java 8 stream流

文章目录

java 8 stream流
- Stream 综合案例

什么是stream流

Stream 是JDK1.8 中处理集合的关键抽象概念，Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

Stream ：非常方便精简的形式遍历集合实现 过滤、排序等。
Mysql：select userName from mayikt where userName =‘mayikt’
Order by age limt(0,2)

中间操作 filter 过滤器 ;distinct 去重; sorted 排序; limit 分页

终止操作: forEach 遍历; collect 转换; min max; allMatch 条件;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2EG2PGtG-1638614292364)(C:\Users\LENOVO\AppData\Roaming\Typora\typora-user-images\1638613363137.png)]

Stream创建方式

parallelStream为并行流采用多线程执行
Stream采用单线程执行

parallelStream效率比Stream要高。

/**
 * 并行流与串行流区别
 *
 *
 * 串行流：单线程的方式操作； 数据量比较少的时候。
 * 并行流：多线程方式操作；数据量比较大的时候，原理：
 * Fork join 将一个大的任务拆分n多个小的子任务并行执行，
 * 最后在统计结果，有可能会非常消耗cpu的资源，确实可以
 * 提高效率。
 *
 *
 * 注意：数据量比较少的情况下，不要使用并行流。
 */

Stream将list转换为Set

public class Test01 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("xiaowei", 16));

        userEntities.forEach((t) -> {
            System.out.println(t.toString());
        });

        System.out.println("+++++++");
        Stream<UserEntity> stream = userEntities.stream();
        Set<UserEntity> setUserList = stream.collect(Collectors.toSet());
        setUserList.forEach((userEntity -> {
            System.out.println(userEntity.toString());
        }));
    }
}

Stream将list转换为Map

package com.nie.stream;

import com.nie.entity.UserEntity;

import java.util.ArrayList;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author DaZhao
 * @Date 2021/12/1 16:16
 * @Version 1.0
 */
public class Test02 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
//        userEntities.add(new UserEntity("xiaowei", 16));

        Stream<UserEntity> stream = userEntities.stream();
//        key为string类型       Value userEntity集合中的数据: UserEntity string类型
        /**
         * 内部内写法
         */
        Map<String, UserEntity> collect = stream.collect(Collectors.toMap(new Function<UserEntity, String>() {
            @Override
            public String apply(UserEntity userEntity) {
                return userEntity.getName();
            }
        }, new Function<UserEntity, UserEntity>() {
            @Override
            public UserEntity apply(UserEntity userEntity) {
                return userEntity;
            }
        }));
        collect.forEach(new BiConsumer<String, UserEntity>() {
            @Override
            public void accept(String s, UserEntity userEntity) {
                System.out.println("S:" + s + ",:" + userEntity.toString());
            }
        });


        /**
         * lambda 表达式写法
         */
        Map<String, UserEntity> collect1 = stream.collect(Collectors.toMap(userEntity -> userEntity.getName(), userEntity -> userEntity));
        collect1.forEach((s, userEntity) -> System.out.println("S:" + s + ",:" + userEntity.toString()));


    }
}

Stream将Reduce 求和

package com.nie.stream;

import com.nie.entity.UserEntity;

import java.util.ArrayList;
import java.util.Optional;
import java.util.Set;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author DaZhao
 * @Date 2021/12/1 16:16
 * @Version 1.0
 */
public class Test03 {
    public static void main(String[] args) {

        /**
         * 求和
         */
//        Stream<Integer> stream = Stream.of(10, 20, 30);
//        Optional<Integer> reduce = stream.reduce(new BinaryOperator<Integer>() {
//            @Override
//            public Integer apply(Integer integer, Integer integer2) {
//                return integer + integer2;
//            }
//        });
//        System.out.println(reduce.get());

        ArrayList<UserEntity> userEntities1 = new ArrayList<>();
        userEntities1.add(new UserEntity("meite", 28));
        userEntities1.add(new UserEntity("zhangsan", 35));
        userEntities1.add(new UserEntity("xiaowei", 16));
        Stream<UserEntity> stream = userEntities1.stream();
        Optional<UserEntity> sum = stream.reduce((userEntity, userEntity2) -> {
            UserEntity sum1 = new UserEntity("sum", userEntity.getAge() + userEntity2.getAge());
            return sum1;
        });
        System.out.println(sum.get());


    }
}

StreamMax和Min

package com.nie.stream;

import com.nie.entity.UserEntity;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author DaZhao
 * @Date 2021/12/1 16:16
 * @Version 1.0
 */

/**
 * 最大最小的
 */
public class Test04 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("xiaowei", 16));

        Stream<UserEntity> stream = userEntities.stream();
        Stream<UserEntity> stream2 = userEntities.stream();
        //最小
        Optional<UserEntity> min = stream.min((o1, o2) -> o1.getAge() - o2.getAge());
        System.out.println(min.get());
        //最大
        Optional<UserEntity> max = stream2.max((o1, o2) -> o1.getAge() - o2.getAge());
        System.out.println(max.get());
    }
}

StreamMatch 匹配

