Package: CollectionHelper

CollectionHelper

name	instruction	branch	complexity	line	method
concat(Collection, Collection)	M: 0 C: 9 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
createList(Object[])	M: 0 C: 3 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
createSet(Object[])	M: 0 C: 6 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
intersect(Collection, Collection)	M: 12 C: 0 0%	M: 0 C: 0 100%	M: 1 C: 0 0%	M: 1 C: 0 0%	M: 1 C: 0 0%

Coverage

1: package util;
2:
3: import java.util.Arrays;
4: import java.util.Collection;
5: import java.util.HashSet;
6: import java.util.List;
7: import java.util.Set;
8: import java.util.stream.Collectors;
9: import java.util.stream.Stream;
10:
11: /**
12: * Hilfsklasse für Kollektionen.
13: */
14: public final class CollectionHelper {
15:
16:         private CollectionHelper() {
17:
18:         }
19:
20:         /**
21:          * vereinigt die beiden übergebenen Collections, achtet dabei jedoch nicht auf Dopplungen. Diese können durchaus vorkommen.
22:          * <p>
23:          * Beispiele:
24:          * <p>
25:          * concat([a, b, c], [d, e]) wird zu [a, b, c, d, e]
26:          * <p>
27:          * concat([a, b, c], [c, d, e]) wird zu [a, b, c, c, d, e] //hier ist c nun doppelt.
28:          *
29:          * @param collection1
30:          *                 erste zu vereinigende Collection.
31:          * @param collection2
32:          *                 zweite zu vereinigende Collection.
33:          * @param <T>
34:          *                 Typ der Elemente in der zurückgegebenen, sowie den eingehenden Listen
35:          *
36:          * @return Konkatenation der beiden Collections.
37:          */
38:         public static <T> List<T> concat(final Collection<? extends T> collection1, final Collection<? extends T> collection2) {
39:                 return Stream.concat(collection1.stream(), collection2.stream()).collect(Collectors.toList());
40:         }
41:
42:         /**
43:          * @param c1
44:          *                 Menge, die mit c2 geschnitten werden soll.
45:          * @param c2
46:          *                 Menge, die mit c1 geschnitten werden soll.
47:          * @param <T>
48:          *                 Rückgabedatentyp
49:          *
50:          * @return liefert die Schnittmenge der Mengen c1 und c2.
51:          */
52:         public static <T> List<T> intersect(final Collection<? extends T> c1, final Collection<? extends T> c2) {
53:                 return c1.stream().filter(c2::contains).collect(Collectors.toList());
54:         }
55:
56:         /**
57:          * Erstellt eine Liste.
58:          *
59:          * @param <T>
60:          *                 Typ
61:          * @param t
62:          *                 Werte
63:          *
64:          * @return Liste.
65:          */
66:         @SafeVarargs
67:         public static <T> List<T> createList(final T... t) {
68:                 return Arrays.asList(t);
69:         }
70:
71:         /**
72:          * Erstellt ein Set.
73:          *
74:          * @param <T>
75:          *                 Typ
76:          * @param t
77:          *                 Werte
78:          *
79:          * @return Set.
80:          */
81:         @SafeVarargs
82:         public static <T> Set<T> createSet(final T... t) {
83:                 return new HashSet<>(Arrays.asList(t));
84:         }
85: }