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