Stream的使用

目录

 

Stream流的创建

Stream流的之间的转换

map的使用

filter 的使用

flatMap

limit、skip、distinct

sorted 排序

reduce

sum、count、max、min

findFirst、findAny、allMatch、anyMatch、noneMatch

iterate

---

参考文章：https://www.cnblogs.com/xuwujing/p/10145691.html

使用到的数据

实体类：

public class Model implements Comparable {
    private String name;
    private Integer age;
    private String address;

    public Model() {
    }

    public Model(String name, int age, String address) {
        this.name = name;
        this.address = address;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if (o == null) return -1;
        if (this == null) return 1;
        if (o instanceof Model) {
            Model c = (Model) o;
            Integer age = c.getAge();
            return age.compareTo(this.age);
        }
        return 0;
    }
}

        ArrayList<Model> models = new ArrayList<>();
        models.add(new Model("张三", 20, "上海"));
        models.add(new Model("李四", 32, "北京"));
        models.add(new Model("王五", 41, "深圳"));
        models.add(new Model("tom", 18, "北京"));

        List<String> strList = Arrays.asList("a", "b", "c", "d", "e", "e");
        List<String> numStrList = Arrays.asList("10", "11", "12");
        List<Integer> sortList = Arrays.asList(4, 2, 10, 1, 8);

Stream流的创建

Stream.of()方式

String[] arr = {"a", "b", "c"};
Stream<String> stream1 = Stream.of("a", "b", "c");
Stream<String> stream2 = Stream.of(arr);

Arrays.stream()方式

Stream<String> stream3 = Arrays.stream(arr);

list.stream()方式

List<String> list = Arrays.asList(arr);
Stream<String> stream4 = list.stream();

Stream流的之间的转换

转换成数组

Object[] array = Stream.of("a", "b", "c").toArray();
String[] toArray = Stream.of("a", "b", "c").toArray(String[]::new);

装换成List集合

List<String> list1 = Arrays.asList(arr).stream().collect(Collectors.toList());
Set<String> set = Arrays.asList(arr).stream().collect(Collectors.toSet());
ArrayList<String> list2 = Arrays.asList(arr).stream().collect(Collectors.toCollection(ArrayList::new));
Stack<String> stack = Arrays.asList(arr).stream().collect(Collectors.toCollection(Stack::new));

转换成String

String collect = Arrays.asList(arr).stream().collect(Collectors.joining());

map的使用

map是将流中每个元素映射成另外一个流。

List<String> list3 = Arrays.asList("Avril Lavigne", "WestLife", "Daniel Powter", "Britney Spears", "Coldplay");
List<String> collect1 = list3.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println("map后转换数据：" + collect1);

List<Integer> list5 = numStrList.stream().map(Integer::valueOf).collect(Collectors.toList());
System.out.println("map转换后的数据：" + list5);

System.out.println("map获取对象中的某个属性值：" + models.stream().map(Model::getAddress).collect(Collectors.toList()));

输出结果：

map后转换数据：[AVRIL LAVIGNE, WESTLIFE, DANIEL POWTER, BRITNEY SPEARS, COLDPLAY]
map转换后的数据：[10, 11, 12]
map获取对象中的某个属性值：[上海, 北京, 深圳, 北京]

 

filter 的使用

filter起到数据过滤的作用

// 筛选出年龄大于30的人
List<Model> filter1 = models.stream().filter(model -> model.getAge() > 30).collect(Collectors.toList());
System.out.println("filter过滤后的数据：" + filter1);

String orElse1 = strList.stream().filter(s -> "aa".equals(s)).findAny().orElse("找不到"); // 集合中是否存在aa元素
String orElse2 = strList.stream().filter(s -> "a".equals(s)).findAny().orElse("找不到"); // 集合中是否存在a元素
System.out.println("orElse1：" + orElse1 + "  orElse2：" + orElse2);

int sum = models.stream().filter(model -> "北京".equals(model.getAddress())).mapToInt(model -> model.getAge()).sum();
System.out.println("居住在北京所有人的年龄和：" + sum);

输出结果：

filter过滤后的数据：[{name='李四', age=32, address='北京'}, {name='王五', age=41, address='深圳'}]
orElse1：找不到  orElse2：a
居住在北京所有人的年龄和：50

 

flatMap

flatMap 方法用于映射每个元素到对应的结果，一对多。

List<List<String>> flatMap = Stream.of(strList, numStrList).collect(Collectors.toList());
System.out.println("不使用flatMap合并多个list：" + flatMap);
List<String> flatMap1 = Stream.of(strList, numStrList).flatMap(List::stream).collect(Collectors.toList());
System.out.println("使用flatMap合并多个list：" + flatMap1);

String[] t1 = {"aaa", "bbb", "ccc"};
String[] t2 = {"111", "222", "333"};
String[] t3 = {"@@@", "###", "$$$"};
List<String> flatMap2 = Stream.of(t1, t2, t3).flatMap(Arrays::stream).collect(Collectors.toList());
System.out.println("使用flatMap合并多个数组：" + flatMap2);

输出结果

