forEach() 集合循环

一般循环体

List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F");
boolean flag = false;
for (String str : list) {
    if(str.equals("C")){
        flag = true;
    }
}

lambda表达式循环体

List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F");
boolean flag = false;
list.forEach(str->{
    if(str.equals("C")){
        flag = true;
    }
});
结果:会有语法错误
variable used in lambda expression should be final or effectively final
lambda表达式中使用的变量应该是final或final
原因我就不解释了,有需要可自行查

List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F");
list.forEach(str->{
    boolean flag = false;
    if(str.equals("C")){
        flag = true;
    }
});
可改成这样的写法,如果业务逻辑需要变量必须放在循环体外面,那就建议用常规循环体

filter() 设置过滤条件

List<String> strs = Arrays.asList("abc", "", "bc", "efg", "abcd",null, "jkl");
long count = strs .stream()
	.filter(str-> str==null || str.isEmpty())//根据业务添加自己的过滤条件
	.count();//统计数量
System.out.println("空字符串数量为: " + count);

//Collector作为collect方法的参数,Collector是一个接口,它是一个可变的汇聚操作,将输入元素累积到一个可变的结果容器中;它会在所有元素都处理完毕后,将累积的结果转换为一个最终的表示(这是一个可选操作);它支持串行与并行两种方式执行。
List<String> filterList = strs.stream()
	.filter(str -> str!=null && !str.isEmpty())//根据业务添加自己的过滤条件
	.collect(Collectors.toList());//collect()是结果收集器
System.out.println("筛选后不为空的列表: " + filterList);

String mergedString = strs.stream()
	.filter(str -> str!=null && !str.isEmpty())
	.collect(Collectors.joining(", "));//将符合条件的结果集合,用逗号拼接成一个字符串   
System.out.println("筛选后不为空的列表-合并字符串: " + mergedString);

统计

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
 
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
 
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
执行结果:
列表中最大的数 : 7
列表中最小的数 : 2
所有数之和 : 25
平均数 : 3.5714285714285716

sorted() 排序

需要一个User实体类

public class User{

    private Integer id;
    private String name;
    private String phone;
    private Integer age;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Integer getAge() {
        return age;
    }

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

    public User(Integer id, String name, String phone, Integer age) {
        this.id = id;
        this.name = name;
        this.phone = phone;
        this.age = age;
    }
}
public static void main(String[] args) {
        //数组排序
        List<Integer> list = Arrays.asList(3, 2, 2, 4, 7, 3, 5);

        List<Integer> sortList1 = list.stream().sorted().collect(Collectors.toList());
        System.out.println("升序排序:"+sortList1);//升序排序:[2, 2, 3, 3, 4, 5, 7]

        List<Integer> sortList2 = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        System.out.println("降序排序:"+sortList2);//降序排序:[7, 5, 4, 3, 3, 2, 2]

        //对象根据单个字段排序
        List<User> userList = Arrays.asList(
                new User(1,"张三","15614456733",23),
                new User(2,"李四","15877776733",43),
                new User(3,"王五","15614457777",48),
                new User(4,"赵六","15614457777",48)
        );

        List<User> sortList3 = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
        //根据年龄升序排序:张三、李四、王五、赵六、
        System.out.println("根据年龄升序排序:");
        sortList3.forEach(sort->{
            System.out.print(sort.getName()+"、");
        });


        List<User> sortList4 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
        //根据年龄降序排序1:王五、赵六、李四、张三、
        System.out.println("\n根据年龄降序排序1:");
        sortList4.forEach(sort->{
            System.out.print(sort.getName()+"、");
        });

        List<User> sortList5 = userList.stream().sorted(Comparator.comparing(User::getAge,Comparator.reverseOrder())).collect(Collectors.toList());
        //根据年龄降序排序2:王五、赵六、李四、张三、
        System.out.println("\n根据年龄降序排序2:");
        sortList5.forEach(sort->{
            System.out.print(sort.getName()+"、");
        });

        //对象根据多个字段排序
        List<User> sortList6 = userList.stream().sorted(Comparator.comparing(User::getAge,Comparator.reverseOrder()).thenComparing(User::getId,Comparator.reverseOrder())).collect(Collectors.toList());
        //根据年龄降序排序,年龄相同的情况根据id降序排序:赵六、王五、李四、张三、
        System.out.println("\n根据年龄降序排序,年龄相同的情况根据id降序排序1:");
        sortList6.forEach(sort->{
            System.out.print(sort.getName()+"、");
        });

        List<User> sortList7 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getId).reversed()).collect(Collectors.toList());
        //根据年龄降序排序,年龄相同的情况根据id降序排序:张三、李四、赵六、王五、
        //**注意**,此结果是错误
        System.out.println("\n根据年龄降序排序,年龄相同的情况根据id降序排序2:");
        sortList7.forEach(sort->{
            System.out.print(sort.getName()+"、");
        });

        //通过以上例子我们可以发现,两种排序是完全不一样的,而且多个字段排序的时候,使用reversed()方法会出现问题,所以建议使用Comparator.reverseOrder()
        //Comparator.comparing(类::属性一).reversed();//得到排序结果后再排序
        //Comparator.comparing(类::属性一,Comparator.reverseOrder());//直接进行排序
}

