Stream流的认识和实战

最新推荐文章于 2024-05-08 23:00:00 发布

浪去爪哇岛喝咖啡

最新推荐文章于 2024-05-08 23:00:00 发布

阅读量223

点赞数

分类专栏：学相伴飞哥文章标签： java Stream高级部分

本文链接：https://blog.csdn.net/qq_32695257/article/details/123370045

版权

学相伴飞哥专栏收录该内容

33 篇文章 0 订阅

订阅专栏

问题：我需要查询用户信息，但是我需要把每个用户的信息的密码在返回的时候设置为null。为什么这样做，因为这样安全。

List<User> userList = new ArrayList();
List<User> newList = new ArrayList();
for(User user : userList){
 user.setPassword(null);
 newList.add(user);
}

// stream流化
List<User> newList = userList.stream().peek(u->u.setPassword(null)).collect(Collections.toList());

在这里插入图片描述
1.1 使用Collection下的 stream() 和 parallelStream() 方法

List<String> list = new ArrayList<>();
Stream<String> Stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

1.2 使用Stream中的静态方法：of()、iterate()、generate()

Stream<Integer> Stream = Stream.of(1,2,3,4,5,6);
  
Stream<Integer> Stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
Stream2.forEach(System.out::println); // 0 2 4 6 8 10
  
Stream<Double> Stream3 = Stream.generate(Math::random).limit(2);
Stream3.forEach(System.out::println);

1.3使用Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10];
Stream<Integer> Stream = Arrays.stream(nums);

1.4 使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader = new BufferedReader(new FileReader("F:\\test_Stream.txt"));
Stream<String> lineStream = reader.lines();
lineStream.forEach(System.out::println);

1.5 使用 Pattern.splitAsStream() 方法，将字符串分隔成流

Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
stringStream.forEach(System.out::println);



public class StreamDemo02 {

    public static void main(String[] args) {
        // 1：创建一个集合
        List<User> userList1 = new ArrayList<>();
        userList1.add(new User(1, "小文", "123456", 16, 1, 20000d));
        userList1.add(new User(2, "老季", "123456", 22, 1, 100000d));
        userList1.add(new User(3, "怪咖", "123456", 13, 1, 89557d));
        userList1.add(new User(4, "小六", "123456", 26, 1, 78000d));
        userList1.add(new User(5, "小刘", "123456", 46, 1, 58000d));


        // user--nickname
        List<String> nicknames = userList1.stream().map(u -> {
            return u.getUsername();
        }).collect(Collectors.toList());

        for (String nickname : nicknames) {
            System.out.println(nickname);
        }

        // user---map
        List<Map<String, Object>> collect = userList1.stream().map(u -> {
            Map<String, Object> map = new HashMap<>();
            map.put("id", u.getId());
            map.put("username", u.getUsername());
            map.put("sex", u.getSex());
            return map;
        }).collect(Collectors.toList());

        for (Map<String, Object> stringObjectMap : collect) {
            System.out.println(stringObjectMap);
        }


        // user--->uservo
        List<UserVo> collect1 = userList1.stream().map(u -> {
            UserVo userVo = new UserVo();
            userVo.setId(u.getId());
            userVo.setUsername(u.getUsername());
            userVo.setSex(u.getSex() == 1 ? "男" : "女");
            return userVo;
        }).collect(Collectors.toList());

        for (UserVo userVo : collect1) {
            System.out.println(userVo);
        }


    }


}

public class StreamDemo03 {

    public static void main(String[] args) {
        // 1：创建一个集合
        List<User> userList1 = new ArrayList<>();
        userList1.add(new User(1, "小文", "123456", 16, 1, 20000d));
        userList1.add(new User(2, "老季", "123456", 22, 1, 100000d));
        userList1.add(new User(3, "怪咖", "123456", 13, 1, 89557d));
        userList1.add(new User(4, "小六", "123456", 26, 1, 78000d));
        userList1.add(new User(5, "小刘", "123456", 46, 1, 58000d));


//        List<User> sortUserList = userList1.stream().sorted(new Comparator<User>() {
//            @Override
//            public int compare(User o1, User o2) {
//                return o2.getAge() - o1.getAge();
//            }
//        }).collect(Collectors.toList());

//        List<User> sortUserList = userList1.stream().sorted((User o1, User o2) ->{
//                return o2.getAge() - o1.getAge();
//        }).collect(Collectors.toList());

      
        List<User> sortUserList = userList1.stream().sorted((o1, o2) -> o2.getAge() - o1.getAge()).collect(Collectors.toList());
        for (User user : sortUserList) {
            System.out.println(user);
        }

    }

}