不使用flatMap合并多个list：[[a, b, c, d, e, e], [10, 11, 12]]
使用flatMap合并多个list：[a, b, c, d, e, e, 10, 11, 12]
使用flatMap合并多个数组：[aaa, bbb, ccc, 111, 222, 333, @@@, ###, $$$]

 

limit、skip、distinct

limit对数据量进行限制，skip跳过元素数量，distinct去重

System.out.println("取出前三个元素：" + strList.stream().limit(3).collect(Collectors.toList()));
System.out.println("跳过前3个人元素：" + strList.stream().skip(3).collect(Collectors.toList()));
System.out.println("去重：" + strList.stream().distinct().collect(Collectors.toList()));

输出结果：

取出前三个元素：[a, b, c]
跳过前3个人元素：[d, e, e]
去重：[a, b, c, d, e]

 

sorted 排序

System.out.println("自然排序：" + sortList.stream().sorted().collect(Collectors.toList()));
System.out.println("倒序排序：" + sortList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()));
System.out.println("自然排序：" + models.stream().sorted().collect(Collectors.toList()));
System.out.println("根据指定规则排序：" + models.stream().sorted(Comparator.comparing(Model::getAge)).collect(Collectors.toList()));

输出结果：

自然排序：[1, 2, 4, 8, 10]
倒序排序：[10, 8, 4, 2, 1]
自然排序：[{name='王五', age=41, address='深圳'}, {name='李四', age=32, address='北京'}, {name='张三', age=20, address='上海'}, {name='tom', age=18, address='北京'}]
根据指定规则排序：[{name='tom', age=18, address='北京'}, {name='张三', age=20, address='上海'}, {name='李四', age=32, address='北京'}, {name='王五', age=41, address='深圳'}]

 

reduce

把 Stream 元素组合起来进行操作

System.out.println("将集合中的每个元素通过' # '拼接起来：" + strList.stream().reduce((a, b) -> a + " # " + b));
System.out.println("将结合中每个元素拼接起来，并在前面加上 # ：" + strList.stream().reduce(" # ", String::concat));
System.out.println("求流中最大值：" + sortList.stream().reduce(Integer.MAX_VALUE, Integer::min));

输出结果：

将集合中的每个元素通过' # '拼接起来：Optional[a # b # c # d # e # e]
将结合中每个元素拼接起来，并在前面加上 # ： # abcdee
求流中最大值：1

sum、count、max、min

System.out.println("总数：" + models.stream().count());
System.out.println("过滤后总数：" + models.stream().filter(model -> model.getAge() > 30).count());
System.out.println("年龄总和方式一：" + models.stream().map(Model::getAge).reduce(Integer::sum).get());
System.out.println("年龄总和方式二：" + models.stream().map(Model::getAge).reduce(0, Integer::sum)); //起始值为0，然后开始求总和
System.out.println("年龄总和方式三：" + models.stream().mapToInt(Model::getAge).sum());
System.out.println("最大年龄：" + models.stream().mapToInt(Model::getAge).max().getAsInt());
System.out.println("最小年龄：" + models.stream().mapToInt(Model::getAge).min().getAsInt());
System.out.println("最大年龄：" + models.stream().map(Model::getAge).reduce(Integer::max).get());
System.out.println("最小年龄：" + models.stream().map(Model::getAge).reduce(Integer::min).get());
System.out.println("最大值：" + sortList.stream().reduce(Integer::max).get());
System.out.println("最小值：" + sortList.stream().reduce(Integer::min).get());

输出结果：

总数：4
过滤后总数：2
年龄总和方式一：111
年龄总和方式二：111
年龄总和方式三：111
最大年龄：41
最小年龄：18
最大年龄：41
最小年龄：18
最大值：10
最小值：1

 

findFirst、findAny、allMatch、anyMatch、noneMatch

// 查询流中第一个元素
System.out.println("findFirst：" + strList.stream().findFirst().get());
// 查询流中任意一个元素，如果流中存在“哈哈”，则输出，如果没有则输出“没有哈哈”
System.out.println("findAny：" + strList.stream().filter(a -> "哈哈".equals(a)).findAny().orElse("没有\"哈哈\""));
// 
System.out.println("findAny：" + strList.stream().filter(a -> "c".equals(a)).findAny().orElse("没有\"c\""));
// 查询流中所有的元素是否都大于5
System.out.println("allMatch：" + sortList.stream().allMatch(a -> a > 5));
// 查询流中所有元素的年龄是否都大于15
System.out.println("allMatch：" + models.stream().allMatch(a -> a.getAge() > 15));
// 查询流中是否存在一个姓名是“张三”的数据
System.out.println("anyMatch：" + models.stream().anyMatch(model -> "张三".equals(model.getName())));
// 查询流中是否存在奈年龄大于20 的数据
System.out.println("anyMatch：" + models.stream().anyMatch(model -> model.getAge() > 20));
// 查询流中是否不存在所有数据都大于10
System.out.println("noneMatch：" + sortList.stream().noneMatch(s -> s > 10));

输出结果：

findFirst：a
findAny：没有"哈哈"
findAny：c
allMatch：false
allMatch：true
anyMatch：true
anyMatch：true
noneMatch：true

 

iterate

iterate 跟 reduce 操作很像，接受一个种子值，和一个UnaryOperator（例如 f）。 然后种子值成为 Stream 的第一个元素，f(seed) 为第二个，f(f(seed)) 第三个，以此类推。 在 iterate 时候管道必须有 limit 这样的操作来限制 Stream 大小。

System.out.println("从10开始生成一个等差队列，取其前五个：" + Stream.iterate(10, n -> n + 5).limit(5).collect(Collectors.toList()));

结果：

从10开始生成一个等差队列，取其前五个：[10, 15, 20, 25, 30]