非常全面的lambda表達式對List集合去重、分組、排序、過濾、求和、最值方法工具類

我們經常會對list集合去重，於是我自己花了點時間將如何用 lambda表達式對list集合去重做了封裝和測試，方便以後快速使用。包括對對象集合中的某個屬性去重等。如果有特殊的list去重要求，可以自行對下列方法進行修改。

下列方法是本人驗證過比較簡便的寫法，請參考：

一、去重

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

public class ListUtil {

    public static List<String> list = Arrays.asList("1","2","2","3","3","4","4","5","6","7","8");
    public static List<City> cities = null;
    static {
        cities = new ArrayList<City>(){
            {
                add(new City("上海",11));
                add(new City("武漢",22));
                add(new City("武漢",55));
                add(new City("上海",33));
                add(new City("北京",33));
                add(new City("深圳",43));
            }
        };

    }
    public static void main(String[] args) {
        System.out.println(ListUtil.distinctElements(list));
        System.out.println(ListUtil.getNoDuplicateElements(list));
        System.out.println(ListUtil.getDuplicateElements(list));
        System.out.println(ListUtil.getDuplicateElementsForObject(cities));
        System.out.println(ListUtil.getNoDuplicateElementsForObject(cities));
        System.out.println(ListUtil.getElementsAfterDuplicate(cities));
        System.out.println(ListUtil.getDuplicateObject(cities));
        System.out.println(ListUtil.getNoDuplicateObject(cities));
        System.out.println(ListUtil.distinctObject(cities));
    }



    //去重後的集合 [1, 2, 3, 4, 5, 6, 7, 8]
    public static <T> List<T> distinctElements(List<T> list) {
        return list.stream().distinct().collect(Collectors.toList());
    }

    //lambda表達式 去除集合重複的值  [1, 5, 6, 7, 8]
    public static <T> List<T> getNoDuplicateElements(List<T> list) {
        // 獲得元素出現頻率的 Map，鍵爲元素，值爲元素出現的次數
        Map<T, Long> map = list.stream().collect(Collectors.groupingBy(p -> p,Collectors.counting()));
        System.out.println("getDuplicateElements2: "+map);
        return map.entrySet().stream() // Set<Entry>轉換爲Stream<Entry>
                .filter(entry -> entry.getValue() == 1) // 過濾出元素出現次數等於 1 的 entry
                .map(entry -> entry.getKey()) // 獲得 entry 的鍵（重複元素）對應的 Stream
                .collect(Collectors.toList()); // 轉化爲 List
    }

    //lambda表達式 查找出重複的集合 [2, 3, 4]
    public static <T> List<T> getDuplicateElements(List<T> list) {
        return list.stream().collect(Collectors.collectingAndThen(Collectors
                            .groupingBy(p -> p, Collectors.counting()), map->{
                                map.values().removeIf(size -> size ==1); // >1 查找不重複的集合；== 1 查找重複的集合
                                List<T> tempList = new ArrayList<>(map.keySet());
                                return tempList;
                            }));
    }

    //利用set集合
    public static <T> Set<T> getDuplicateElements2(List<T> list) {
        Set<T> set = new HashSet<>();
        Set<T> exist = new HashSet<>();
        for (T s : list) {
            if (set.contains(s)) {
                exist.add(s);
            } else {
                set.add(s);
            }
        }
        return exist;
    }

    /**-----------對象List做處理--------------*/

    //查找對象中某個原屬重複的  屬性集合   [上海, 武漢]
    public static List<String> getDuplicateElementsForObject(List<City> list) {
        return list.stream().collect(Collectors.groupingBy(p -> p.getCity(),Collectors.counting())).entrySet().stream()
                .filter(entry -> entry.getValue() > 1) // >1 查找重複的集合；== 查找不重複的集合
                .map(entry -> entry.getKey())
                .collect(Collectors.toList());
    }