map()方法

map 方法用于映射每个元素到对应的结果:将对象转换为其他对象

需要引入的import:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "c", "e", "a", "f", "b", "d");

        //将list集合去重后组成一个新的集合
        List<String> mapList1 = list.stream().map(x -> x).distinct().collect(Collectors.toList());
        System.out.println("list去重结果:" + mapList1);

        //将list集合转成大写字母后组成新的集合
        List<String> mapList2 = list.stream().map(String::toUpperCase).distinct().collect(Collectors.toList());
        System.out.println("list转大写结果:" + mapList2);

        //将list集合追加字符串后组成新的集合
        List<String> mapList3 = list.stream().map(str -> str + "-").collect(Collectors.toList());
        System.out.println("list元素追加字符串:" + mapList3);

        List<User> userList = Arrays.asList(
                new User(1, "张三", "15614456733", 23),
                new User(2, "李四", "15877776733", 43),
                new User(3, "王五", "15614457777", 48),
                new User(4, "赵六", "15614457777", 48),
                new User(5, "admin", "15614457777", 48)
        );

        //将userList集合中的姓名组成新的集合---2种写法
        List<String> mapList4 = userList.stream().map(str -> str.getName()).collect(Collectors.toList());
        System.out.println("userList集合姓名:" + mapList4);
        List<String> mapList5 = userList.stream().map(User::getName).collect(Collectors.toList());
        System.out.println("userList集合姓名:" + mapList5);

        //将userList集合转成其他对象集合
        List<Dept> deptList1 = userList.stream().map(user ->{
            Dept dept = new Dept();
            dept.setUserName(user.getName());
            dept.setUserId(user.getId());
            if(user.getId().equals(5)){
                dept.setRemark("管理员");
            }else{
                dept.setRemark("员工");
            }
            return dept;
        }).collect(Collectors.toList());
        System.out.println("dept集合1:" + JSON.toJSON(deptList1));

        //上面方法替代了传统的写法,简化了代码
        List<Dept> deptList2 = new ArrayList<>();
        for (User user : userList) {
            Dept dept = new Dept();
            dept.setUserName(user.getName());
            dept.setUserId(user.getId());
            if(user.getId().equals(5)){
                dept.setRemark("管理员");
            }else{
                dept.setRemark("员工");
            }
            deptList2.add(dept);
        }
        System.out.println("dept集合2:" + JSON.toJSON(deptList2));
}

执行结果:
list去重结果:[a, c, e, f, b, d]
list转大写结果:[A, C, E, F, B, D]
list元素追加字符串:[a-, c-, e-, a-, f-, b-, d-]
userList集合姓名:[张三, 李四, 王五, 赵六, admin]
userList集合姓名:[张三, 李四, 王五, 赵六, admin]
dept集合1:[{"remark":"员工","userName":"张三","userId":1},{"remark":"员工","userName":"李四","userId":2},{"remark":"员工","userName":"王五","userId":3},{"remark":"员工","userName":"赵六","userId":4},{"remark":"管理员","userName":"admin","userId":5}]
dept集合2:[{"remark":"员工","userName":"张三","userId":1},{"remark":"员工","userName":"李四","userId":2},{"remark":"员工","userName":"王五","userId":3},{"remark":"员工","userName":"赵六","userId":4},{"remark":"管理员","userName":"admin","userId":5}]