Java中使用Stream流（总结）

介绍：Java 8 是一种流式编程，它支持通过使用Stream来更高效率地处理用户设定的操作。使用流API，您可以执行以下操作：

过滤 filter:对流中的元素进行过滤，仅保留符合给定条件的元素。
映射 map: 对流中的每个元素执行指定的函数，并将结果收集到另一个流中。
排序P sorted:根据指定的排序规则对流中的元素进行排序。
合并 reduce:将流中的元素合并到一个单一的结果中，使用给定的函数作为累加器，可以使用此函数对每个元素执行特定的功能。
聚合 collect:收集流中的元素，将它们收集到集合中，或将它们处理为Map，并返回一个结果容器。
计数 count:计算流中元素数量。
最值 min/max:返回流中的最小或最大元素。
匹配 anyMatch/allMatch/noneMatch:检查流中的元素是否与给定的条件匹配。

区别

Stream().map是将原有的集合中的每一项，通过映射函数转换为新的集合；而Stream().filter是对原有集合进行过滤，过滤出符合条件的结果集，剩下不满足条件的不作处理。

实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Test implements Serializable {


    private Integer id;

    private String name;

    private String address;

//    部门id
    private Integer deptId;
    
        public Test(String name, String address) {
        this.name = name;
        this.address = address;
    }
    
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class DeptMerge implements Serializable {

    private Integer testId;

    private Integer deptId;

}

测试

    //   测试
    public static void main(String[] args) {

        List<Test> testList = Arrays.asList(new Test(1, "张三", "安徽", 2), new Test(2, "李四", "芜湖", 2), new Test(3, "王五", "六安", 3), new Test(4, "赵七", "南京", 4), new Test(5, "张三", "南京", 5));

//    获取当中的name集合
        List<String> nameList = testList.stream().map(test -> test.getName()).collect(Collectors.toList());
//    System.out.println(nameList);     [张三, 李四, 王五, 赵七]
//    将testList的id转换为Long
        Integer[] idToLong = testList.stream().map(Test::getId).toArray(Integer[]::new);
//    System.out.println(idToLong);  [1,2,3,4]
        // list - > new List
        List<Test> newList = testList.stream().map(p -> {
            return new Test(p.getName(), p.getAddress());
        }).collect(Collectors.toList());
//    System.out.println(newList);
//[Test(id=null, name=张三, address=安徽, deptId=null), Test(id=null, name=李四, address=芜湖, deptId=null), Test(id=null, name=王五, address=六安, deptId=null), Test(id=null, name=赵七, address=南京, deptId=null)]
//将学生姓名放到Set中，可以实现去重功能
        Set<String> collectToSet = testList.stream().map(Test::getName).collect(Collectors.toSet());
//[李四, 张三, 王五, 赵七]

//        使用Arrays.stream().map   适用于一对多关系
        Integer[] toArray = testList.stream().map(Test::getId).toArray(Integer[]::new);
        Arrays.stream(toArray).map(id->new DeptMerge(id,1)).collect(Collectors.toSet());
        System.out.println(toArray);
    }

user实体类

public class User {
    private String name;
    private int age;

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

    public User() {
    }

    public String getName() {
        return name;
    }

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

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

    public int getAge() {
        return age;
    }

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

 public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张三",20));
        users.add(new User("李四",23));
        users.add(new User("王五",18));
        Stream<User> stream = users.stream();
        Optional<User> sum = stream.reduce(new BinaryOperator<User>() {
            @Override
            public User apply(User user, User user2) {
                User sum = new User("sum", user.getAge() + user2.getAge());
                return sum;
            }
        });
        System.out.println(sum.get());

    }

public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张三",20));
        users.add(new User("李四",23));
        users.add(new User("王五",18));
        Stream<User> stream = users.stream();
        Optional<User> min = stream.min(new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println(min.get());
    }
}

public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张三",20));
        users.add(new User("李四",23));
        users.add(new User("王五",18));
        Stream<User> stream = users.stream();
        boolean b = stream.allMatch(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return "张三".equals(user.getName());
            }
        });
        System.out.println(b);

    }
}

 public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张三",20));
        users.add(new User("李四",23));
        users.add(new User("王五",18));
        Stream<User> stream = users.stream();
        stream.filter(user -> "张三".equals(user.getName()) && user.getAge()>18).forEach(s-> System.out.println(s));
    }
}

  public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张三",20));
        users.add(new User("李四",23));
        users.add(new User("王五",18));
        Stream<User> stream = users.stream();
        stream.skip(2).limit(2).forEach(s-> System.out.println(s));


    }
}

public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张三",20));
        users.add(new User("李四",23));
        users.add(new User("王五",18));
        users.add(new User("王五",28));
        users.add(new User("赵六",15));
        Stream<User> stream = users.stream();
        stream.sorted((o1,o2)->-(o1.getAge()-o2.getAge())).filter(s->"王五".equals(s.getName())).limit(2).forEach(s-> System.out.println(s));
    }
}

public static void main(String[] args) {
        Instant now = Instant.now();
        int sum=0;
        for (int i = 0; i < 1000000; i++) {
            sum+=i;
        }
        Instant end = Instant.now();
        System.out.println("话费的时间是："+ Duration.between(now,end).toMillis());
    }
}

 public static void main(String[] args) {
        String username=null;
Optional.ofNullable(username).filter(new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return "张三".equals(s);
    }
}).isPresent();


    }
}

public static void main(String[] args) {
        String username=null;
        Optional<String> option = Optional.ofNullable(username);
        if (option.isPresent()){
            System.out.println(option.get());
        }
    }
}

原文链接：https://blog.csdn.net/qq_55362295/article/details/129239074

你可能也喜欢