    //查找對象中某個原屬未重複的  屬性集合   [深圳, 北京]
    public static List<String> getNoDuplicateElementsForObject(List<City> list){
        Map<String,List<City>> map = list.stream().collect(Collectors.groupingBy(City::getCity));
        return map.entrySet().stream().filter(entry -> entry.getValue().size() == 1)
                .map(entry -> entry.getKey()) // 獲得 entry 的鍵（重複元素）對應的 Stream
                .collect(Collectors.toList()); // 轉化爲 List

    }

    //查找對象中某個原屬去重後的集合 [上海, 武漢, 北京, 深圳]
    public static List<String> getElementsAfterDuplicate(List<City> list) {
        return list.stream().map(o->o.getCity()).distinct().collect(Collectors.toList());
    }

    //對象中某個原屬重複的 對象集合
    // [[City(city=上海, total=11), City(city=上海, total=33)], [City(city=武漢, total=22), City(city=武漢, total=55)]]
    public static List<List<City>> getDuplicateObject(List<City> list) {
        return list.stream().collect(Collectors.groupingBy(City::getCity)).entrySet().stream()
                .filter(entry -> entry.getValue().size() > 1) // >1 查找重複的集合；== 查找不重複的集合
                .map(entry -> entry.getValue())
                .collect(Collectors.toList());
    }

    //對象中某個原屬未重複 對象集合
    //[[City(city=深圳, total=43)], [City(city=北京, total=33)]]
    public static List<City> getNoDuplicateObject(List<City> list) {
        List<City> cities = new ArrayList<>();
        list.stream().collect(Collectors.groupingBy(City::getCity)).entrySet().stream()
                    .filter(entry -> entry.getValue().size() ==1) //>1 查找重複的集合；== 查找不重複的集合;
                    .map(entry -> entry.getValue())
                    .forEach(p -> cities.addAll(p));
        return cities;
    }


    //根據對象的某個原屬去重後的 對象集合
    //[City(city=上海, total=11), City(city=武漢, total=22), City(city=北京, total=33), City(city=深圳, total=43)]
    public static List<City> distinctObject(List<City> list) {
        return list.stream().filter(distinctByKey(City::getCity)).collect(Collectors.toList());
    }

    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return object -> seen.putIfAbsent(keyExtractor.apply(object), Boolean.TRUE) == null;
    }

}

二、排序

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

public class ListUtil_sort {

    public static List<Integer> list = Arrays.asList(10,1,6,4,8,7,9,3,2,5);
    public static List<City> cities = null;
    public static List<City> cities2 = null;
    static {
        cities = new ArrayList<City>(){
            {
                add(new City("上海",11));
                add(new City("武漢",55));
                add(new City("南京",33));
                add(new City("深圳",33));
            }
        };

        cities2 = new ArrayList<City>(){
            {
                add(new City("上海",11,11));
                add(new City("武漢",55,22));
                add(new City("南京",33,55));
                add(new City("深圳",33,44));
            }
        };

    }
    public static void main(String[] args) {
        System.out.println(sort(list));
        System.out.println(reversed(list));
        System.out.println(sortForObject(cities));
        System.out.println(reversedForObject(cities));
        System.out.println(sortForObject2(cities2));
    }

    //list排序 正序
    public static <T> List<T> sort(List<T> list){
        return list.stream().sorted().collect(Collectors.toList());
    }

    //list排序 倒序
    public static List<Integer> reversed(List<Integer> list){
        return list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
    }

    //根據對象某個屬性排序  正序
    public static List<City> sortForObject(List<City> list){
        return list.stream().sorted(Comparator.comparing(City::getTotal)).collect(Collectors.toList());
    }

    //根據對象某個屬性排序  倒序
    public static List<City> reversedForObject(List<City> list){
        return list.stream().sorted(Comparator.comparing(City::getTotal).reversed()).collect(Collectors.toList());
    }

    //根據對象兩個屬性排序  正序
    public static List<City> sortForObject2(List<City> list){
        return list.stream().sorted(Comparator.comparing(City::getTotal).thenComparing(City::getNum)).collect(Collectors.toList());
    }
}

三、過濾、求和、最值

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

public class ListUtil_sum {