public class StreamDemo04 {

    public static void main(String[] args) {
        // 1：创建一个集合
        List<User> userList1 = new ArrayList<>();
        User user1 =  new User(1, "小文", "123456", 16, 1, 20000d);
        User user2 =  new User(1, "小文", "123456", 16, 1, 20000d);
        userList1.add(user1);
        userList1.add(user2);
        userList1.add(new User(2, "老季", "123456", 22, 1, 100000d));
        userList1.add(new User(3, "怪咖", "123456", 13, 1, 89557d));
        userList1.add(new User(4, "小六", "123456", 26, 1, 78000d));
        userList1.add(new User(5, "小刘", "123456", 46, 1, 58000d));


        System.out.println(user1.equals(user2));

        List<User> userList = userList1.stream().distinct().collect(Collectors.toList());
        for (User user : userList) {
            System.out.println(user);
        }

//        List<Integer> userList1 = new ArrayList<>();
//        userList1.add(1);
//        userList1.add(2);
//        userList1.add(3);
//        userList1.add(1);
//
//        List<Integer> collect = userList1.stream().distinct().collect(Collectors.toList());
//        System.out.println(collect);
    }


}

 public static List<User> pageUser(int pageNo,int pageSize){
          int skip = (pageNo - 1) * pageSize;
          return  userList1.stream().sorted((o1, o2) -> o2.getAge() - o1.getAge())
                .skip(skip) // (pageno-1) * pageSize
                .limit(pageSize) // pageSize
                .collect(Collectors.toList());
    
    }

public class StreamDemo02 {

    public static void main(String[] args) {

        // 1：创建一个集合
        List<User> userList1 = new ArrayList<>();
        userList1.add(new User(1, "小文", "123456", 16, 1, 20000d));
        userList1.add(new User(2, "老季", "123456", 22, 0, 100000d));
        userList1.add(new User(3, "怪咖", "123456", 13, 1, 89557d));
        userList1.add(new User(4, "小六", "123456", 26, 0, 78000d));
        userList1.add(new User(5, "小刘", "123456", 46, 1, 58000d));

        List<User> userList2 = new ArrayList<>();
        userList2.add(new User(6, "小文1", "123456", 16, 1, 20000d));
        userList2.add(new User(7, "老季2", "123456", 22, 0, 100000d));
        userList2.add(new User(8, "怪咖3", "123456", 13, 1, 89557d));
        userList2.add(new User(9, "小六4", "123456", 26, 0, 78000d));
        userList2.add(new User(10, "小刘5", "123456", 46, 1, 58000d));


        // 合并
        List<User> allUserList = Stream.of(userList1, userList2).flatMap(s -> s.stream()).collect(Collectors.toList());
        allUserList.forEach(System.out::println);

        // 2：合并flatmap + 在映射map
        List<String> allUserList2 = Stream.of(userList1, userList2).flatMap(s -> s.stream()) //Stream<User>
                .map(u -> {
                    return u.getUsername();
                }).collect(Collectors.toList());
        allUserList2.forEach(System.out::println);
    }
}

 // 合并 -- 并集
        //List<User> allUserList = Stream.of(userList1, userList2).flatMap(s -> s.stream()).collect(Collectors.toList());
        //allUserList.forEach(System.out::println);

        // 合并 -- 交集 -- 共同好友
        System.out.println("-=================================共同好友=====================");
        List<User> allUserList2 = userList1.stream().filter(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return userList2.contains(user);
            }
        }).collect(Collectors.toList());
        allUserList2.forEach(System.out::println);

        //List<User> allUserList2 = userList1.stream().filter(user -> userList2.contains(user) ).collect(Collectors.toList());
        //List<User> allUserList2 = userList1.stream().filter(userList2::contains).collect(Collectors.toList());
        //List<User> allUserList3 = userList1.stream().filter(StreamDemo02::contains).collect(Collectors.toList());

        System.out.println("-==================================差集=====================");
        // 合并 -- 差集
        List<User> allUserList3 = userList1.stream().filter(user -> !userList2.contains(user) ).collect(Collectors.toList());
        allUserList3.forEach(System.out::println);

        // 2：合并flatmap + 在映射map
