/** * 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)); }
/** * 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 <T1, T2, T3> Tuple3<LinkedHashSet<T1>, LinkedHashSet<T2>, LinkedHashSet<T3>> unzip3( Function<? super T, Tuple3<? extends T1, ? extends T2, ? extends T3>> unzipper) { Objects.requireNonNull(unzipper, "unzipper is null"); final Tuple3<Iterator<T1>, Iterator<T2>, Iterator<T3>> t = iterator().unzip3(unzipper); return Tuple.of(LinkedHashSet.ofAll(t._1), LinkedHashSet.ofAll(t._2), LinkedHashSet.ofAll(t._3)); }
/** * Creates a LinkedHashSet that contains the elements of the given {@link java.util.stream.Stream}. * * @param javaStream A {@link java.util.stream.Stream} * @param <T> Component type of the Stream. * @return A LinkedHashSet containing the given elements in the same order. */ public static <T> LinkedHashSet<T> ofAll(java.util.stream.Stream<? extends T> javaStream) { Objects.requireNonNull(javaStream, "javaStream is null"); return ofAll(Iterator.ofAll(javaStream.iterator())); }
/** * Creates a LinkedHashSet from float values. * * @param elements a float values * @return A new LinkedHashSet of Float values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Float> ofAll(float... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
/** * Creates a LinkedHashSet from boolean values. * * @param elements boolean values * @return A new LinkedHashSet of Boolean values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Boolean> ofAll(boolean... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
/** * Creates a LinkedHashSet from byte values. * * @param elements byte values * @return A new LinkedHashSet of Byte values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Byte> ofAll(byte... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
/** * Creates a LinkedHashSet from int values. * * @param elements int values * @return A new LinkedHashSet of Integer values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Integer> ofAll(int... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
/** * Creates a LinkedHashSet from double values. * * @param elements double values * @return A new LinkedHashSet of Double values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Double> ofAll(double... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
/** * Creates a LinkedHashSet from long values. * * @param elements long values * @return A new LinkedHashSet of Long values * @throws NullPointerException if elements is null */ public static LinkedHashSet<Long> ofAll(long... elements) { Objects.requireNonNull(elements, "elements is null"); return LinkedHashSet.ofAll(Iterator.ofAll(elements)); }
@Override public <U, R> LinkedHashSet<R> zipWith(Iterable<? extends U> that, BiFunction<? super T, ? super U, ? extends R> mapper) { Objects.requireNonNull(that, "that is null"); Objects.requireNonNull(mapper, "mapper is null"); return LinkedHashSet.ofAll(iterator().zipWith(that, mapper)); }
@Override public <T1, T2> Tuple2<LinkedHashSet<T1>, LinkedHashSet<T2>> unzip( Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper) { Objects.requireNonNull(unzipper, "unzipper is null"); final Tuple2<Iterator<T1>, Iterator<T2>> t = iterator().unzip(unzipper); return Tuple.of(LinkedHashSet.ofAll(t._1), LinkedHashSet.ofAll(t._2)); }
@Override public <U> LinkedHashSet<T> distinctBy(Function<? super T, ? extends U> keyExtractor) { Objects.requireNonNull(keyExtractor, "keyExtractor is null"); return LinkedHashSet.ofAll(iterator().distinctBy(keyExtractor)); }
@Override public LinkedHashSet<T> distinctBy(Comparator<? super T> comparator) { Objects.requireNonNull(comparator, "comparator is null"); return LinkedHashSet.ofAll(iterator().distinctBy(comparator)); }
@Override public <U> LinkedHashSet<U> zipWithIndex(BiFunction<? super T, ? super Integer, ? extends U> mapper) { Objects.requireNonNull(mapper, "mapper is null"); return LinkedHashSet.ofAll(iterator().zipWithIndex(mapper)); }
@Override public LinkedHashSet<T> dropRight(int n) { if (n <= 0) { return this; } else { return LinkedHashSet.ofAll(iterator().dropRight(n)); } }
@Override public LinkedHashSet<T> takeRight(int n) { if (map.size() <= n) { return this; } return LinkedHashSet.ofAll(() -> iterator().takeRight(n)); }
@Override public LinkedHashSet<T> take(int n) { if (map.size() <= n) { return this; } return LinkedHashSet.ofAll(() -> iterator().take(n)); }
@Override public LinkedHashSet<T> dropWhile(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); final LinkedHashSet<T> dropped = LinkedHashSet.ofAll(iterator().dropWhile(predicate)); return dropped.length() == length() ? this : dropped; }
@Override public LinkedHashSet<T> filter(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); final LinkedHashSet<T> filtered = LinkedHashSet.ofAll(iterator().filter(predicate)); return filtered.length() == length() ? this : filtered; }