Lamada List 去重及其它操作示例

import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

private static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
facultyRetList = facultyList.stream().filter(distinctByKey(Faculty::getId)).collect(Collectors.toList());

　更多相关操作如下

import com.example.springdemo.testFunc.pojo.Student;
import com.example.springdemo.testFunc.pojo.User;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toList;

/**
 * @Package：com.example.springdemo.testFunc
 * @Description: $star$
 * @author cc x
 * @date  2021-9-6 -  10:06
 * @version：V1.0
 * @Copyright: 2021 Inc. All rights reserved.
 */
public class ListOperate {

    public static void main(String[] args) {


        List<String> list1 = new ArrayList();
        List<String> list2 = new ArrayList();


        // 交集
        List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
        System.out.println("---得到交集 intersection---");
        intersection.parallelStream().forEach(System.out::println);

        // 差集 (list1 - list2)
        List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
        System.out.println("---得到差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out::println);

        // 差集 (list2 - list1)
        List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
        System.out.println("---得到差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out::println);

        // 并集
//        List<String> listAll = list1.parallelStream().collect(toList());
//        List<String> listAll2 = list2.parallelStream().collect(toList());
//        listAll.addAll(listAll2);
        System.out.println("---得到并集 listAll---");


        List<Student> list = new ArrayList<>();
        Collections.addAll(list,
                new Student("张三"),
                new Student("李四"),
                new Student("王五"),
                new Student("张三"),
                new Student("李四"),
                new Student("赵六"));

        System.out.println("去重之前: ");
        System.out.println("list = " + list);
        // 吧所有的name 拼成一个List
        List<String> pa = list.stream().map(Student::getName).collect(toList());
        System.out.println("获取对象单一属性转换为List: ");
        pa.forEach(System.out::println);

        Set<Student> set = new TreeSet<>(Comparator.comparing(Student::getName));
        set.addAll(list);
        System.out.println("去重之后 =》 1 : ");
        set.forEach(System.out::println);
        testDisComSort();

        // 尝试 steam 的 <wiz_tmp_highlight_tag class="cm-searching">lamada 操作

        User user1 = new User(5, "aa");
        User user2 = new User(2, "ba");
        User user3 = new User(3, "ac");
        User user4 = new User(1, "aad");
        User user5 = new User(4, "asd");
        List<User> userList = Arrays.asList(user1, user2, user3, user4, user5);
        System.out.println("初始数据");        
userList.forEach(System.out::println);        
//获取所有ID集合        
List<Integer> idList = userList.stream().map(User::getId).collect(Collectors.toList());        
System.out.println("获取所有ID集合" + idList);        
//排序ID        
List<User> userList1 = userList.stream().sorted(Comparator.comparingInt(User::getId)).collect(Collectors.toList());        
System.out.println("排序ID" + userList1);        
//分组        
Map<String, Long> map = userList.stream().collect(Collectors.groupingBy(User::getName, Collectors.counting()));        
System.out.println("分组" + map);        
//获取id大于2的        
List<User> userList2 = userList.stream().filter(user -> user.getId() > 2).collect(Collectors.toList());        
System.out.println("获取id大于2的" + userList2);        
//获取最大        
Integer id = userList.stream().map(User::getId).max(Integer::compareTo).get();        
System.out.println("获取最大" + id);        
//获取最小        
Integer id1 = userList.stream().map(User::getId).min(Integer::compareTo).get();        
System.out.println("获取最小" + id1);        
//获取id数量        
long count = userList.stream().map(User::getId).count();        
System.out.println("获取id数量" + count);        
//总和        
int sum = userList.stream().mapToInt(User::getId).sum();        
System.out.println("总和" + sum);        
//获取平均值        
double d = userList.stream().mapToInt(User::getId).average().getAsDouble();        
//匹配findAny/allMatch/noneMatch多用来判断        
User user = userList.stream().findAny().get();        
//获取第一个对象        
User user6 = userList.stream().findFirst().get();        
System.out.println("获取第一个对象" + user6);        
//将名字全转换为大写        
List<String> list4 = userList.stream().map(User::getName).map(String::toUpperCase).collect(Collectors.toList());        
System.out.println("将名字全转换为大写");        
list4.forEach(System.out::println);        
//获取忽略第一个并取前几条数据        
List<User> list14 = userList.stream().skip(1).limit(2).collect(Collectors.toList());        
System.out.println("获取忽略第一个并取前几条数据");        
list14.forEach(System.out::println);        

//去重        
List<User> collect = userList.stream().distinct().collect(Collectors.toList());        
System.out.println("去重");        
collect.forEach(System.out::println);    


}    

public static void testDisComSort() {        
//定义一个100元素的集合，包含A-Z        
List<String> list = new LinkedList<>();        
for (int i = 0; i < 100; i++) {            
list.add(String.valueOf((char) ('A' + Math.random() * ('Z' - 'A' + 1))));        
}        
System.out.println(list);
//统计集合重复元素出现次数，并且去重返回hashmap        
Map<String, Long> map = list.stream().                
collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));        
System.out.println(map);
//由于hashmap无序，所以在排序放入LinkedHashMap里(key升序)        
Map<String, Long> sortMap = new LinkedHashMap<>();        
map.entrySet().stream().sorted(Map.Entry.comparingByKey()).                
forEachOrdered(e -> sortMap.put(e.getKey(), e.getValue()));        
System.out.println(sortMap);
//获取排序后map的key集合        
List<String> keys = new LinkedList<>();        
sortMap.entrySet().stream().forEachOrdered(e -> keys.add(e.getKey()));        
System.out.println(keys);
//获取排序后map的value集合        
List<Long> values = new LinkedList<>();        
sortMap.entrySet().stream().forEachOrdered(e -> values.add(e.getValue()));        
System.out.println(values);    
}}