Java8新特性Stream流的使用

记录一下如何使用Stream流对象处理数据

使用三步骤：

• 创建Stream流
• 一系列对流的中间操作
• 终止操作

创建Stream流的方式

1. 通过Collection系类集合提供的stream()方法获取串行流或者parallelStream()方法获取并行流

		List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

2. 通过Arrays中的静态方法stream()方法获取数组流

		String[] strings = new String[10];
        Stream<String> stream1 = Arrays.stream(strings);

3. 通过Stream流中的静态方法of()创建

Stream<String> a = Stream.of("a", "b", "c");

4. 创建无限流

	//迭代
 	Stream.iterate(0, (x) -> x + 2).limit(10).forEach(System.out::println);
 	//生成
	Stream.generate(()->Math.random()).limit(5).forEach(System.out::println);

一系列对流的中间操作

筛选与切片

1. filter:接收lambda，从流中排除某些元素。

//定义一个学生类方便演示，这里get,set方法自己添加
public class Student {
    private String name;
    private Integer age;
}

public class StreamDemo2 {
    public static void main(String[] args) {
    //筛选年龄在30岁以上的
        List<Student> students = new ArrayList<>();
        students.add(new Student("a",12));
        students.add(new Student("b",42));
        students.add(new Student("c",52));
        students.add(new Student("d",22));
        students.add(new Student("e",182));

        students.stream().filter((s)->s.getAge()>30).forEach(System.out::println);
    }
}

2. limit----截断流，使其元素不超过指定的数量。

public class StreamDemo2 {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("a",12));
        students.add(new Student("b",42));
        students.add(new Student("c",52));
        students.add(new Student("d",22));
        students.add(new Student("e",182));
//筛选并且只显示一个
        students.stream().filter((s)->s.getAge()>30).limit(1).forEach(System.out::println);
    }
}

3. skip----跳过元素，返回一个扔掉前n个元素的流，如果剩下的不足n个，则返回空流，与limit互补
4. distinct----通过流生成元素的hashCode()和equals()方法进行去重，但前提是元素要重写这两个方法。

映射

1. map----接收lambda,将元素转化成其他元素或者提取信息。接收一个函数作为参数，改函数会作用到每一个元素，并将其映射成一个新元素。

public class StreamDemo3 {
    public static void main(String[] args) {
       List<String> list = Arrays.asList("aaa","bbb","xxx","ccc","ddd");
       list.stream().map((s)->s.toUpperCase()).forEach(System.out::println);
        System.out.println("------------------------------------------------------");
        List<Student> students = new ArrayList<>();
        students.add(new Student("a",12));
        students.add(new Student("b",42));
        students.add(new Student("c",52));
        students.add(new Student("d",22));
        students.add(new Student("e",182));
        students.add(new Student("c",52));
        students.add(new Student("d",22));
        students.add(new Student("e",182));
        students.stream().map(Student::getName).forEach(System.out::println);
    }
}

2. flatMap----接收一个函数作为参数，将流中的每一个值都换成另外一个流，然后把所有流连接成一个流

public class StreamDemo3 {
    public static void main(String[] args) {
       List<String> list = Arrays.asList("aaa","bbb","xxx","ccc","ddd");
       //不使用flatMap
       list.stream().map(StreamDemo3::filterCharacter).forEach((sm)->sm.forEach(System.out::println));
       //使用flatMap
        list.stream().flatMap(StreamDemo3::filterCharacter).forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String s){
        List<Character> list = new ArrayList<>();
        for (char c : s.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
}

排序

1. sorted()-----自然排序
2. sorted(Comparator com)------定制排序

public class StreamDemo4 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("ccc", "aaa", "vvv", "bbb", "ddd");
        //自然排序
        list.stream().sorted().forEach(System.out::println);
        System.out.println("----------------------------");
        List<Student> students = new ArrayList<>();
        students.add(new Student("a",12));
        students.add(new Student("b",42));
        students.add(new Student("c",52));
        students.add(new Student("d",22));
        students.add(new Student("e",182));
        students.stream().sorted((s1,s2)->{
            if (s1.getAge().equals(s2.getAge())){
                return s1.getName().compareTo(s2.getName());
            }else {
                return s1.getAge().compareTo(s2.getAge());
            }
        }).forEach(System.out::println);

    }
}

终止操作

查找和匹配

1. allMatch-------是否匹配所有元素，返回true或者false。
2. anyMacth-----是否至少匹配一个元素，返回true或者false。
3. noneMatch----是否没有匹配所有的元素，返回true或者false。
4. findFirst-------返回第一个元素。
5. findAny-----返回当前流中的任意元素。
6. count-----返回当前流中元素的总个数。
7. max----返回流中最大值。
8. min-----返回流中最小值。

public class StreamDemo5 {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("a",12));
        students.add(new Student("b",42));
        students.add(new Student("c",52));
        students.add(new Student("d",22));
        students.add(new Student("e",182));
        students.add(new Student("c",52));
        students.add(new Student("d",22));
        students.add(new Student("e",182));

        Optional<Student> max = students.stream().max((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge()));
        System.out.println(max.get());
        Optional<Integer> min = students.stream().map(Student::getAge).min(Integer::compare);
        System.out.println(min.get());
    }
}

归约

1. reduce-----可以将流中元素返回结合起来，得到一个值。其中参数第一个是起始值，第二个是运算符。

 List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer reduce = integers.stream().reduce(0, (x, y) -> x + y);
        System.out.println(reduce);

收集

1. collect-------将流转换成其他形式，

       List<String> collect = students.stream().map(Student::getName).collect(Collectors.toList());
        collect.forEach(System.out::println);
        System.out.println("---------------------");
        Set<String> collect1 = students.stream().map(Student::getName).collect(Collectors.toSet());
        collect1.forEach(System.out::println);
        System.out.println("--------------------");
        HashSet<String> collect2 = students.stream().map(Student::getName).collect(Collectors.toCollection(HashSet::new));

        System.out.println("---------求平均数---------------");
        Double collect3 = students.stream().collect(Collectors.averagingInt(Student::getAge));
        System.out.println(collect3);

        System.out.println("---------求总和---------------");
        Integer collect4 = students.stream().collect(Collectors.summingInt(Student::getAge));
        System.out.println(collect4);

        System.out.println("---------求最大---------------");
        Optional<Student> collect5 = students.stream().collect(Collectors.maxBy((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge())));
        System.out.println(collect5.get());

        System.out.println("---------求最小---------------");
        Optional<Integer> collect6 = students.stream().map(Student::getAge).collect(Collectors.minBy(Integer::compare));
        System.out.println(collect6.get());
           System.out.println("------------分组---------------");
        Map<Integer, List<Student>> collect7 = students.stream().collect(Collectors.groupingBy(Student::getAge));
         System.out.println("------------分组后再分组---------------");
        Map<String, Map<String, List<Student>>> collect8 = students.stream().collect(Collectors.groupingBy(Student::getName, Collectors.groupingBy((s) -> {
            if (s.getAge() <= 20) {
                return "幼年";
            } else if (s.getAge() <= 60) {
                return "中年";
            } else {
                return "老年";
            }
        })));