anyMatch表示，判断的条件里，任意一个元素成功，返回true
allMatch表示，判断条件里的元素，所有的都是，返回true
noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

package com.nie.stream;

import com.nie.entity.UserEntity;

import java.util.ArrayList;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * @Author DaZhao
 * @Date 2021/12/1 16:16
 * @Version 1.0
 */

/**
 * streamMatch匹配
 * <p>
 * anyMatch表示 判断任意一个元素 人一个返回 true
 * allMatch表示 判断条件里的元素  都是返回true
 * noneMatch和allMatch相反
 */
public class Test05 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("xiaowei", 16));

        Stream<UserEntity> stream = userEntities.stream();
//        boolean meite = stream.anyMatch(new Predicate<UserEntity>() {
//            @Override
//            public boolean test(UserEntity userEntity) {
//                return userEntity.getName().equals("meite");
//            }
//        });
//        System.out.println(meite);

        System.out.println(stream.noneMatch(new Predicate<UserEntity>() {
            @Override
            public boolean test(UserEntity userEntity) {
                return userEntity.getAge() > 15;
            }
        }));
    }
}


>>>>>>>> false

StreamFor循环

/**
 * @Author DaZhao
 * @Date 2021/12/1 16:16
 * @Version 1.0
 */

/**
 * streamFor 循环
 */
public class Test06 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("xiaowei", 16));

        Stream<UserEntity> stream = userEntities.stream();
        stream.forEach(userEntity -> System.out.println(userEntity.toString()));
    }
}

Stream过滤器

/**
 * @Author DaZhao
 * @Date 2021/12/1 16:16
 * @Version 1.0
 */

/**
 * stream filter 过滤器
 */
public class Test07 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("xiaowei", 16));

        Stream<UserEntity> stream = userEntities.stream();
        stream.filter(new Predicate<UserEntity>() {
            @Override
            public boolean test(UserEntity userEntity) {
                return userEntity.getAge()>20;
            }
        }).filter(new Predicate<UserEntity>() {
            @Override
            public boolean test(UserEntity userEntity) {
                return  userEntity.getName().equals("zhangsan");
            }
        }).forEach(new Consumer<UserEntity>() {
            @Override
            public void accept(UserEntity userEntity) {
                System.out.println(userEntity.toString());
            }
        });

        stream.filter(userEntity -> userEntity.getAge()>20)
                .filter(userEntity -> userEntity.getName().equals("zhangsan"))
                .forEach(userEntity -> System.out.println(userEntity.toString()));
    }
}

Stream排序 sorted

/**
 * stream sorted 排序
 */
public class Test08 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("xiaowei", 16));

        Stream<UserEntity> stream = userEntities.stream();
        stream.sorted(new Comparator<UserEntity>() {
            @Override
            public int compare(UserEntity o1, UserEntity o2) {
                return o1.getAge() - o2.getAge();
            }
        }).forEach(new Consumer<UserEntity>() {
            @Override
            public void accept(UserEntity userEntity) {
                System.out.println(userEntity);
            }
        });

        stream.sorted((o1, o2) -> o1.getAge() - o2.getAge())
                .forEach(userEntity -> System.out.println(userEntity));
    }
}

Stream limit和skip

Limit 从头开始获取
Skip 就是跳过

/**
 * stream limit和skip
 * limit 从头开始跳
 * skip 就是跳过
 */
public class Test09 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiao", 16));
        userEntities.add(new UserEntity("xiaowei", 16));

        Stream<UserEntity> stream = userEntities.stream();
        stream.skip(2).limit(1).forEach(userEntity -> System.out.println(userEntity));
    }
}


>>>>>>>>>>>> UserEntity{name='xiao', age=16}

Stream 综合案例

/**
 * @Author DaZhao
 * @Date 2021/12/1 16:16
 * @Version 1.0
 */

/**
 * 综合案例
 */
public class Test010 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("mayikt", 20));
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("mayikt_list", 109));
        userEntities.add(new UserEntity("mayikt_zhangsan", 110));
        userEntities.add(new UserEntity("lisi", 109));
        Stream<UserEntity> stream = userEntities.stream();
        //要求：对数据流的数据实现降序排列、且名称包含mayikt 获取前两位
        stream.sorted(new Comparator<UserEntity>() {
            @Override
            public int compare(UserEntity o1, UserEntity o2) {
                return -(o1.getAge() - o2.getAge());
            }
        }).filter(new Predicate<UserEntity>() {
            @Override
            public boolean test(UserEntity userEntity) {
                return userEntity.getName().contains("mayikt");
            }
        }).limit(2).forEach(new Consumer<UserEntity>() {
            @Override
            public void accept(UserEntity userEntity) {
                System.out.println(userEntity.toString());
            }
        });


        stream.sorted((o1, o2) -> -(o1.getAge() - o2.getAge()))
                .filter(userEntity -> userEntity.getName().contains("mayikt"))
                .limit(2)
                .forEach(userEntity -> System.out.println(userEntity.toString()));

    }
  
}

原文链接：https://blog.csdn.net/qq_44236958/article/details/121719783