forked from wertzber/CodeSamples
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Advance.java
143 lines (116 loc) · 4.16 KB
/
Advance.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package lambda;
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
/**
*
* Created by eladw on 12/23/2014.
*/
public class Advance {
List<Person> persons = null;
//test
public Advance(){
persons = Arrays.asList(
new Person("Max", 18),
new Person("Peter", 23),
new Person("Peter2", 25),
new Person("Pamela", 23),
new Person("David", 12));
}
public static void main(String args[]){
Advance advance = new Advance();
advance.toMap();
}
/**
* Collect is an extremely useful terminal operation to transform the elements of the stream into a different kind of result,
* e.g. a List, Set or Map.
* Collect accepts a Collector which consists of four different operations:
* a supplier, an accumulator, a combiner and a finisher.
* This sounds super complicated at first, but the good part is Java 8 supports various built-in collectors via the Collectors class.
* So for the most common operations you don't have to implement a collector yourself.
*/
public void collect(){
List<Person> filtered =
persons
.stream()
.filter(p -> p.name.startsWith("P"))
.collect(Collectors.toList());
System.out.println(filtered); // [Peter, Pamela]
filtered.remove(0);
System.out.println(persons); // [Peter, Pamela]
// Set<Person> filtered2 =
// persons
// .stream()
// .filter(p -> p.name.startsWith("P"))
// .collect(Collectors.toSet());
//
// System.out.println(filtered2); // [
}
/**
* Group results
*/
public void group(){
Map<Integer, List<Person>> personsByAge = persons
.stream()
.collect(Collectors.groupingBy(p -> p.age));
personsByAge
.forEach((age, p) -> System.out.format("age %s: %s\n", age, p));
}
/**
* Average on collection
*/
public void avg(){
Double averageAge = persons
.stream()
.collect(Collectors.averagingInt(p -> p.age));
System.out.println(averageAge); // 19.0
}
/**
* Stats new objects
* IntSummaryStatistics{count=5, sum=99, min=12, average=19.800000, max=23}
*/
public void stat(){
IntSummaryStatistics ageSummary =
persons
.stream()
.collect(Collectors.summarizingInt(p -> p.age));
System.out.println(ageSummary);
}
/**
* join string
* In Germany Max and Peter and Peter2 and Pamela are of legal age.
*/
public void join(){
String phrase = persons
.stream()
.filter(p -> p.age >= 18)
.map(p -> p.name)
.collect(Collectors.joining(" and ", "In Germany ", " are of legal age."));
System.out.println(phrase);
}
/**
* from list to map(key,value,merger)
*{18=Max, 23=Peter;Pamela, 25=Peter2, 12=David}
*/
public void toMap(){
Map<Integer, String> map = persons
.stream()
.collect(Collectors.toMap(
p -> p.age, //key
p -> p.name, //value
(name1, name2) -> name1 + ";" + name2)); //merger
System.out.println(map);
}
public void newCollector(){
Collector<Person, StringJoiner, String> personNameCollector =
Collector.of(
() -> new StringJoiner(" |--|"), // supplier
(j, p) -> j.add(p.name + p.age), // accumulator
(j1, j2) -> j1.merge(j2), // combiner
StringJoiner::toString); // finisher
String names = persons
.stream()
.collect(personNameCollector);
System.out.println(names); // MAX | PETER | PAMELA | DAVID
}
}