//        List<String> allUserList2 = Stream.of(userList1, userList2).flatMap(s -> s.stream()) //Stream<User>
//                .map(u -> {
//                    return u.getUsername();
//                }).collect(Collectors.toList());
//        allUserList2.forEach(System.out::println);
    }


    public static boolean contains(Object o){
        return true;
    }

  // 并集
        System.out.println("=============并集========================");
        List<Integer> collect = Stream.of(list1, list2).flatMap(s -> s.stream()).collect(Collectors.toList());
        collect.forEach(System.out::println);

        // 交集
        System.out.println("=============交集========================");
        List<Integer> collect2 =  list1.stream().filter(list2::contains).collect(Collectors.toList());
        collect2.forEach(System.out::println);


        // 差集
        System.out.println("=============差集========================");
        List<Integer> collect3 =  list1.stream().filter(u->!list2.contains(u)).collect(Collectors.toList());
        collect3.forEach(System.out::println);

        List<Integer> collect4 =  list2.stream().filter(u->!list1.contains(u)).collect(Collectors.toList());
        collect4.forEach(System.out::println);

public class StreamDemo06 {

    public static void main(String[] args) {


        List<User> userList1 = new ArrayList<>();
        userList1.add(new User(1, "小文", "123456", 15, 1, 20000d));
        userList1.add(new User(2, "老季", "123456", 15, 0, 100000d));
        userList1.add(new User(8, "怪咖3", "123456", 15, 1, 89557d));
        userList1.add(new User(3, "怪咖", "123456", 15, 1, 89557d));
        userList1.add(new User(4, "小六", "123456", 15, 0, 78000d));
        userList1.add(new User(5, "小刘", "123456", 15, 1, 58000d));



//        User user = userList1.stream().findAny().get();
//        System.out.println(user);

//         anyMatch  只要集合中的某个元素满足条件就是true ,否则就是false
//        boolean anyMatch = userList1.stream().anyMatch(new Predicate<User>() {
//            @Override
//            public boolean test(User user) {
//                return user.getAge() > 16;
//            }
//        });

//      allMatch  和noneMatch是相对立的，必须条件全部满足才是true,否则false
//        boolean noneMatch = userList1.stream().allMatch(new Predicate<User>() {
//            @Override
//            public boolean test(User user) {
//                return user.getAge() > 16;
//            }
//        });
//        System.out.println(noneMatch);


        // noneMatch 相对于allMatch 必须条件全部不满足才是true,否则 false
        boolean noneMatch = userList1.stream().noneMatch(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getAge() > 16;
            }
        });

        System.out.println(noneMatch);
    }



}

public class StreamDemo05 {

    public static void main(String[] args) {

        List<ShopCart> shopCarts = new ArrayList<>();
        shopCarts.add(new ShopCart(1, "手机1", 1d, 1));//a
        shopCarts.add(new ShopCart(2, "手机2", 2d, 2));//b
        shopCarts.add(new ShopCart(3, "手机3", 3d, 3));

        double doubleValue1 = shopCarts.stream().map(shopcart -> shopcart.getPrice() * shopcart.getNum()).reduce(0d, (a, b) -> a + b).doubleValue();
        double doubleValue2 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice() * shopcart.getNum()).sum();
        double doubleValue3 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice()).average().getAsDouble();
        double doubleValue4 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice()).max().getAsDouble();
        double doubleValue5 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice()).min().getAsDouble();

        System.out.println(doubleValue1);
        System.out.println(doubleValue2);
        System.out.println(doubleValue3);
        System.out.println(doubleValue4);
        System.out.printn(doubleValue5);
    }
}

树结构十分重要

@Service
@Log4j2
public class CourseCategoryServiceImpl extends ServiceImpl<CourseCategoryMapper, CourseCategory>
        implements CourseCategoryService {


    public List<CourseCategory> findCategoiresTree() {
        // 1 :查询表中所有的数据
        List<CourseCategory> allList = this.list(); // 思考空间，为什么查询的是所有
        // 2: 找到所有的根节点 pid = 0
        List<CourseCategory> rootList = allList.stream().filter(category -> category.getPid().equals(0))
                .sorted((a,b)->a.getSorted()-b.getSorted()).collect(Collectors.toList());
        // 3 : 查询所有的非根节点
        List<CourseCategory> subList = allList.stream().filter(category -> !category.getPid().equals(0)).collect(Collectors.toList());
        // 4 : 循环根节点去subList去找对应的子节点
        rootList.forEach(root -> busorts(root,subList));

        return rootList;
    }


    private void busorts(CourseCategory root,List<CourseCategory> subList){
        // 通过根节点去id和子节点的pid是否相等，如果相等的话，代表是当前根的子集
        List<CourseCategory> childrenList = subList.stream().filter(category -> category.getPid().equals(root.getId()))
                .sorted((a,b)->a.getSorted()-b.getSorted())
                .collect(Collectors.toList());
        // 如果你当前没一个子集，初始化一个空数组
        if(!CollectionUtils.isEmpty(childrenList)) {
            // 查询以后放回去
            root.setChildenList(childrenList);
            // 再次递归构建即可
            childrenList.forEach(category -> busorts(category,subList));
        }else{
            root.setChildenList(new ArrayList<>());
        }
    }
}

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>tree菜单</title>
    <style>
        [v-cloak]{display: none}
    </style>
