Skip to content

Commit 2dbb466

Browse files
author
Reko Jokelainen
committed
feat(utils): add NMaps and NSets utility classes
1 parent c5780ea commit 2dbb466

File tree

6 files changed

+749
-1
lines changed

6 files changed

+749
-1
lines changed

‎src/main/java/com/nitorcreations/streams/NMaps.java

Lines changed: 387 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,387 @@
1+
package com.nitorcreations.streams;
2+
3+
import java.util.*;
4+
import java.util.function.BinaryOperator;
5+
import java.util.function.Function;
6+
import java.util.stream.IntStream;
7+
8+
import static com.nitorcreations.streams.NCollectors.entriesToMap;
9+
import static com.nitorcreations.streams.NMappers.entryOf;
10+
11+
public final class NMaps {
12+
private NMaps() { /** prevent instantiation */}
13+
14+
/*
15+
Map<String, Integer> aMap = NMaps.mapOf(entryOf("a", 1), entryOf("c", 2), ...);
16+
Map<String, Integer> bMap = NMaps.mapOf("a", 1, "c", 2, ...); // Up to five entries
17+
Map<String, Integer> bMap = NMaps.mapping(asList("a", "bee", "cheetah"), s -> s.length()); // Map from keys
18+
*/
19+
20+
/**
21+
* Create a map of an arbitrary amount of map entries. Will throw exception on duplicate keys.
22+
* @param entries entries to collect to a map
23+
* @param <K> the key type
24+
* @param <V> the value type
25+
* @return the new map
26+
* @see NCollectors#entriesToMap()
27+
*/
28+
@SafeVarargs
29+
public static <K,V> Map<K, V> mapOfEntries(Map.Entry<K, V>... entries) {
30+
return Arrays.stream(entries).collect(entriesToMap());
31+
}
32+
33+
/**
34+
* Create a map with keys mapped to values by the {@code valueFn}. The values are evaluated
35+
* eagerly and stored immediately.
36+
*
37+
* @param keys the keys to map
38+
* @param valueFn the function mapping keys to values
39+
* @param <K> type of key
40+
* @param <V> type of values
41+
* @return the map
42+
*/
43+
public static <K, V> Map<K, V> mapping(Set<K> keys, Function<K, V> valueFn) {
44+
return keys.stream()
45+
.map(k -> entryOf(k, valueFn.apply(k)))
46+
.collect(entriesToMap());
47+
}
48+
49+
/**
50+
* Create a map of the list of keys and list of values. Values are associated by the index
51+
* in the list.
52+
* <p>
53+
* Will throw exception if sizes differ or either one is {@code null}.
54+
* <p>
55+
*
56+
*
57+
* @param keys
58+
* @param values
59+
* @param <K>
60+
* @param <V>
61+
* @return
62+
*/
63+
public static <K,V> Map<K, V> mapOfLists(List<K> keys, List<V> values) {
64+
if (keys.size() != values.size()) {
65+
throw new IllegalArgumentException(String.format("Keys and values sizes differ: %d != %d", keys.size(), values.size()));
66+
}
67+
return IntStream.range(0, keys.size())
68+
.mapToObj(i -> entryOf(keys.get(i), values.get(i)))
69+
.collect(entriesToMap());
70+
}
71+
72+
/**
73+
* Combine multiple maps to a single one. Will throw exception on duplicate keys.
74+
* If duplicate values are expected, use {@link #combine(BinaryOperator, Map[])}
75+
*
76+
* @param maps the maps to combine
77+
* @param <K> the key type
78+
* @param <V> the value type
79+
* @return the resulting combined map
80+
*/
81+
public static <K,V> Map<K, V> combine(Map<K, V>... maps) {
82+
return Arrays.stream(maps)
83+
.flatMap(m -> m.entrySet().stream())
84+
.collect(entriesToMap());
85+
}
86+
87+
/**
88+
* Combine multiple maps to a single one. Uses {@code mergeFn} to cope with duplicate keys.
89+
*
90+
* @param maps the maps to combine
91+
* @param mergeFn the function to combine values on duplicate keys
92+
* @param <K> the key type
93+
* @param <V> the value type
94+
* @return the resulting combined map
95+
*/
96+
public static <K,V> Map<K, V> combine(BinaryOperator<V> mergeFn, Map<K, V>... maps) {
97+
return Arrays.stream(maps)
98+
.flatMap(m -> m.entrySet().stream())
99+
.collect(entriesToMap(mergeFn));
100+
}
101+
102+
/**
103+
* Combine multiple maps to a single one. Uses the first encountered value as the value
104+
* on duplicate keys.
105+
*
106+
* @param maps the maps to combine
107+
* @param <K> the key type
108+
* @param <V> the value type
109+
* @return the resulting combined map
110+
*/
111+
public static <K,V> Map<K, V> combineAndSkip(Map<K, V>... maps) {
112+
return combine((V v1, V v2) -> v1, maps);
113+
}
114+
115+
/**
116+
* Create a map with the given values
117+
* @param k1 key
118+
* @param v1 value
119+
* @param <K> type of key
120+
* @param <V> type of value
121+
* @return the map
122+
*/
123+
public static <K, V> Map<K, V> mapOf(K k1, V v1) {
124+
return mapOfEntries(entryOf(k1, v1));
125+
}
126+
127+
/**
128+
* Create a map with the given values
129+
* @param k1 key
130+
* @param v1 value
131+
* @param k2 key
132+
* @param v2 value
133+
* @param <K> type of key
134+
* @param <V> type of value
135+
* @return the map
136+
*/
137+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2) {
138+
return combine(
139+
mapOf(k1, v1),
140+
mapOf(k2, v2)
141+
);
142+
}
143+
144+
/**
145+
*
146+
* @param k1 key
147+
* @param v1 value
148+
* @param k2 key
149+
* @param v2 value
150+
* @param k3 key
151+
* @param v3 value
152+
* @param <K> key type
153+
* @param <V> value type
154+
* @return a map with the values
155+
*/
156+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3) {
157+
return combine(
158+
mapOf(k1, v1),
159+
mapOf(k2, v2),
160+
mapOf(k3, v3)
161+
);
162+
}
163+
164+
/**
165+
*
166+
* @param k1 key
167+
* @param v1 value
168+
* @param k2 key
169+
* @param v2 value
170+
* @param k3 key
171+
* @param v3 value
172+
* @param k4 key
173+
* @param v4 value
174+
* @param <K> key type
175+
* @param <V> value type
176+
* @return a map with the values
177+
*/
178+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
179+
return combine(
180+
mapOf(k1, v1),
181+
mapOf(k2, v2),
182+
mapOf(k3, v3),
183+
mapOf(k4, v4)
184+
);
185+
}
186+
187+
/**
188+
*
189+
* @param k1 key
190+
* @param v1 value
191+
* @param k2 key
192+
* @param v2 value
193+
* @param k3 key
194+
* @param v3 value
195+
* @param k4 key
196+
* @param v4 value
197+
* @param k5 key
198+
* @param v5 value
199+
* @param <K> key type
200+
* @param <V> value type
201+
* @return a map with the values
202+
*/
203+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
204+
return combine(
205+
mapOf(k1, v1),
206+
mapOf(k2, v2),
207+
mapOf(k3, v3),
208+
mapOf(k4, v4),
209+
mapOf(k5, v5)
210+
);
211+
}
212+
213+
/**
214+
*
215+
* @param k1 key
216+
* @param v1 value
217+
* @param k2 key
218+
* @param v2 value
219+
* @param k3 key
220+
* @param v3 value
221+
* @param k4 key
222+
* @param v4 value
223+
* @param k5 key
224+
* @param v5 value
225+
* @param k6 key
226+
* @param v6 value
227+
* @param <K> key type
228+
* @param <V> value type
229+
* @return a map with the values
230+
*/
231+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
232+
return combine(
233+
mapOf(k1, v1),
234+
mapOf(k2, v2),
235+
mapOf(k3, v3),
236+
mapOf(k4, v4),
237+
mapOf(k5, v5),
238+
mapOf(k6, v6)
239+
);
240+
}
241+
242+
/**
243+
*
244+
* @param k1 key
245+
* @param v1 value
246+
* @param k2 key
247+
* @param v2 value
248+
* @param k3 key
249+
* @param v3 value
250+
* @param k4 key
251+
* @param v4 value
252+
* @param k5 key
253+
* @param v5 value
254+
* @param k6 key
255+
* @param v6 value
256+
* @param k7 key
257+
* @param v7 value
258+
* @param <K> key type
259+
* @param <V> value type
260+
* @return a map with the values
261+
*/
262+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
263+
return combine(
264+
mapOf(k1, v1),
265+
mapOf(k2, v2),
266+
mapOf(k3, v3),
267+
mapOf(k4, v4),
268+
mapOf(k5, v5),
269+
mapOf(k6, v6),
270+
mapOf(k7, v7)
271+
);
272+
}
273+
274+
/**
275+
*
276+
* @param k1 key
277+
* @param v1 value
278+
* @param k2 key
279+
* @param v2 value
280+
* @param k3 key
281+
* @param v3 value
282+
* @param k4 key
283+
* @param v4 value
284+
* @param k5 key
285+
* @param v5 value
286+
* @param k6 key
287+
* @param v6 value
288+
* @param k7 key
289+
* @param v7 value
290+
* @param k8 key
291+
* @param v8 value
292+
* @param <K> key type
293+
* @param <V> value type
294+
* @return a map with the values
295+
*/
296+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
297+
return combine(
298+
mapOf(k1, v1),
299+
mapOf(k2, v2),
300+
mapOf(k3, v3),
301+
mapOf(k4, v4),
302+
mapOf(k5, v5),
303+
mapOf(k6, v6),
304+
mapOf(k7, v7),
305+
mapOf(k8, v8)
306+
);
307+
}
308+
309+
/**
310+
*
311+
* @param k1 key
312+
* @param v1 value
313+
* @param k2 key
314+
* @param v2 value
315+
* @param k3 key
316+
* @param v3 value
317+
* @param k4 key
318+
* @param v4 value
319+
* @param k5 key
320+
* @param v5 value
321+
* @param k6 key
322+
* @param v6 value
323+
* @param k7 key
324+
* @param v7 value
325+
* @param k8 key
326+
* @param v8 value
327+
* @param k9 key
328+
* @param v9 value
329+
* @param <K> key type
330+
* @param <V> value type
331+
* @return a map with the values
332+
*/
333+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
334+
return combine(
335+
mapOf(k1, v1),
336+
mapOf(k2, v2),
337+
mapOf(k3, v3),
338+
mapOf(k4, v4),
339+
mapOf(k5, v5),
340+
mapOf(k6, v6),
341+
mapOf(k7, v7),
342+
mapOf(k8, v8),
343+
mapOf(k9, v9)
344+
);
345+
}
346+
347+
/**
348+
*
349+
* @param k1 key
350+
* @param v1 value
351+
* @param k2 key
352+
* @param v2 value
353+
* @param k3 key
354+
* @param v3 value
355+
* @param k4 key
356+
* @param v4 value
357+
* @param k5 key
358+
* @param v5 value
359+
* @param k6 key
360+
* @param v6 value
361+
* @param k7 key
362+
* @param v7 value
363+
* @param k8 key
364+
* @param v8 value
365+
* @param k9 key
366+
* @param v9 value
367+
* @param k10 key
368+
* @param v10 value
369+
* @param <K> key type
370+
* @param <V> value type
371+
* @return a map with the values
372+
*/
373+
public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
374+
return combine(
375+
mapOf(k1, v1),
376+
mapOf(k2, v2),
377+
mapOf(k3, v3),
378+
mapOf(k4, v4),
379+
mapOf(k5, v5),
380+
mapOf(k6, v6),
381+
mapOf(k7, v7),
382+
mapOf(k8, v8),
383+
mapOf(k9, v9),
384+
mapOf(k10, v10)
385+
);
386+
}
387+
}

0 commit comments

Comments
 (0)