Stream 流

• Stream流是一种流式接口，是jdk8出现的特性。
• Stream流对于集合做聚合操作。
• Stream流中的接口都是函数是接口，都可以使用lambda表达式。

获取流的方式

• 集合.Stream

import java.util.Arrays;
import java.util.ListIterator;
import java.util.stream.Stream;

public static void main(String[] args) {
    // 创建一个list
    List
<Integer> list = Arraya.asList(1, 2, 3, 4, 5);
    //获取流的方式一

    Stream
<Integer> stream = list.stream();

    List
<Integer> list1 = Arrays.asList(1, 4, 5, 6, 7);
    List
<Integer> list2 = Arrays.asList(6, 3, 4, 6, 6);
    List
<Integer> list3 = Arrays.asList(88, 44, 55, 6, 7);
    Stream
<Integer> stream1 = list1.stream();
    Stream
<Integer> stream2 = list2.stream();
    Stream
<Integer> stream3 = list3.stream();
}

• 合并流Stream.concat

public static void main(String[] args) {
    // 获取流的方式二  
    Stream
<Integer> concat = Stream.concat(stream1, stream2);
    Stream
<Integer> concat1 = Stream.concat(concat, stream3);

    Stream
<Integer> concat2 = Stream.concat(Stream.concat(stream1, stream2), stream3);
}

常用方法

• distinct() 去重，把流中重复的元素去重
• sorted() 排序
• limit(n) 获取前n个元素
• collect() 把流转换成对应的集合
• flatMap() 合并流
• filter() 过滤
• map()
• peek() 对集合中的每一个对象进行处理

案例一 ：对指定的集合数据进行去重，然后降序排列，并获取前3个最大值

方式一：

import java.util.ArrayList;
import java.util.Collection;

public static void main(String[] args) {
    List
<Integer> list = new ArrayList<>();
    //向集合中添加数据
    Collection.addAll(list, 1, 3, 5, 1, 6, 8, 9, 3, 2, 6, 7, 5, 11, 66, 4, 88, 7);

    //将流转换为集合
    List
<Integer> collect = list.stream().distinct().sorted(Comparator.reverseOrder()).limit(3).collect(Collectors.toList());
    System.out.println(collect);
}

方法二:

import java.util.Collections;
import java.util.Comparator;
import java.util.stream.Stream;

public static void main(String[] args) {
    List
<Integer> list = new ArrayList<>();
    // 向集合中添加数据
    Collections.addAll(list, 1, 3, 5, 1, 6, 8, 9, 3, 2, 6, 7, 5, 11, 66, 4, 88, 7);
}

