你们好，最近小活发现有诸多的小伙伴们对于jdk8新特性详解，jdk1 8新特性这个问题都颇为感兴趣的，今天小活为大家梳理了下，一起往下看看吧。
1、1、创建Stream
2、package com.stream.api1;
3、import java.util.ArrayList;
4、import java.util.Arrays;
5、import java.util.List;
6、import java.util.stream.Stream;
7、import org.junit.Test;
8、/**
9、* 一 、 Stream 的三个操作步骤 1、创建Stream 2、中级操作 3、终止操作（终端操作）
10、*
11、* @author Administrator
12、*
13、*/
14、public class TestStreamAPI1 {
15、 // 创建Stream
16、 @Test
17、 public void test1() {
18、 // 1、可以通过Collection 系列集合提供的stream()或parallelStream()
19、 List<String> list = new ArrayList<String>();
20、 Stream<String> stream1 = list.stream();
21、 // 2、通过Arrays中的静态方法stream()获取数组流
22、 Employee[] ems = new Employee[10];
23、 Stream<Employee> stream2 = Arrays.stream(ems);
24、 // 3、通过Stream类中的静态方法of()
25、 Stream<String> stream3 = Stream.of("aa", "bb", "cc", "dd");
26、 // 4、创建无限流
27、 Stream<Integer> stream4 = Stream.iterate(0, x -> x + 2);
28、 // stream4.forEach(System.out::println);
29、 stream4.limit(10).forEach(System.out::println);
30、 // 生成
31、 Stream.generate(() -> Math.random()).limit(5).forEach(System.out::println);
32、 }
33、}
34、2、Stream筛选和切片
35、package com.stream.api2;
36、import java.util.Arrays;
37、import java.util.Iterator;
38、import java.util.List;
39、import java.util.stream.Stream;
40、import org.junit.Test;
41、import com.stream.api1.Employee;
42、/**
43、* 一 、 Stream 的三个操作步骤 1、创建Stream 2、中级操作 3、终止操作（终端操作）
44、*
45、* @author Administrator
46、*
47、*/
48、public class TestStreamAPI2 {
49、 List<Employee> employees = Arrays.asList(new Employee("张三", 12, 1200.99), new Employee("小明", 15, 4500.99),
50、 new Employee("小丽", 16, 5500.99), new Employee("王二", 32, 1100.99), new Employee("二虎", 22, 9825.99),
51、 new Employee("李静", 18, 4502.99), new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99),
52、 new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99));
53、 // 中间操作
54、 /**
55、 * 筛选与切片 filter —— 接收Lambda，从流中排除某些元素 limit —— 截断流，使其元素不超过给定数量。 skip(n) ——
56、 * 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补 distinct ——
57、 * 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
58、 *
59、 *
60、 * 注意：使用distinct去重需要重写hashcode和equals方法
61、 */
62、 // 内部迭代：迭代操作有Stream API完成。
63、 @Test
64、 public void test1() {
65、 // 中间操作：不会执行任何操作
66、 Stream<Employee> stream1 = employees.stream().filter((e) -> {
67、 System.out.println("Stream API中间操作");
68、 return e.getAge() > 17;
69、 });
70、 // 终止操作：一次性执行全部内容，即“惰性求值”
71、 stream1.forEach(System.out::println);
72、 }
73、 // 外部迭代
74、 @Test
75、 public void test2() {
76、 Iterator<Employee> it = employees.iterator();
77、 while (it.hasNext()) {
78、 System.out.println(it.next());
79、 }
80、 }
81、 // 短路，limit一旦找到合适的数据将不再继续执行，一定程度上提高了性能
82、 @Test
83、 public void test3() {
84、 employees.stream().filter((e) -> {
85、 System.out.println("短路！");
86、 return e.getSalary() > 5000;
87、 }).limit(2).forEach(System.out::println);
88、 ;
89、 }
90、 @Test
91、 public void test4() {
92、 employees.stream().filter((e) -> e.getSalary() > 1000).skip(2).limit(2).forEach(System.out::println);
93、 ;
94、 }
95、 @Test
96、 public void test5() {
97、 employees.stream().filter((e) -> e.getSalary() > 1000).skip(2).distinct().forEach(System.out::println);
98、 ;
99、 }
100、}
101、/3、Stream映射
102、package com.stream.api3;
103、import java.util.ArrayList;
104、import java.util.Arrays;
105、import java.util.List;
106、import java.util.stream.Stream;
107、import org.junit.Test;
108、import com.stream.api1.Employee;
109、public class TestStreamAPI3 {
110、 List<Employee> employees = Arrays.asList(new Employee("张三", 12, 1200.99), new Employee("小明", 15, 4500.99),
111、 new Employee("小丽", 16, 5500.99), new Employee("王二", 32, 1100.99), new Employee("二虎", 22, 9825.99),
112、 new Employee("李静", 18, 4502.99), new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99),
113、 new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99));
114、 /**
115、 *
116、 * 映射 map —— Lambda，将元素转换成其它形式或提取信息，接收一个函数作为参数，改函数会被应用到每个元素上， 并将其映射成一个新的元素。
117、 * flatMap —— 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连城一个流。
118、 */
119、 @Test
120、 public void test6() {
121、 List<String> list = Arrays.asList("aaa", "bbb", "bbb", "ddd");
122、 list.stream().map((str) -> str.toUpperCase()).forEach(System.out::println);
123、 System.out.println("---------------------------");
124、 employees.stream().map(Employee::getName).forEach(System.out::println);
125、 System.out.println("---------------------------");
126、 Stream<Stream<Character>> stream = list.stream().map(TestStreamAPI3::filterCharacter);
127、 stream.forEach((sm) -> {
128、 sm.forEach(System.out::println);
129、 });
130、 System.out.println("---------------------------");
131、 Stream<Character> stream2 = list.stream().flatMap(TestStreamAPI3::filterCharacter);
132、 stream2.forEach(System.out::println);
133、 }
134、 public static Stream<Character> filterCharacter(String str) {// add(Object obj) addAll(collection coll)
135、 List<Character> list = new ArrayList<>();
136、 for (Character character : str.toCharArray()) {
137、 list.add(character);
138、 }
139、 return list.stream();
140、 }
141、}
142、4、Stream排序
143、package com.stream.api4;
144、import java.util.Arrays;
145、import java.util.List;
146、import org.junit.Test;
147、import com.stream.api1.Employee;
148、public class TestStreamAPI4 {
149、 List<Employee> employees = Arrays.asList(new Employee("张三", 12, 1200.99), new Employee("小明", 15, 4500.99),
150、 new Employee("小丽", 16, 5500.99), new Employee("王二", 32, 1100.99), new Employee("二虎", 22, 9825.99),
151、 new Employee("李静", 18, 4502.99), new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99),
152、 new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99));
153、 /**
154、 * 排序 sorted() —— 自然排序(Comparable) sorted(Comparater com) —— 定制排序(Comparater)
155、 */
156、 @Test
157、 public void test1() {
158、 List<String> list = Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");
159、 list.stream().sorted().forEach(System.out::println);
160、 System.out.println("--------------------------------------------");
161、 employees.stream().sorted((e1, e2) -> {
162、 if (e1.getAge() == e2.getAge()) {
163、 return e1.getName().compareTo(e2.getName());
164、 } else {
165、 return Integer.compare(e1.getAge(), e2.getAge());
166、 }
167、 }).forEach(System.out::println);
168、 }
169、}
170、5、Stream查找与匹配
171、package com.stream.api5;
172、import java.util.Arrays;
173、import java.util.List;
174、import java.util.Optional;
175、import org.junit.Test;
176、import com.stream.api1.Employee;
177、import com.stream.api1.Employee.Status;
178、public class TestStreamAPI5 {
179、 List<Employee> employees = Arrays.asList(new Employee("张三", 12, 1200.99, Status.BUSY),
180、 new Employee("小明", 15, 4500.99, Status.BUSY), new Employee("小丽", 16, 5500.99, Status.BUSY),
181、 new Employee("王二", 32, 1100.99, Status.FREE), new Employee("二虎", 22, 9825.99, Status.FREE),
182、 new Employee("李静", 18, 4502.99, Status.FREE), new Employee("小三", 17, 1469.99, Status.VOCATION),
183、 new Employee("小三", 17, 1469.99, Status.VOCATION), new Employee("小三", 17, 1469.99, Status.VOCATION),
184、 new Employee("小三", 17, 1469.99, Status.VOCATION));
185、 /**
186、 * 查找与匹配 allMatch —— 检查是否平匹配所有元素 anyMatch —— 检查是否至少匹配一个元素 noneMatch ——
187、 * 检查是否没有匹配的元素 findFirst —— 返回第一个元素 findAny —— 返回当前流中的任意元素 count —— 返回流中元素的总个数
188、 * max —— 返回流中最大值 min —— 返回流中最小值
189、 */
190、 @Test
191、 public void test1() {
192、 boolean b1 = employees.stream().allMatch(e -> e.getStatus().equals(Status.BUSY));
193、 System.out.println(b1);
194、 boolean b2 = employees.stream().anyMatch((e) -> e.getStatus().equals(Status.BUSY));
195、 System.out.println(b2);
196、 boolean b3 = employees.stream().noneMatch((e) -> e.getStatus().equals(Status.BUSY));
197、 System.out.println(b3);
198、 Optional<Employee> op1 = employees.stream().sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary()))
199、 .findFirst();
200、 System.out.println(op1.get());
201、 Optional<Employee> op2 = employees.stream().filter((e) -> e.getStatus().equals(Status.FREE)).findAny();
202、 System.out.println(op2.get());
203、 Optional<Employee> op3 = employees.parallelStream().filter((e) -> e.getStatus().equals(Status.FREE)).findAny();
204、 System.out.println(op3.get());
205、 }
206、 @Test
207、 public void test2() {
208、 Long count = employees.stream().count();
209、 System.out.println(count);
210、 Optional<Employee> op1 = employees.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
211、 System.out.println(op1.get());
212、 Optional<Double> op2 = employees.stream().map(Employee::getSalary).max(Double::compare);
213、 System.out.println(op2.get());
214、 }
215、}
216、6、Stream约与收集归
217、package com.stream.api6;
218、import java.util.Arrays;
219、import java.util.DoubleSummaryStatistics;
220、import java.util.HashSet;
221、import java.util.List;
222、import java.util.Map;
223、import java.util.Optional;
224、import java.util.Set;
225、import java.util.stream.Collectors;
226、import org.junit.Test;
227、import com.stream.api1.Employee;
228、import com.stream.api1.Employee.Status;
229、public class TestStreamAPI6 {
230、 List<Employee> employees = Arrays.asList(new Employee("张三", 12, 1200.99, Status.BUSY),
231、 new Employee("小明", 15, 4500.99, Status.BUSY), new Employee("小丽", 16, 5500.99, Status.BUSY),
232、 new Employee("王二", 32, 1100.99, Status.FREE), new Employee("二虎", 22, 9825.99, Status.FREE),
233、 new Employee("李静", 18, 4502.99, Status.FREE), new Employee("小三", 17, 1469.99, Status.VOCATION),
234、 new Employee("小三", 17, 1469.99, Status.VOCATION), new Employee("小三", 17, 1469.99, Status.VOCATION),
235、 new Employee("小三", 17, 1469.99, Status.VOCATION));
236、 /**
237、 * 归约 reduce(T identity,BinaryOperator)/reduce(BinaryOperator) ——
238、 * 可以将流中元素反复结合起来，得到一个值
239、 */
240、 @Test
241、 public void test1() {
242、 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
243、 Integer sum = list.stream().reduce(0, (x, y) -> x + y);
244、 System.out.println(sum);
245、 System.out.println("-------------------------------------------");
246、 Optional<Double> op1 = employees.stream().map(Employee::getSalary).reduce(Double::sum);
247、 System.out.println(op1.get());
248、 }
249、 /**
250、 * 收集 collect —— 将流转换为其它形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
251、 */
252、 @Test
253、 public void test2() {
254、 List<String> list = employees.stream().map(Employee::getName).collect(Collectors.toList());
255、 list.forEach(System.out::println);
256、 System.out.println("-----------------------");
257、 Set<String> set = employees.stream().map(Employee::getName).collect(Collectors.toSet());
258、 set.forEach(System.out::println);
259、 System.out.println("-----------------------");
260、 HashSet<String> hashSet = employees.stream().map(Employee::getName)
261、 .collect(Collectors.toCollection(HashSet::new));
262、 hashSet.forEach(System.out::println);
263、 }
264、 @Test
265、 public void test3() {
266、 // 总数
267、 Long count = employees.stream().collect(Collectors.counting());
268、 System.out.println(count);
269、 System.out.println("-----------------------");
270、 // 平均值
271、 Double avg = employees.stream().collect(Collectors.averagingDouble(Employee::getSalary));
272、 System.out.println(avg);
273、 System.out.println("-----------------------");
274、 // 总和
275、 Double sum = employees.stream().collect(Collectors.summingDouble(Employee::getSalary));
276、 System.out.println(sum);
277、 System.out.println("-----------------------");
278、 // 最大值
279、 Optional<Employee> max = employees.stream()
280、 .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
281、 System.out.println(max.get());
282、 System.out.println("-----------------------");
283、 // 最大值
284、 Optional<Employee> min = employees.stream()
285、 .collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
286、 System.out.println(min.get());
287、 }
288、 // 分组
289、 @Test
290、 public void test4() {
291、 Map<Status, List<Employee>> map = employees.stream().collect(Collectors.groupingBy(Employee::getStatus));
292、 System.out.println(map);
293、 }
294、 // 多级分组
295、 @Test
296、 public void test5() {
297、 Map<Status, Map<String, List<Employee>>> map = employees.stream()
298、 .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
299、 if (e.getAge() < 16) {
300、 return "青年";
301、 } else if (e.getAge() < 18) {
302、 return "中年";
303、 } else {
304、 return "老年";
305、 }
306、 })));
307、 System.out.println(map);
308、 }
309、 // 分区
310、 @Test
311、 public void test6() {
312、 Map<Boolean, List<Employee>> map = employees.stream()
313、 .collect(Collectors.partitioningBy(e -> e.getSalary() > 5000));
314、 System.out.println(map);
315、 }
316、 @Test
317、 public void test7() {
318、 DoubleSummaryStatistics collect = employees.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
319、 System.out.println(collect.getAverage());
320、 System.out.println(collect.getCount());
321、 System.out.println(collect.getMax());
322、 System.out.println(collect.getMin());
323、 System.out.println(collect.getSum());
324、 }
325、
326、 @Test
327、 public void test8() {
328、 String str1 = employees.stream().map(Employee::getName).collect(Collectors.joining());
329、 System.out.println(str1);
330、 System.out.println("---------------------------------");
331、 String str2 = employees.stream().map(Employee::getName).collect(Collectors.joining(","));
332、 System.out.println(str2);
333、 System.out.println("---------------------------------");
334、 String str3 = employees.stream().map(Employee::getName).collect(Collectors.joining(",", "===", "==="));
335、 System.out.println(str3);
336、 }
337、}
338、7、Stream约练习
以上就是jdk1 8新特性这篇文章的一些介绍，希望对大家有所帮助。
标签：
免责声明：本文由用户上传，如有侵权请联系删除！