java8新特性stream操作

Stream是Java8的一大亮点，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的 聚合操作（aggregate operation）或者大批量数据操作。Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。所以说，Java8中首次出现的 java.util.stream是一个函数式语言+多核时代综合影响的产物。
一.针对不同数据结构如何转化成stream
public class Main {
public static void main(String[] args) {
//获取单个值的stream对象
Stream stream = Stream.of("a", "b", "c");
//针对数组类型获取stream对象
String[] array = new String[]{"1", "2", "3"};
stream = Stream.of(array);
stream = Arrays.stream(array);
//针对集合的操作
List<String> list = Arrays.asList(array);
stream = list.stream();
}
二.Stream的使用
@Data
public class Person implements Serializable{
public Person(String personId, String personName, int sex, double score) {
this.personId = personId;
this.personName = personName;
this.sex = sex;
this.score = score;
}
private String personId;
private String personName;
private int sex;
private double score;
private String remarks;
}
1.map:一对一映射，把inputStream的每个元素映射成outputStream的另外一个元素
List<Integer> nums = Arrays.asList(1, 2, 3);
List<Integer> squareNums = nums.stream().map(n -> n * n).collect(Collectors.toList());
System.out.println(squareNums.toString());
结果：
[1, 4, 9]

2.flatMap：一对多映射，将inputStream中的层级结构扁平化，就是将最底层元素抽出来放到一起
List<Integer> nums1 = Arrays.asList(1, 2, 3);
List<Integer> nums2 = Arrays.asList(4, 5, 6);
List<Integer> nums3 = Arrays.asList(7, 8, 9);
List<Integer> flatNums = Stream.of(nums1, nums2, nums3).flatMap((childList) ->      childList.stream()).collect(Collectors.toList());
System.out.println(flatNums.toString());
结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]

3.filter：原始Stream进行某项测试，通过测试的元素被留下来生成一个新Stream
Integer[] sixNums = {1, 2, 3, 4, 5, 6, 7, 8};
Integer[] events = Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);
System.out.println(Arrays.asList(events).toString());
结果：
[2, 4, 6, 8]

4.forEach：terminal操作,没有返回值，personList本身的值会被改变
Person personMing = new Person("123", "xiaoming", 1, 85);
Person personHong = new Person("456", "xiaohong", 2, 59);
Person personHua = new Person("789", "xiaohua", 2, 65);
List<Person> personList = new ArrayList<>();
personList.add(personMing);
personList.add(personHong);
personList.add(personHua);
personList.stream().filter(person -> person.getScore() >= 60).forEach(person -> person.setRemarks("及格"));
personList.stream().filter(person -> person.getScore() < 60).forEach(person -> person.setRemarks("不及格"));
System.out.println(personList.toString());
结果：
[Person(personId=123, personName=xiaoming, sex=1, score=85.0, remarks=及格), Person(personId=456, personName=xiaohong, sex=2, score=59.0, remarks=不及格), Person(personId=789, personName=xiaohua, sex=2, score=65.0, remarks=及格)]

5.peek是intermediate操作，有返回值，返回值为符合条件被赋值了的数据，personList本身的值也会被改变
List<Person> newList = personList.stream().filter(person -> person.getScore() >= 60).peek(person ->  person.setRemarks("及格")).collect(Collectors.toList());
System.out.println(newList.toString());
结果：
[Person(personId=123, personName=xiaoming, sex=1, score=85.0, remarks=及格), Person(personId=789,   personName=xiaohua, sex=2, score=65.0, remarks=及格)]

6.reduce:将reduce后的第一个参数和Stream中的元素组合，求结果
String[] str = {"A", "B", "C", "D"};
String concatStr = Stream.of(str).reduce("F", String::concat);
System.out.println(concatStr);

Double[] doubles = {1.0, 2.0, 3.0, 4.0};
double minValue = Stream.of(doubles).reduce(Double.MAX_VALUE, Double::min);
System.out.println(minValue);

Double sum = personList.stream().filter(person -> person.getScore() >= 60).collect(Collectors.summingDouble(Person::getScore));
System.out.println(sum);
结果：
FABCD
1.0
150.0

7.limit和skip: limit返回Stream的前面n个元素；skip则是扔掉前n个元素
String[] name = personList.stream().map(Person::getPersonName).limit(2).skip(1).toArray(String[]::new);
System.out.println(Arrays.asList(name).toString());
结果：
[xiaohong]

8.sorted排序:默认升序,加reversed()降序
List<Person> sortsList =  personList.stream().sorted(Comparator.comparing(Person::getScore).reversed()).collect(Collectors.toList());
System.out.println(sortsList.toString());
结果：
[Person(personId=123, personName=xiaoming, sex=1, score=85.0, remarks=及格), Person(personId=789, personName=xiaohua, sex=2, score=65.0, remarks=及格), Person(personId=456, personName=xiaohong, sex=2, score=59.0, remarks=不及格)]

9.Stream有三个match方法
System.out.println("Stream有三个match方法");
System.out.println("allMatch：Stream中全部元素符合，返回 true");
boolean isAllExcellent = personList.stream().allMatch(p -> p.getScore() > 80);
System.out.println(isAllExcellent);
System.out.println("anyMatch：Stream中只要有一个元素符合，返回 true");
boolean isThereAnyExcellent = personList.stream().anyMatch(p -> p.getScore() > 80);
System.out.println(isThereAnyExcellent);
System.out.println("noneMatch：Stream中没有一个元素符合，返回 true");
boolean isThereNoneExcellent = personList.stream().noneMatch(p -> p.getScore() > 80);
System.out.println(isThereNoneExcellent);
结果：
allMatch：Stream中全部元素符合，返回 true
false
anyMatch：Stream中只要有一个元素符合，返回 true
true
noneMatch：Stream中没有一个元素符合，返回 true
false