@Override public LinkedHashSet<T> reject(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); return filter(predicate.negate()); }
/** * Returns a singleton {@code LinkedHashSet}, i.e. a {@code LinkedHashSet} of one element. * * @param element An element. * @param <T> The component type * @return A new LinkedHashSet instance containing the given element */ public static <T> LinkedHashSet<T> of(T element) { return LinkedHashSet.<T> empty().add(element); }
/** * Creates a LinkedHashSet from char values. * * @param elements char values * @return A new LinkedHashSet of Character values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Character> ofAll(char... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
@Test public void testLinkedHashSet() throws Exception { LinkedHashSet<A> src = LinkedHashSet.of(new B("a", "b")); String json = MAPPER.writeValueAsString(new LinkedHashSetPojo().setValue(src)); Assert.assertEquals(json, "{\"value\":[{\"ExtFieldsPojoTest$B\":{\"a\":\"a\",\"b\":\"b\"}}]}"); LinkedHashSetPojo pojo = MAPPER.readValue(json, LinkedHashSetPojo.class); LinkedHashSet<A> restored = pojo.getValue(); Assert.assertEquals(restored.filter(e -> e instanceof B).length(), 1); Assert.assertEquals(restored.head().a, "a"); Assert.assertEquals(((B) restored.head()).b, "b"); }
@Override public <U> LinkedHashSet<U> flatMap(Function<? super T, ? extends Iterable<? extends U>> mapper) { Objects.requireNonNull(mapper, "mapper is null"); if (isEmpty()) { return empty(); } else { final LinkedHashMap<U, Object> that = foldLeft(LinkedHashMap.empty(), (tree, t) -> addAll(tree, mapper.apply(t))); return new LinkedHashSet<>(that); } }
public LinkedHashSet<T> union(Set<? extends T> elements) { Objects.requireNonNull(elements, "elements is null"); if (isEmpty()) { if (elements instanceof LinkedHashSet) { return (LinkedHashSet<T>) elements; } else { return LinkedHashSet.ofAll(elements); final LinkedHashMap<T, Object> that = addAll(map, elements); if (that.size() == map.size()) { return this; } else { return new LinkedHashSet<>(that);
@Test public void testLinkedHashSet() throws Exception { LinkedHashSet<I> src = LinkedHashSet.of(new B()); String json = MAPPER.writeValueAsString(new LinkedHashSetPojo().setValue(src)); Assert.assertEquals(json, "{\"value\":[{\"type\":\"b\"}]}"); LinkedHashSetPojo pojo = MAPPER.readValue(json, LinkedHashSetPojo.class); LinkedHashSet<I> restored = pojo.getValue(); Assert.assertEquals(restored.filter(e -> e instanceof B).length(), 1); }
/** * Alias for {@link LinkedHashSet#of(Object)} * * @param <T> Component type of element. * @param element An element. * @return A new {@link LinkedHashSet} instance containing the given element */ public static <T> Set<T> LinkedSet(T element) { return LinkedHashSet.of(element); }
/** * Creates a LinkedHashSet of the given elements. * * @param elements Set elements * @param <T> The value type * @return A new LinkedHashSet containing the given entries */ @SuppressWarnings("unchecked") public static <T> LinkedHashSet<T> ofAll(Iterable<? extends T> elements) { Objects.requireNonNull(elements, "elements is null"); if (elements instanceof LinkedHashSet) { return (LinkedHashSet<T>) elements; } else { final LinkedHashMap<T, Object> mao = addAll(LinkedHashMap.empty(), elements); return mao.isEmpty() ? empty() : new LinkedHashSet<>(mao); } }
/** * Adds all of the given elements to this set, replacing existing one if they are not already contained. * <p> * Note that this method has a worst-case quadratic complexity. * * @param elements The elements to be added. * @return A new set containing all elements of this set and the given {@code elements}, if not already contained. */ @Override public LinkedHashSet<T> addAll(Iterable<? extends T> elements) { Objects.requireNonNull(elements, "elements is null"); if (isEmpty() && elements instanceof LinkedHashSet) { @SuppressWarnings("unchecked") final LinkedHashSet<T> set = (LinkedHashSet<T>) elements; return set; } final LinkedHashMap<T, Object> that = addAll(map, elements); if (that.size() == map.size()) { return this; } else { return new LinkedHashSet<>(that); } }
/** * Add the given element to this set, replacing existing one if it is already contained. * <p> * Note that this method has a worst-case linear complexity. * * @param element The element to be added. * @return A new set containing all elements of this set and also {@code element}. */ @Override public LinkedHashSet<T> add(T element) { return contains(element) ? this : new LinkedHashSet<>(map.put(element, element)); }
/** * {@code readResolve} method for the serialization proxy pattern. * <p> * Returns a logically equivalent instance of the enclosing class. The presence of this method causes the * serialization system to translate the serialization proxy back into an instance of the enclosing class * upon deserialization. * * @return A deserialized instance of the enclosing class. */ private Object readResolve() { return map.isEmpty() ? LinkedHashSet.empty() : new LinkedHashSet<>(map); } }
static <T> LinkedHashSet<T> wrap(LinkedHashMap<T, Object> map) { return new LinkedHashSet<>(map); }
/** * Creates a LinkedHashSet from short values. * * @param elements short values * @return A new LinkedHashSet of Short values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Short> ofAll(short... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
@Override public <U> LinkedHashSet<U> map(Function<? super T, ? extends U> mapper) { Objects.requireNonNull(mapper, "mapper is null"); if (isEmpty()) { return empty(); } else { final LinkedHashMap<U, Object> that = foldLeft(LinkedHashMap.empty(), (tree, t) -> { final U u = mapper.apply(t); return tree.put(u, u); }); return new LinkedHashSet<>(that); } }