java 集合合并 去重 java中集合去重

List集合去重的方式

• 方式一：利用TreeSet集合特性排序+去重（有序）
• 方式二：利用HashSet的特性去重（无序）
• 方式三：利用LinkedHashSet去重（有序）
• 方式四：迭代器去重（无序）
• 方式五：使用list.contains()对全部元素进行判断（有序）
• 方式六：使用Java8特性（Stream去重）去重（有序）
• 方式七：使用list自身方法remove()–>不推荐
• 总结：

方式一：利用TreeSet集合特性排序+去重（有序）

TreeSet可以将字符串类型的数据按照字典顺序进行排序，首字母相同则看第二位

public static void main(String[] args) {
        // 一.利用TreeSet集合特性排序+去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        list.forEach(item->{
            System.out.println("去重前的集合："+item);
        });
        System.out.println("-----------------");


        List<String> result=new LinkedList<>(new TreeSet<>(list));
        System.out.println("去重后的集合："+result);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

方式二：利用HashSet的特性去重（无序）

由于Set的特性是无序且不可重复，我们利用这个特性进行两步操作：

1. 把list放入set中
2. 把set还回list里

public static void main(String[] args) {
        // 利用set的特性去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        Iterator iter=list.iterator();
        while(iter.hasNext()){
            System.out.println("去重前的集合元素："+iter.next());
        }
        System.out.println("-----------------");


        // result集合存放最终的结果
        List<String> result=new LinkedList<>();

        if (list.size()>0&&list!=null){
            // 新建HashSet集合，将list放入
            Set<String> set=new HashSet<>();
            set.addAll(list);

            // 将去重后的set集合放入结果集合result中
            result.addAll(set);
        }
        System.out.println("去重后的集合："+result);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

方式三：利用LinkedHashSet去重（有序）

LinkedHashSet虽然可以去重，但是根据它的特性，它不能对数据进行排序，只能维持原来插入时的秩序

public static void main(String[] args) {
        // 利用LinkedHashSet集合去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        for (int i=0;i<list.size();i++){
            System.out.println("去重前的集合元素："+list.get(i));
        }
        System.out.println("-----------------");


        List<String> result=new LinkedList<>(new LinkedHashSet<String>(list));
        System.out.println("去重后的集合："+result);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

方式四：迭代器去重（无序）

此方法得到的新集合是无序的，也就是新集合的排列顺序和原集合不一致

public static void main(String[] args) {
        // 二.迭代器去重（无序）

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        for (String item:list){
            System.out.println("去重前的集合元素："+item);
        }
        System.out.println("-----------------");


        Iterator<String> iterator=list.iterator();
        while (iterator.hasNext()){
            String next= iterator.next();
            // 如果存在两个相同的值
            if (list.indexOf(next)!=list.lastIndexOf(next)){
                //移除最后那个相同的值
                iterator.remove();
            }
        }
        System.out.println("去重后的集合："+list);
    }

去重前的集合元素：22
去重前的集合元素：11
去重前的集合元素：33
去重前的集合元素：66
去重前的集合元素：22

方式五：使用list.contains()对全部元素进行判断（有序）

• String类型会判断字符串里是否有相同的部分
• List里则会判断是否有相同的元素
• 我们可以用list.contains()的方法进行判断，然后将其添加到新的list当中，元素的顺序不发生改变

public static void main(String[] args) {
        // 使用list.contains()对全部元素进行判断


        System.out.println("----------");
        System.out.println("探究contains()方法");
        String s1="aaa";
        String s2="aa";
        System.out.println(s1.contains(s2));

        List<String> list0=new LinkedList<>();
        list0.add("aaa");
        System.out.println(list0.contains("aa"));
        System.out.println("----------");



        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        System.out.println("去重前的集合:"+list);
        System.out.println("-----------------");


        List<String> result=new LinkedList<>();
        for (String str:list){
            if (!result.contains(str)){
                result.add(str);
            }
        }
        System.out.println("去重后的集合："+result);
    }

探究contains()方法
true
false

去重前的集合:[22, 11, 33, 66, 22]

方式六：使用Java8特性（Stream去重）去重（有序）

把list集合->Stream流，然后对流用distinct()去重，再用collect()收集

public static void main(String[] args) {
        // 使用Java8特性去重

        List<String> list=new LinkedList<>();
        list.add("22");
        list.add("11");
        list.add("33");
        list.add("66");
        list.add("22");
        System.out.println("去重前的集合:"+list);
        System.out.println("-----------------");


        List<String> result=new LinkedList<>();
        result=list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后的集合："+result);
    }

去重前的集合:[22, 11, 33, 66, 22]

方式七：使用list自身方法remove()–>不推荐

• 如果你的list里存的比较复杂，是一个List<Map<String,Object>>格式的情况，最无奈之举就是这种方法
• 主要操作是将同一个list用两层for循环配合.equals()方法，有相同的就用remove()方法剔除掉，然后得到一个没有重复数据的list

public static List<Map<String,Object>> distinct(List<Map<String,Object>> list){
        if (list!=null && list.size()>0){
            for (int i=0;i<list.size();i++){
                for (int j=list.size()-1;j>i;j--){
                    // 这里是对象的比较，如果去重条件不一样，修改这里即可
                    if (list.get(j).equals(list.get(i))){
                        list.remove(j);
                    }
                }
            }
        }
        return list;
    }

总结：

介绍集合去重的方法中实现最简洁，且去重之后的顺序能和原集合保持一致的实现方法，只有两种：LinkedHashSet 去重和 Stream 去重，其中后一种去重方法无需借助新集合，是我们优先考虑的去重方法