public static void method() {
    //获取流
    Stream
<Integer> stream = list.stream();
    //去重
    Stream
<Integer> stream1 = stream.distinct();
    //降序
//  Stream
<Integer> stream2 = stream1.sorted(new Comparator<Integer>() {
//    @Override
//    public int compare(Integer o1, Integer o2) {
//      return o2 - o1;
//    }
//  });
    //降序 lambda
    Stream
<Integer> stream2 = stream1.sorted((o1, o2) -> o2 - o1);
    //获取前三个值
    List
<Integer> collect = stream3.collect(Collections.singletonList());
    System.out.println(collect);

}

案例二：统计多个集合中最大最小值，平均值，和。排序去重后获取结果。

import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.function.ToIntFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public static void main(String[] args) {
    //定义三个集合
    List
<Integer> list1 = Arrays.asList(1, 4, 5, 6, 7, 2);
    List
<Integer> list2 = Arrays.asList(13, 2, 55, 6, 44, 7, 88, 9);
    List
<Integer> list3 = Arrays.asList(11, 2, 33, 44, 46, 56);

    //合并到一个stream流中 

    //方式一 使用 Stream.concat 递归地合并多个 Stream
    Stream
<Integer> stream = Stream.concat(list1.stream(), list2.stream(), list3.stream());

    //方式二 使用匿名内部类与flatMap()合并多个流  
    Stream
<Object> stream = Stream.of(list1, list2, list3).flapMap(new Function<List<Integer>, Stream<?>>() {
        @Override
        public Stream<?> apply(List<Integer> integers) {
            return integers.stream();
        }
    });

    //方式三 使用 flatMap 和 Lambda 表达式合并多个流
    Stream
<Integer> stream = Stream.of(list1, list2, list3).flatMap(integers -> integers.stream());

    //方式四 使用 flatMap 和方法引用合并多个流
    Stream
<Integer> stream = Stream.of(list1, list2, list3).flatMap(List::stream);

    // 合并多个列表，去重，按降序排序，收集结果
    List
<Integer> collect = Stream.of(list1, list2, list3).flatMap(List::stream).distinct().sorted((Comparator.reverseOrder()).collect(Collectors.toList()));
    System.out.println(collect);

    // 计算统计信息

    //使用匿名内部类计算统计信息
    IntSummaryStatistics intSummaryStatistics = collect.stream().mapToInt(new ToIntFunction
<Integer>() {
        @Override
        public int applyAsInt(Integer value) {
            return value.intValue();
        }
    }).summaryStatistics();
    //使用Lambda表达式
    collect.stream().mapToInt(v -> v.intValue());

    //使用方法引用计算统计信息
    IntSummaryStatistics intSummaryStatistics1 = collect.stream().mapToInt(Integer::intValue).summaryStatistics();

    // 输出信息
    // 平均值
    System.out.println(intSummaryStatistics.getAverage());
    // 最大值
    System.out.println(intSummaryStatistics.getMax());
    // 最小值
    System.out.println(intSummaryStatistics.getMin());
    // 和
    System.out.println(intSummaryStatistics.getSum());
}

案例三：统计集合中名字带o的，分数score > 40的人，根据成绩进行降序排序，根据id进行升序排序

import java.util.ArrayList;
import java.util.Comparator;
import java.util.stream.Collectors;

class Person {
    public class Person {

        private int id;

        private String name;

        private int score;

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getScore() {
            return score;
        }

        public void setScore(int score) {
            this.score = score;
        }

        public Person(int id, String name, int score) {
            this.id = id;
            this.name = name;
            this.score = score;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", score=" + score +
                    '}';
        }
    }
}

public static void main(String[] args) {

    // 统计集合中名字带o的，分数score > 40的人，根据成绩进行降序排序，根据id进行升序排序

    List
<Person> persons = Arrays.asList(
            new Person(1, "james", 8),
            new Person(3, "durant", 45),
            new Person(4, "curry", 40),
            new Person(5, "jordan", 81),
            new Person(2, "kobe", 81),
            new Person(6, "jokic", 90),
            new Person(7, "westbrook", 39)
    );

    // 返回false的数据就会被过滤掉
//        persons.stream().filter(new Predicate
<Person>() {
//            @Override
//            public boolean test(Person person) {
//                return person.getName().contains("o") && person.getScore() > 40;
//            }
//        });

    List
<Person> people = person.stream().filter(person -> person.getName().contains("o"))
            .filter(person.getScore() > 40)
            .sorted(Comparator(Person::getId))
            .collect(Collectors.toList());
    people.forEach(System.out::println);
}

public static void main(String[] args) {
    List
<Person> datalist = new ArrayList<>();

    // 传统方式 增强for循环
    for (Person person : persons) {
        if (person.getName().contains("o") && person.getScore() > 40) {
            datalist.add(person);
        }
    }

    //重写compare方法
//  datalist.sort(new Comparator
<Person>(){
//     @Override
//    public int compare(Person o1,Person o2){
//         return o2.getScore() - o1.getScore;
//     }
//  });

    //lambda表达式
//  datalist.sort((o1,o2)->o2.getScore()-o1.getScore());

    datalist.sort(Comparator.comparing(Person::getScore).reversed().thenComparing(Person::getId));
}

案例四:把集合中的名称全部转换成大写

public static void main(String[] args) {
    List
<Person> persons = Arrays.asList(
            new Person(1, "james", 8),
            new Person(3, "durant", 45),
            new Person(4, "curry", 40),
            new Person(5, "jordan", 81),
            new Person(2, "kobe", 81),
            new Person(6, "jokic", 90),
            new Person(7, "westbrook", 39)
    );
    // 传统方式
//        List
<Person> list = new ArrayList<>();
//        for (Person person : persons) {
//            person.setName(person.getName().toUpperCase());
//            list.add(person);
//        }
//        System.out.println(list);

    // 流式调用
    // map 对于集合中的每一个元素进行处理
    // 泛型一:apply方法的参数类型
    // 泛型二:返回值类型
//        List
<Person> collect = persons.stream().map(new Function<Person, Person>() {
//            @Override
//            public Person apply(Person person) {
//                person.setName(person.getName().toUpperCase());
//                return person;
//            }
//        }).collect(Collectors.toList());
    // lambda表达式
//        List
<Person> collect = persons.stream().
//                map(person -> new Person(person.getId(), person.getName().toUpperCase(), person.getScore())).
//                collect(Collectors.toList());
//        List
<Person> collect = persons.stream().map(person -> {
//            person.setName(person.getName().toUpperCase());
//            return person;
//        }).collect(Collectors.toList());
//        collect.forEach(System.out::println);

    // 求结果中名字带u的人
    List
<Person> personList = persons.stream().
            filter(person -> person.getName().contains("u")).
            map(person -> {
                person.setName(person.getName().toUpperCase());
                return person;
            }).collect(Collectors.toList());
    System.out.println(personList);

}

案例五：给每个人的分数都加10分

  public static void main(String[] args) {
    List
<Person> persons = Arrays.asList(
            new Person(1, "james", 8),
            new Person(3, "durant", 45),
            new Person(4, "curry", 40),
            new Person(5, "jordan", 81),
            new Person(2, "kobe", 81),
            new Person(6, "jokic", 90),
            new Person(7, "westbrook", 39)
    );

//        List
<Person> collect = persons.stream().
//                map(person -> {
//            person.setScore(per  son.getScore() + 10);
//            return person;
//        }).collect(Collectors.toList());
//        System.out.println(collect);

    // 匿名内部类
//        List
<Person> collect = persons.stream().peek(new Consumer<Person>() {
//            @Override
//            public void accept(Person person) {
//                person.setScore(person.getScore() + 10);
//            }
//        }).collect(Collectors.toList());

    // lambda表达式
    List
<Person> collect = persons.stream().peek(p -> p.setScore(p.getScore() + 10)).collect(Collectors.toList());
    System.out.println(collect);
}