关于java新特性.stream()链式编程的常用点汇总

目录

List:

1.Java8对List集合对象某个字段进行排序

2.java中list根据两个属性进行分组

3.java中list根据条件过滤

4.java中list去重

5.根据某属性判断list中是否包含有同值实体

6.使用stream()来遍历list

7.使用stream()来遍历list实体属性并做改动

8.使用stream()判断一个list集合中是否包含某个属性值的对象(是返回true)

9.Stream流求和

Map:

1.java8使用.stream()按Map的键排序

2.将Map按key排序最简单办法，使用TreeMap特性

---

List:

1.Java8对List集合对象某个字段进行排序

注：sorted()排序根据首字母排序的，故数字字符排序时需转化后排序。

（1）单一属性排序

写法一：

// 根据年龄倒叙，不写reversed()，默认升序

List<StudentInfo> collect = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge).reversed())

.collect(Collectors.toList());
//排序后输出
StudentInfo.printStudents(studentsSortName);

//字符串转换为数值再排序

List<StudentInfo> collect = studentList.stream().sorted(       Comparator.comparing(StudentInfo::getAge,Comparator.comparingInt(Integer::parseInt)).reversed()).collect(Collectors.toList());
//排序后输出
StudentInfo.printStudents(studentsSortName);

写法二：

List<StudentInfo> collect = studentList.stream().sorted(Comparator.comparing(vo->Integer.parseInt(vo.getAge())).reversed())

.collect(Collectors.toList());

（2）多属性排序

// 先根据年龄升序，在根据性别倒叙
List<StudentInfo> collect1 = studentList.stream().sorted(

   Comparator.comparing(StudentInfo::getAge).

   thenComparing(StudentInfo::getSex,Comparator.reverseOrder())

).collect(Collectors.toList());

2.java中list根据两个属性进行分组

（1）对实体类型的list集合进行分组：
Map<Long, Map<Integer, List<SubsZinger>>> collect = subsZingerList.stream().collect(Collectors.groupingBy(SubsZinger::getPrintInId, Collectors.groupingBy(SubsZinger::getUid)));
collect.forEach((key,value)->{
    System.out.println("外键"+key+"外部值"+value);
    value.forEach((key2,value2)->{
        System.out.println("内键"+key2+"内部值"+value2);
    });
});

（2）对Map类型的list集合进行分组：
List<Map<String, String>> billDiscodeList = Lists.newArrayList();
HashMap<String, String> billDiscode = Maps.newHashMap();
billDiscode.put("DiagIcd", diseaseCode);
billDiscode.put("DiagName", diseaseName);
billDiscodeList.add(billDiscode);
//对元素类型为Map的List集合进行stream()处理：
Map<String, List<Map<String, String>>> diagIcdGroup = billDiscodeList.stream().collect(Collectors.groupingBy(map -> map.get("DiagIcd")));

3.java中list根据条件过滤

//去掉含急诊的科室(单一条件)
List<DeptListVO> southDeptList = deptListVO.stream() .filter(dept -> !dept.getDeptName().contains("急诊")) .collect(Collectors.toList());

//去掉含急诊 且 科室code为001的科室(多条件)
List<DeptListVO> southDeptList = deptListVO.stream() .filter(dept -> !dept.getDeptName().contains("急诊")&&dept -> dept.getDeptCode().equals("001")) .collect(Collectors.toList());

4.java中list去重

//(1)对于 String去重
List<String> stringList = new ArrayList<String>() {{
    add("A");
    add("A");
    add("B");
    add("B");
   add("C");
}};
stringList = stringList.stream().distinct().collect(Collectors.toList());

//(2)对于Student 列表实体去重
List<Student> studentList = getStudentList();
studentList = studentList.stream().distinct().collect(Collectors.toList());

//(3)对于实体某属性去重

方式1：

private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

List<Student> studentList = studentList.stream().filter(distinctByKey(Student::getName)).collect(Collectors.toList());

方式2：

List<Student> studentList = studentList.stream().collect(
      collectingAndThen(
              toCollection(() -> new TreeSet<>(Comparator.comparing(Student::getName))), ArrayList::new
      )
);

5.根据某属性判断list中是否包含有同值实体

boolean isContail = studentList.stream()
.anyMatch(student -> student.getName().equals("张三"));

6.使用stream()来遍历list

List<String> list1 = new ArrayList();
list1.add("a");
list1.add("b");
List<String> list2 = new ArrayList();
list1.stream().forEach(str ->{
    list2.add(str);
});
System.out.println(list2);

7.使用stream()来遍历list实体属性并做改动

List patientInfoList=new ArrayList<>();
patientInfoList.stream().map(orderVO -> {
            PatientInfoVO vo = new PatientInfoVO();
            vo.setPatientName(orderVO.getPatientName());
            vo.setRegTime(orderVO.getUpdateTime());
            return vo;
        }).collect(Collectors.toList());

8.使用stream()判断一个list集合中是否包含某个属性值的对象(是返回true)

list.stream().filter(m->m.getName().equals("张三")).findAny().isPresent();

9.Stream流求和

1.Java泛型为Integer、Long、Double、BigDecimal求和

Integer sum = scores.stream().reduce(Integer::sum).orElse(0);
Long sum = scores.stream().reduce(Long::sum).orElse(0L);
Double sum = scores.stream().reduce(Double::sum).orElse(0.00);
BigDecimal sum = scores.stream().reduce(BigDecimal::add).orElse(new BigDecimal(0.00));

2.泛型为实体类

对单个属性求和

 Integer sum = sales.stream().mapToInt(Sale::getOrderNum).sum();
 Long sum = sales.stream().mapToLong(Sale::getOrderNum).sum();
 Double sum = sales.stream().mapToDouble(Sale::getOrderNum).sum();
 BigDecimal sum = sales.stream().map(Sale::getAppleSale).reduce(BigDecimal.ZERO, BigDecimal::add);

对多个属性求和

// 类型为BigDecimal
Sale result = sales.stream().reduce((x, y) -> new Sale(x.getAppleSale().add(y.getAppleSale()),
                x.getBananaSale().add(y.getBananaSale()), x.getGrapeSale().add(y.getGrapeSale())))
                .orElse(new Sale(BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO));
// 类型为Integer、Long、Double（注：orElse中需输入对应类型初始值）
Sale sale = sales.stream().reduce((x, y) -> new Sale(x.getAppleSale() + y.getAppleSale(),
                x.getBananaSale() + y.getBananaSale(), x.getGrapeSale() + y.getGrapeSale()))
                .orElse(new Sale(0.00, 0.00,0.00));

注意：多属性求和需在对应实体中添加对应的有参构造方法。

Map:

1.java8使用.stream()按Map的键排序

// 按照Map的键进行排序

Map<String, Integer> sortedMap = studentMaps.entrySet().stream() .sorted(Map.Entry.comparingByKey())

.collect(Collectors.toMap(

         Map.Entry::getKey,

         Map.Entry::getValue,

         (oldVal, newVal) -> oldVal, LinkedHashMap::new

) );

// 将排序后的Map打印

sortedMap.entrySet().forEach(System.out::println);

2.将Map按key排序最简单办法，使用TreeMap特性

原理：TreeMap内的元素是有顺序的，所以利用TreeMap排序也是可取的一种方法。

// 将 `HashMap` 转为 `TreeMap`

Map<String, Integer> sorted = new TreeMap<>(maps); //正序

Map<String, Integer> sorted = new TreeMap<>(Comparator.reverseOrder(maps)); //倒序