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