Skip to content

Commit ebeebf3

Browse files
rjokelairjokelai
committed
Merge pull request #8 from NitorCreations/feature/nmaps
Add utilities for creating maps and sets
2 parents 82da83e + f0076f8 commit ebeebf3

File tree

12 files changed

+797
-4
lines changed

12 files changed

+797
-4
lines changed

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

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

0 commit comments

Comments
 (0)