假如只有一个参数 ()括号 可以省略

如果方法体只有一条语句，{} 大括号可以省

如果方法体中唯一的语句是return 返回语句，那么省略大括号的同时reutn也可以省

forEach遍历

List<String> list = new ArrayList<>();
list.add("111");
list.add("222");
list.add("333");
list.forEach(item->{
    System.out.println(item);
});

排序   

public static void main(String[] args) {

    List<String> list = new ArrayList<>();
    list.add("111");
    list.add("333");
    list.add("222");

    list.forEach(item -> {
        System.out.println(item);
    });
    Collections.sort(list, (s1, s2) -> {
        return s1.compareTo(s2);
    });
    list.forEach(item -> {
        System.out.println(item);
    });
}

排序2

// 核心排序代码：使用 Stream API 按 count 降序排序（大到小）
List<Dept> sortedDeptList = deptList.stream()
        // 按 count 降序排序，若 count 可能为 null，需先做非空判断
        .sorted((d1, d2) -> {
            // 处理 count 为 null 的情况，避免空指针异常，null 视为 0 或排到末尾
            Long count1 = d1.getCount() == null ? 0L : d1.getCount();
            Long count2 = d2.getCount() == null ? 0L : d2.getCount();
            // 降序排序：d2 在前 - d1 在后（升序为 count1 - count2）
            return count2.compareTo(count1);
        })
        .collect(Collectors.toList());

过虑  filter  查询1开头的字符串

List<String> list = new ArrayList<>();
list.add("111");
list.add("333");
list.add("222");
List<String> list2 = list.stream().filter(item->item.startsWith("1")).collect(Collectors.toList());
System.out.println(list2);

===============
public static void main(String[] args) {

    List<String> list = new ArrayList<>();
    list.add("111");
    list.add("333");
    list.add("222");
    List<String> list2 = list.stream().filter(item->{
       return item.startsWith("1");
    }).collect(Collectors.toList());
    System.out.println(list2);
}

Lambda 表达式 映射   各种转。

public static void main(String[] args) {

    List<String> list = new ArrayList<>();
    list.add("111");
    list.add("333");
    list.add("222");
    List<Integer> list2 = list.stream().map(item->{
       return item.length();
    }).collect(Collectors.toList());
    System.out.println(list2);
}


===========可以简写。参考上面的。 可以把{} 和return删除了。

list<实体> 转成list<integer> 

    List<SysRoleMenu> roleMenuList = sysRoleMenuService.list(new QueryWrapper<SysRoleMenu>().eq("role_id", id));
    List<Long> menuIdList = roleMenuList.stream().map(p -> p.getMenuId()).collect(Collectors.toList());

list<integer>  转成字符串  1,2,5,3

List<Integer> 变成字符串 逗号 分割

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);String result = list.stream()
                   .map(String::valueOf)
                   .collect(Collectors.joining(","));
System.out.println(result);

字符串 1,2,5  转list<integer>

List<Integer> list = Arrays.stream(str.split(","))
                           .map(Integer::parseInt)
                           .collect(Collectors.toList());

Lambda 表达式 归约

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(4);
Integer sum = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);

===============
public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(3);
    list.add(4);
    Integer sum = list.stream().reduce(0, (a, b) -> {
        return  a + b;
    });
    System.out.println(sum);
}





// 使用Stream API计算总金额
BigDecimal totalAmount = list.stream()
      .map(day -> {
         // 计算每个OrderDay的总金额 
         BigDecimal dayTotal = day.getPrice().multiply(BigDecimal.valueOf(day.getPersonNum()))
               .add(day.getDanPrice().multiply(BigDecimal.valueOf(day.getFangcha())));
         return dayTotal;
      })
      .reduce(BigDecimal.ZERO, BigDecimal::add);
      
      
      
// 计算总金额 - 优化后的Stream API
BigDecimal totalAmount = list.stream()
      .map(OrderDay::getAmount)
      .reduce(BigDecimal.ZERO, BigDecimal::add);

Lambda 表达式 进行分组  根据长度进行分组。

public static void main(String[] args) {

    List<String> list = new ArrayList<>();
    list.add("111");
    list.add("333");
    list.add("21122");
    Map<Integer,List<String>> map = list.stream().collect(Collectors.groupingBy(item->{
       return item.length();
    }));
    System.out.println(map);
}

Lambda 表达式 函数式接口的实现

list 删除其中某个节点 

forEach存在的缺点

List<DuanDaKu> duanDaKuList = duanDaKuSerice.list(map,1,1000);
Integer num_shengyu = num;//因为有可能不够减，所以要记录，还有多少没有减掉。
duanDaKuList.forEach(duanda->{
    //减少对应的数量。
   Integer shengyu= duanda.getNum()- duanda.getNum2();
   if(shengyu.compareTo(num)>=0){
        //对比,0是相等于  值1比值2大，返回1         值1比值2小，返回-1
       //够减
       num_shengyu = 0;
   }else{
       //不够减 ， 还要继续 减
   }
});
//上面代码不能直接修改num_shengyu = 0 ; 报错。

改成普通的for就不会  报错了。

求和。 stream.mapToInt

Integer sum = recordValueList.stream().mapToInt(RecordValue::getMonthValue).sum();


Integer sum = recordValueList.stream()
        .map(RecordValue::getMonthValue) // 获取月份值
        .filter(Objects::nonNull) // 过滤掉为null的值
        .mapToInt(Integer::intValue) // 转换为int值
        .sum();
        
        
        //如果是list里面没有数据，输出是0
 List<RecordValue> recordValueList = new ArrayList<>(); 、、
Integer sum_xiufu = recordValueList.stream()
      .map(RecordValue::getPjXiuTime) //  平均修复时间
      .filter(Objects::nonNull) // 过滤掉为null的值
      .mapToInt(Integer::intValue) // 转换为int值
      .sum();
System.out.println(sum_xiufu);//输出是0