java替换list中某个值 java用stream替换list中的某个元素

提示：项目中常用lambda的表达式

java8 stream 的项目应用

• 案例

---

案例

stream +索引 去除 更简洁，高效。

//定义list
List<User> list = new ArrayList<>();
User  user1 = new User();  
User  user2 = new User(); 
user1.serName("111");
user2.serName("222"); 
list.add(user1);
list.add(user2);
 
//删除集合中某一元素值
IntStream.range(0,list.size()).filter(i->
    list.get(i).getName().equals("222")).
boxed().findFirst().map(i->list.remove((int)i));
 
其中boxed为装箱操作

filter过滤，ParentId等于0或等于1

//filter过滤，ParentId等于0或等于1
List<DeptDTO> deptDTOList =
                deptDTOS.stream().filter(deptDTO -> deptDTO.getParentId().equals(0) || deptDTO.getParentId().equals(1)).collect(Collectors.toList());

list转map

Map<String, List<Integer>> map = list.stream().collect(Collectors.toMap(Function.identity(), s-> new ArrayList<>()));

list转linkedHashMap

accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2,LinkedHashMap::new));

转成set时直接用toSet，或者用.distinct()做去重
把实体类的集合抽出某属性转成list

// 转成set时直接用toSet，或者用.distinct()做去重
// 把实体类的集合抽出某属性转成list
List<Integer> collect = banners.stream().map(BankBanner::getPictureSort).collect(Collectors.toList());

把实体类的集合转map

// 把实体类的集合转map

public Map<String, Account> getNameAccountMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2));
}

排序

//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));

//返回 对象集合以类属性一降序排序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序
 
//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));

//返回 对象集合以类属性一降序 属性二升序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序
 
//返回 对象集合以类属性一降序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
 
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序<br><br><br>

过滤把list转map

// 把list转map
personList.stream().filter(t -> t.getName()!=null)
.collect(Collectors.toMap(Person::getCode,Person::getName,(k1,k2)->k2));

获取某实体类集合某字段中最大/最小的值

// 获取某实体类集合某字段中最大/最小的值
userList.stream().max(Comparator.comparing(User::getAge)).get();
userList.stream().min(Comparator.comparing(User::getAge)).get();

获取某整数集合某字段中最大/最小的值

// 获取某整数集合某字段中最大/最小的值
integerList.stream().max(Integer :: max).get();
integerList.stream().min(Integer :: max).get();

获取集合某字段中最大值

// 获取集合某字段中最大值
timeList.stream().filter(o -> o.getTime() != null).map(TimeTest::getTime).distinct().max((e1, e2) -> e1.compareTo(e2)).get();

大于2L 和 小于等于2进行 分组

//大于2L 和 小于等于2进行 分组
Map<Boolean, List<DxUser>> collect1 = list.stream().collect(Collectors.groupingBy(x -> x.getId() > 2));
System.out.println("===大于2L==");
collect1.get(true).forEach(System.out::println);
System.out.println("===小于等于2L==");
collect1.get(false).forEach(System.out::println);

分割，聚合，分组

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