List集合去重的好方法

方法一：利用set （里面有三个集合，HashSet不排序，TreeSet 按照自然顺序排）

HashSet底层用的是哈希表，它把对象根据其哈希值存放到对应的区域里，两个在不同区域的对象会被认为不相同的，且不同步允许集合元素为null（只允许一个null），但是TreeSet底层是二叉树，数据自动排序，不允许null。

        List<String> list  =   new  ArrayList<>();
        list.add("e23");
        list.add("c23");
        list.add("f23");
        list.add("e23");
        list.add("f23");

        Set set = new  HashSet();
        List newList = new  ArrayList();
        set.addAll(list);
        newList.addAll(set);

        System.out.println( "去重后的集合： " + newList.toString());
        //去重后的集合： [c23, f23, e23] 不排序
        //使用了TreeSet，按自然排序
        去重后的集合： [c23, e23, f23] 

方法二：但是想要按照怎么存的排序，用set作为筛选条件

        List<String> list  =   new  ArrayList<>();
        list.add("e23");
        list.add("c23");
        list.add("f23");
        list.add("e23");
        list.add("f23");

        List newList = new  ArrayList();
        Set set = new TreeSet();
        for (String s : list) {
            if (set.add(s)){
                newList.add(s);
            }
        }

        System.out.println( "去重后的集合： " + newList.toString());
        //去重后的集合： [e23, c23, f23]

 

方法三：利用List.contains(one)（里面有两个集合）

LinkedHashSet会根据HashCode决定元素的位置，在同时也会使用链表维护元素的次序，就是存的是怎么样取出去就是什么样。访问的时候快于HashSet，但是在插入的时候缺输一筹。

         List<Object> list  =   new  ArrayList<>();
        list.add("e23");
        list.add("c23");
        list.add("f23");
        list.add("e23");
        list.add("a23");
        list.add("f23");

        List<String> newList = new ArrayList<>();
        for (String one : list) {
            if (! newList.contains(one)){
                  newList.add(one);
            }
        }

        System.out.println( "去重后的集合： " + newList.toString());
        //去重后的集合： [e23, c23, f23, a23]
       

        List newList = new  ArrayList();
        Set set = new LinkedHashSet();
        set.addAll(list);
        newList.addAll(set);

        System.out.println( "去重后的集合： " + newList.toString());
        //去重后的集合： [e23, c23, f23, a23]

方法四：Java 8 的新方法（流处理）

 
        List<Object> list  =   new  ArrayList<>();
        list.add("e23");
        list.add("c23");
        list.add("f23");
        list.add("e23");
        list.add("f23");

        list =list.stream().distinct().collect(Collectors.toList());
        //[e23, c23, f23]


        stream()操作将集合转换成一个流；
        distinct()去重后得到一个新的流，去重使用equals方法做相等比较，
        该方法不要求先对流进行排序，可以直接乱序去重（而且其算法也不是先对流进行排序的）；
        filter()执行我们自定义的筛选处理，这里是通过lambda表达式筛选出所有偶数；
        最后通过collect()对结果进行封装处理，
        并通过Collectors.toList()指定其封装成为一个List集合返回。

  还可以对对象集合做处理哦！但是要让你的maven支持1.8才行。

        Ratio p1 = new Ratio(1,11, 111);
        Ratio p2 = new Ratio(2,22, 222);
        Ratio p3 = new Ratio(3,33, 333);
        Ratio p4 = new Ratio(4,44, 444);
        Ratio p5 = new Ratio(5,55, 555);


        List<Ratio> persons = Arrays.asList(p1, p2, p3, p4, p5, p5, p1, p2, p2);

        List<Ratio> personList = new ArrayList<>();
        // 去重
        persons.stream().forEach(
                p -> {
                    if (!personList.contains(p)) {
                        personList.add(p);
                    }
                }
        );
        System.out.println(personList);
       

            在pom.xml中增加一个插件，使得maven支持jdk1.8语法：
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>

如果要让源集合改变的话，要先将集合清空（list.clear()），再将去重后的加入。