/** * Returns a {@link Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(Collector)} to obtain a * {@link TreeMap}. * * @param <K> The key type * @param <V> The value type * @param keyComparator The comparator used to sort the entries by their key. * @return A {@link TreeMap} Collector. */ public static <K, V> Collector<Tuple2<K, V>, ArrayList<Tuple2<K, V>>, TreeMap<K, V>> collector(Comparator<? super K> keyComparator) { return createCollector(EntryComparator.of(keyComparator)); }
/** * Returns a {@link Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(Collector)} to obtain a * {@link TreeMap}. * <p> * The natural comparator is used to compare TreeMap keys. * * @param <K> The key type * @param <V> The value type * @return A {@link TreeMap} Collector. */ public static <K extends Comparable<? super K>, V> Collector<Tuple2<K, V>, ArrayList<Tuple2<K, V>>, TreeMap<K, V>> collector() { return createCollector(EntryComparator.natural()); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * <p> * The natural comparator is used to compare TreeMap keys. * * @param keyMapper The key mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @return A {@link TreeMap} Collector. */ public static <K extends Comparable<? super K>, V, T extends V> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Function<? super T, ? extends K> keyMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); return createCollector(EntryComparator.natural(), keyMapper, v -> v); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * * @param keyMapper The key mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @param keyComparator The comparator used to sort the entries by their key. * @return A {@link TreeMap} Collector. */ public static <K, V, T extends V> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Comparator<? super K> keyComparator, Function<? super T, ? extends K> keyMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); return createCollector(EntryComparator.of(keyComparator), keyMapper, v -> v); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * <p> * The natural comparator is used to compare TreeMap keys. * * @param keyMapper The key mapper * @param valueMapper The value mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @return A {@link TreeMap} Collector. */ public static <K extends Comparable<? super K>, V, T> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); Objects.requireNonNull(valueMapper, "valueMapper is null"); return createCollector(EntryComparator.natural(), keyMapper, valueMapper); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * * @param keyMapper The key mapper * @param valueMapper The value mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @param keyComparator The comparator used to sort the entries by their key. * @return A {@link TreeMap} Collector. */ public static <K, V, T> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Comparator<? super K> keyComparator, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); Objects.requireNonNull(valueMapper, "valueMapper is null"); return createCollector(EntryComparator.of(keyComparator), keyMapper, valueMapper); }
/** * Returns a {@link Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(Collector)} to obtain a * {@link TreeMap}. * * @param <K> The key type * @param <V> The value type * @param keyComparator The comparator used to sort the entries by their key. * @return A {@link TreeMap} Collector. */ public static <K, V> Collector<Tuple2<K, V>, ArrayList<Tuple2<K, V>>, TreeMap<K, V>> collector(Comparator<? super K> keyComparator) { return createCollector(EntryComparator.of(keyComparator)); }
/** * Returns a {@link Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(Collector)} to obtain a * {@link TreeMap}. * <p> * The natural comparator is used to compare TreeMap keys. * * @param <K> The key type * @param <V> The value type * @return A {@link TreeMap} Collector. */ public static <K extends Comparable<? super K>, V> Collector<Tuple2<K, V>, ArrayList<Tuple2<K, V>>, TreeMap<K, V>> collector() { return createCollector(EntryComparator.natural()); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * <p> * The natural comparator is used to compare TreeMap keys. * * @param keyMapper The key mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @return A {@link TreeMap} Collector. */ public static <K extends Comparable<? super K>, V, T extends V> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Function<? super T, ? extends K> keyMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); return createCollector(EntryComparator.natural(), keyMapper, v -> v); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * * @param keyMapper The key mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @param keyComparator The comparator used to sort the entries by their key. * @return A {@link TreeMap} Collector. */ public static <K, V, T extends V> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Comparator<? super K> keyComparator, Function<? super T, ? extends K> keyMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); return createCollector(EntryComparator.of(keyComparator), keyMapper, v -> v); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * * @param keyMapper The key mapper * @param valueMapper The value mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @param keyComparator The comparator used to sort the entries by their key. * @return A {@link TreeMap} Collector. */ public static <K, V, T> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Comparator<? super K> keyComparator, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); Objects.requireNonNull(valueMapper, "valueMapper is null"); return createCollector(EntryComparator.of(keyComparator), keyMapper, valueMapper); }
/** * Returns a {@link java.util.stream.Collector} which may be used in conjunction with * {@link java.util.stream.Stream#collect(java.util.stream.Collector)} to obtain a {@link TreeMap}. * <p> * The natural comparator is used to compare TreeMap keys. * * @param keyMapper The key mapper * @param valueMapper The value mapper * @param <K> The key type * @param <V> The value type * @param <T> Initial {@link java.util.stream.Stream} elements type * @return A {@link TreeMap} Collector. */ public static <K extends Comparable<? super K>, V, T> Collector<T, ArrayList<T>, TreeMap<K, V>> collector( Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) { Objects.requireNonNull(keyMapper, "key comparator is null"); Objects.requireNonNull(keyMapper, "keyMapper is null"); Objects.requireNonNull(valueMapper, "valueMapper is null"); return createCollector(EntryComparator.natural(), keyMapper, valueMapper); }