    public static List<Integer> list = Arrays.asList(10,1,6,4,8,7,9,3,2,5);
    public static List<String> strList = Arrays.asList("10","1","6","4");
    public static List<City> cities = null;
    public static Map<String,Integer> cityMap = null;
    static {
        cities = new ArrayList<City>(){
            {
                add(new City("上海",11));
                add(new City("武漢",55));
                add(new City("武漢",45));
                add(new City("深圳",33));
            }
        };
        cityMap = new HashMap<>();
        cityMap.put("武漢",55);
        cityMap.put("上海",11);
    }
    public static void main(String[] args) {
        System.out.println(calculation(list));
        calculation2(cities);
        listToMap(cities);
        mapToList(cityMap);
        stringToList("上海、武漢");
        joinStringValueByList(cities);
        joinStringValueByList2(strList);
        System.out.println(filter(cities));
    }


    //根據對象某個屬性求各自值
    ///IntSummaryStatistics{count=4, sum=132, min=11, average=33.000000, max=55}
    public static IntSummaryStatistics calculation(List<Integer> list){
        IntSummaryStatistics stat = list.stream().collect(Collectors.summarizingInt(p -> p));
        System.out.println("max:"+stat.getMax());
        System.out.println("min:"+stat.getMin());
        System.out.println("sum:"+stat.getSum());
        System.out.println("count:"+stat.getCount());
        System.out.println("average:"+stat.getAverage());
        return stat;
    }

    //根據對象某個屬性求各自值
    public static void calculation2(List<City> list){
        System.out.println("sum="+ list.stream().mapToInt(City::getTotal).sum());
        System.out.println("max="+ list.stream().mapToInt(City::getTotal).max().getAsInt());
        System.out.println("min="+ list.stream().mapToInt(City::getTotal).min().getAsInt());
        System.out.println("ave="+ list.stream().mapToInt(City::getTotal).average().getAsDouble());
    }

    //功能描述 List轉map
    public static void listToMap(List<City> list){
        //用 (k1,k2)->k1 來設置，如果有重複的key,則保留key1,捨棄key2
        Map<String,City> map = list.stream().collect(Collectors.toMap(City::getCity,city -> city, (k1, k2) -> k1));
        map.forEach((k,v) -> System.out.println("k=" + k + ",v=" + v));
    }


    //對象某個屬性 等於特定值的累加
    public static void calculation11(List<City> list){
        Map<String, IntSummaryStatistics> intSummaryStatistics = list.stream().
                collect(Collectors.groupingBy(i -> i.getCity(), Collectors.summarizingInt(City::getTotal)));
        System.out.println("-4-->" + intSummaryStatistics);
        System.out.println("-5-->" + intSummaryStatistics.get("武漢").getSum());
    }

    //功能描述 map轉list
    public static void mapToList(Map<String,Integer> map){
        List<City> list = map.entrySet().stream().map(key -> new City(key.getKey(),key.getValue())).collect(Collectors.toList());
        System.out.println(list);
        list.forEach(bean -> System.out.println(bean.getCity() + "," + bean.getTotal()));
    }

    //功能描述 字符串轉list
    public static void stringToList(String str){
        //不需要處理
        //<String> list = Arrays.asList(str.split(","));
        //需要處理
        List<String> list = Arrays.asList(str.split(",")).stream().map(string -> String.valueOf(string)).collect(Collectors.toList());
        list.forEach(string -> System.out.println(string));
    }

    //功能描述 姓名以逗號拼接
    public static void joinStringValueByList(List<City> list){
        System.out.println(list.stream().map(City::getCity).collect(Collectors.joining(",")));
    }

    //功能描述 姓名以逗號拼接
    public static void joinStringValueByList2(List<String> list){
        //方式一
        System.out.println(String.join(",", list));
        //方式二
        System.out.println(list.stream().collect(Collectors.joining(",")));
    }

    //功能描述 過濾
    public static List<City> filter(List<City> list){
        return list.stream().filter(a -> a.getTotal()>44).collect(Collectors.toList());
    }

}