</head>
<body>

    <div id="app" v-cloak>
        <h1>{{title}}</h1>
        <ksd-tree v-bind:data="dataList"></ksd-tree>
    </div>


    <script src="/js/vue.min.js"></script>
    <script src="/js/axios.min.js"></script>
    <script>

        Vue.component("ksd-tree",{
            props:{
                data:Array  // private List<?> data;
            },
            template:"<ul>" +
                        "<li v-for='(d,index) in data' @click.stop='expand(d)'>" +
                            "<span><span v-if='d.type==1'>目录</span><span v-if='d.type==2'>文件</span> {{d.title}}</span>" +
                            "<ksd-tree v-show='d.isexpand' v-if='d.childrenList' v-bind:data='d.childrenList'></ksd-tree>"+
                        "</li>" +
                    "</ul>",
            methods:{
                expand:function(obj){
                    obj.isexpand = !obj.isexpand;
                }
            }
        })
        var vue = new Vue({
            el:"#app",
            data:{
                title:"学相伴基于vue的Tree菜单",
                dataList:[]
            },
            created:function(){
                // 1： 页面加载初始化执行获取数组
                this.loadTree();
            },
            methods:{
                // 加载tree的数据信息
                loadTree:function(){
                    axios.get("/api/category/tree").then(res => {
                        this.dataList = res.data;
                    })
                }
            }
        })


    </script>


</body>
</html>

List<String> list = Arrays.asList("a,b,c", "1,2,3");
  
//将每个元素转成一个新的且不带逗号的元素
Stream<String> s1 = list.stream().map(s -> s.replaceAll(",", ""));
s1.forEach(System.out::println); // abc 123
  
Stream<String> s3 = list.stream().flatMap(s -> {
//将每个元素转换成一个Stream
String[] split = s.split(",");
Stream<String> s2 = Arrays.stream(split);
return s2;
});
s3.forEach(System.out::println); // a b c 1 2 3

Student s1 = new Student("aa", 10,1);
Student s2 = new Student("bb", 20,2);
Student s3 = new Student("cc", 10,3);
List<Student> list = Arrays.asList(s1, s2, s3);
  
//装成list
List<Integer> ageList = list.stream().map(Student::getAge).collect(Collectors.toList()); // [10, 20, 10]
  
//转成set
Set<Integer> ageSet = list.stream().map(Student::getAge).collect(Collectors.toSet()); // [20, 10]
  
//转成map,注:key不能相同，否则报错
Map<String, Integer> studentMap = list.stream().collect(Collectors.toMap(Student::getName, Student::getAge)); // {cc=10, bb=20, aa=10}
  
//字符串分隔符连接
String joinName = list.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc)
  
//聚合操作
//1.学生总数
Long count = list.stream().collect(Collectors.counting()); // 3
//2.最大年龄 (最小的minBy同理)
Integer maxAge = list.stream().map(Student::getAge).collect(Collectors.maxBy(Integer::compare)).get(); // 20
//3.所有人的年龄
Integer sumAge = list.stream().collect(Collectors.summingInt(Student::getAge)); // 40
//4.平均年龄
Double averageAge = list.stream().collect(Collectors.averagingDouble(Student::getAge)); // 13.333333333333334
// 带上以上所有方法
DoubleSummaryStatistics statistics = list.stream().collect(Collectors.summarizingDouble(Student::getAge));
System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());
  
//分组
Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));
//多重分组,先根据类型分再根据年龄分
Map<Integer, Map<Integer, List<Student>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(Student::getType, Collectors.groupingBy(Student::getAge)));
  
//分区
//分成两部分，一部分大于10岁，一部分小于等于10岁
Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));
  
//规约
Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get(); //40

浪去爪哇岛喝咖啡

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Stream流的认识和实战

问题：我需要查询用户信息，但是我需要把每个用户的信息的密码在返回的时候设置为null。为什么这样做，因为这样安全。List<User> userList = new ArrayList();List<User> newList = new ArrayList();for(User user : userList){ user.setPassword(null); newList.add(user);}// stream流化List<User> newLi
复制链接

扫一扫