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);
}}