private LinkedHashMap<K, V> createFromEntries(Iterable<Tuple2<K, V>> tuples) { return LinkedHashMap.ofEntries(tuples); }
/** * Alias for {@link LinkedHashMap#ofEntries(Tuple2...)} * * @param <K> The key type. * @param <V> The value type. * @param entries Map entries. * @return A new {@link LinkedHashMap} instance containing the given entries * @deprecated Will be removed in a future version. */ @Deprecated @SuppressWarnings("varargs") @SafeVarargs public static <K, V> Map<K, V> LinkedMap(Tuple2<? extends K, ? extends V>... entries) { return LinkedHashMap.ofEntries(entries); }
@Override public LinkedHashMap<K, V> orElse(Supplier<? extends Iterable<? extends Tuple2<K, V>>> supplier) { return isEmpty() ? ofEntries(supplier.get()) : this; }
@Override public LinkedHashMap<K, V> orElse(Iterable<? extends Tuple2<K, V>> other) { return isEmpty() ? ofEntries(other) : this; }
/** * Returns a LinkedHashMap containing {@code n} values of a given Function {@code f} * over a range of integer values from 0 to {@code n - 1}. * * @param <K> The key type * @param <V> The value type * @param n The number of elements in the LinkedHashMap * @param f The Function computing element values * @return A LinkedHashMap consisting of elements {@code f(0),f(1), ..., f(n - 1)} * @throws NullPointerException if {@code f} is null */ @SuppressWarnings("unchecked") public static <K, V> LinkedHashMap<K, V> tabulate(int n, Function<? super Integer, ? extends Tuple2<? extends K, ? extends V>> f) { Objects.requireNonNull(f, "f is null"); return ofEntries(Collections.tabulate(n, (Function<? super Integer, ? extends Tuple2<K, V>>) f)); }
/** * Returns a LinkedHashMap containing tuples returned by {@code n} calls to a given Supplier {@code s}. * * @param <K> The key type * @param <V> The value type * @param n The number of elements in the LinkedHashMap * @param s The Supplier computing element values * @return A LinkedHashMap of size {@code n}, where each element contains the result supplied by {@code s}. * @throws NullPointerException if {@code s} is null */ @SuppressWarnings("unchecked") public static <K, V> LinkedHashMap<K, V> fill(int n, Supplier<? extends Tuple2<? extends K, ? extends V>> s) { Objects.requireNonNull(s, "s is null"); return ofEntries(Collections.fill(n, (Supplier<? extends Tuple2<K, V>>) s)); }
@Override public LinkedHashMap<K, V> init() { if (isEmpty()) { throw new UnsupportedOperationException("init of empty LinkedHashMap"); } else { return LinkedHashMap.ofEntries(list.init()); } }
@Override public LinkedHashMap<K, V> tail() { if (isEmpty()) { throw new UnsupportedOperationException("tail of empty LinkedHashMap"); } else { return LinkedHashMap.ofEntries(list.tail()); } }
@Override public <K2, V2> LinkedHashMap<K2, V2> bimap(Function<? super K, ? extends K2> keyMapper, Function<? super V, ? extends V2> valueMapper) { Objects.requireNonNull(keyMapper, "keyMapper is null"); Objects.requireNonNull(valueMapper, "valueMapper is null"); final Iterator<Tuple2<K2, V2>> entries = iterator().map(entry -> Tuple.of(keyMapper.apply(entry._1), valueMapper.apply(entry._2))); return LinkedHashMap.ofEntries(entries); }
/** * 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 LinkedHashMap}. * * @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 LinkedHashMap} Collector. */ public static <K, V, T> Collector<T, ArrayList<T>, LinkedHashMap<K, V>> collector( Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) { Objects.requireNonNull(keyMapper, "keyMapper is null"); Objects.requireNonNull(valueMapper, "valueMapper is null"); final Supplier<ArrayList<T>> supplier = ArrayList::new; final BiConsumer<ArrayList<T>, T> accumulator = ArrayList::add; final BinaryOperator<ArrayList<T>> combiner = (left, right) -> { left.addAll(right); return left; }; final Function<ArrayList<T>, LinkedHashMap<K, V>> finisher = arr -> LinkedHashMap.ofEntries(Iterator.ofAll(arr) .map(t -> Tuple.of(keyMapper.apply(t), valueMapper.apply(t)))); return Collector.of(supplier, accumulator, combiner, finisher); }
private LinkedHashMap<K, V> createFromEntries(Iterable<Tuple2<K, V>> tuples) { return LinkedHashMap.ofEntries(tuples); }
@Override public LinkedHashMap<K, V> orElse(Supplier<? extends Iterable<? extends Tuple2<K, V>>> supplier) { return isEmpty() ? ofEntries(supplier.get()) : this; }
@Override public LinkedHashMap<K, V> orElse(Iterable<? extends Tuple2<K, V>> other) { return isEmpty() ? ofEntries(other) : this; }
/** * Returns a LinkedHashMap containing tuples returned by {@code n} calls to a given Supplier {@code s}. * * @param <K> The key type * @param <V> The value type * @param n The number of elements in the LinkedHashMap * @param s The Supplier computing element values * @return A LinkedHashMap of size {@code n}, where each element contains the result supplied by {@code s}. * @throws NullPointerException if {@code s} is null */ @SuppressWarnings("unchecked") public static <K, V> LinkedHashMap<K, V> fill(int n, Supplier<? extends Tuple2<? extends K, ? extends V>> s) { Objects.requireNonNull(s, "s is null"); return ofEntries(Collections.fill(n, (Supplier<? extends Tuple2<K, V>>) s)); }
@Override public LinkedHashMap<K, V> tail() { if (isEmpty()) { throw new UnsupportedOperationException("tail of empty LinkedHashMap"); } else { return LinkedHashMap.ofEntries(list.tail()); } }
@Override public <K2, V2> LinkedHashMap<K2, V2> bimap(Function<? super K, ? extends K2> keyMapper, Function<? super V, ? extends V2> valueMapper) { Objects.requireNonNull(keyMapper, "keyMapper is null"); Objects.requireNonNull(valueMapper, "valueMapper is null"); final Iterator<Tuple2<K2, V2>> entries = iterator().map(entry -> Tuple.of(keyMapper.apply(entry._1), valueMapper.apply(entry._2))); return LinkedHashMap.ofEntries(entries); }
@Override public LinkedHashMap<K, V> init() { if (isEmpty()) { throw new UnsupportedOperationException("init of empty LinkedHashMap"); } else { return LinkedHashMap.ofEntries(list.init()); } }
@Test public void testLinkedHashMapOfString() throws Exception { Integer src00 = 1; String src01 = "A"; Tuple2<Integer, String> src0 = Tuple.of(src00, src01); LinkedHashMap<Integer, String> src = LinkedHashMap.ofEntries(src0); String json = MAPPER.writeValueAsString(new ParameterizedLinkedHashMapPojo<>(src)); Assert.assertEquals(json, "{\"value\":{\"1\":\"A\"}}"); ParameterizedLinkedHashMapPojo<java.lang.Integer, java.lang.String> restored = MAPPER.readValue(json, new TypeReference<ParameterizedLinkedHashMapPojo<java.lang.Integer, java.lang.String>>(){}); Assert.assertEquals(src, restored.getValue()); }
@Test public void testLinkedHashMapOfString() throws Exception { Integer src00 = 1; String src01 = "A"; Tuple2<Integer, String> src0 = Tuple.of(src00, src01); LinkedHashMap<Integer, String> src = LinkedHashMap.ofEntries(src0); String json = MAPPER.writeValueAsString(new LinkedHashMapOfString().setValue(src)); Assert.assertEquals(json, "{\"value\":{\"1\":\"A\"}}"); LinkedHashMapOfString restored = MAPPER.readValue(json, LinkedHashMapOfString.class); Assert.assertEquals(src, restored.getValue()); }
@Test public void testLinkedHashMapOfTuple() throws Exception { Integer src00 = 1; String src010 = "A"; String src011 = "B"; Tuple2<String, String> src01 = Tuple.of(src010, src011); Tuple2<Integer, Tuple2<String, String>> src0 = Tuple.of(src00, src01); LinkedHashMap<Integer, Tuple2<String, String>> src = LinkedHashMap.ofEntries(src0); String json = MAPPER.writeValueAsString(new LinkedHashMapOfTuple().setValue(src)); Assert.assertEquals(json, "{\"value\":{\"1\":[\"A\",\"B\"]}}"); LinkedHashMapOfTuple restored = MAPPER.readValue(json, LinkedHashMapOfTuple.class); Assert.assertEquals(src, restored.getValue()); }