list集合删除重复元素的5种算法

由于list不能在遍历的时候进行删除，因为迭代器内部会维护一些索引位置相关的数据，要求在迭代过程中，容器不能发生结构性变化，否则这些索引位置就失效了。所谓结构性变化就是添加、插入和删除元素，只是修改元素内容不算结构性变化。

以下4种方法是本人亲测有效的方法。

import org.junit.Test;

import java.util.*;

/**
 * 测试List去重
 */
public class TestList {

    /**
     * 利用set集合的元素不可重复性,删除数组中的重复元素
     * 1、用数组作为参数，新建一个HashSet
     * 2、清除原数组
     * 3、调用list的addAll方法，将set集合添加到数组中
     */
    @Test
    public void m1() {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println("原List中的元素：");
        for (String s : list) {
            System.out.println(s);
        }

        Set<String> set = new HashSet<>(list);
        System.out.println("Set中的元素：");
        for (String s : set) {
            System.out.println(s);
        }

        list.clear();
        list.addAll(set);
        System.out.println("去重后List中的元素");
        for (String s : list) {
            System.out.println(s);
        }
    }

    /**
     * 1、新建数组
     * 2、将原数组元素逐个添加到新数组中，排除重复元素
     */
    @Test
    public void m2() {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println("原List中的元素：");
        for (String s : list) {
            System.out.println(s);
        }

        List<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (!list1.contains(s)) {
                list1.add(s);
            }
        }
        System.out.println("去重后List中的元素");
        for (String s : list1) {
            System.out.println(s);
        }
    }

    /**
     * 标记去重法（删除元素的时候必须按下标倒序删除）
     * 1、将原数组中重复元素标记
     * 2、将元素下标倒序排列
     * 3、遍历下标集合，调用list的remove()方法，删除对应索引的元素
     */
    @Test
    public void m3() {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("f");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("c");

        System.out.println("原List中的元素：");
        for (String s : list) {
            System.out.println(s);
        }

        List<Integer> list1 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.indexOf(list.get(i)) != i) {
                list1.add(i);
            }
        }
        System.out.println("List中的重复元素索引为：");
        for (Integer s : list1) {
            System.out.println(s);
        }

        list1.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        System.out.println("List中的重复元素索引倒序排列为：");
        for (Integer s : list1) {
            System.out.println(s);
        }

        for (int index : list1) {
            list.remove(index);
        }

        System.out.println("去重后的List中的元素：");
        for (String s : list) {
            System.out.println(s);
        }
    }

    /**
     * 利用list的内部实现的迭代器Iterator接口，删除重复元素
     * 1、调用list的iterator()，创建Iterator对象，同时定义一个计数器
     * 2、遍历iterator获取对象的值，同时计数器清零
     * 3、遍历list，判断list中元素是否和当前iterator中的值相同，相同则计数器加1
     * 4、判断计数器的值，如果
     */
    @Test
    public void m4() {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("c");
        list.add("b");
        list.add("f");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("c");
        System.out.println("原List中的元素：");
        for (String s : list) {
            System.out.println(s);
        }

        // 将数组排序
//        list.sort(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareTo(o2);
//            }
//        });

        //将数组倒序是希望保留第一次出现的各元素
        Collections.reverse(list);

        Iterator iterator = list.iterator();
        int count = 0;
        while (iterator.hasNext()) {
            //定义一个计数器
            count = 0;

            String str = (String) iterator.next();

            // 取出迭代器中的一个内容，循环一遍list中的内容
            for (int i = list.size() - 1; i > -1; i--) {
                // 如果有相同的，计数器count就加1
                if (str.equals(list.get(i))) {
                    count++;
                    if (count >= 2) {
                        iterator.remove();
                        break;
                    }
                }
            }
        }

        Collections.reverse(list);
        System.out.println("去重后List中的元素：");
        for (String s : list) {
            System.out.println(s);
        }
    }

    /**
     * 利用steam的中间操作distinct
     * 1、调用List的Stream()方法，获取一个顺序流
     * 2、调用Stream的distinct()方法，将重复数据过滤掉
     * 3、调用Stream的collect()方法，传递一个参数Collectors.toList()，将流转为list
     *      或者将流转为数组，然后再将数据转为List集合
     */
    @Test
    public void m5() {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("c");
        list.add("b");
        list.add("f");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("c");
        System.out.println("原List中的元素：");
        for (String s : list) {
            System.out.println(s);
        }

        /**
         * 1、调用List的Stream()方法，获取一个顺序流
         * 2、调用Stream的distinct()方法，将重复数据过滤掉
         * 3、调用Stream的collect()方法，传递一个参数Collectors.toList()，将流转为list
         */
//        List<String> afterList = list.stream().distinct().collect(Collectors.toList());

        /**
         * 1、调用List的Stream()方法，获取一个顺序流
         * 2、调用Stream的distinct()方法，将重复数据过滤掉
         * 3、将流转为数组，然后再将数据转为List集合
         */
        List<String> afterList = Arrays.asList(list.stream().distinct().toArray(String[]::new));
        System.out.println("去重后List中的元素：");
        for (String s : afterList) {
            System.out.println(s);
        }
    }
}