List去重比较

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.TreeSet;

/**
 * @author 马家立
 * @version 创建时间是：2019年8月16日上午9：35：11
 * @Description：TODO List去重比较
 */
public class listRemoveDuplicate {
    /**
     * @Title：removeDuplicateByHashSet
     * @author：马家立
     * @date：2019年9月18日
     * @Description：TODO 方式1：HashSet无序去重
     * @param <E>
     * @param list
     *            void
     */
    public static <E> void removeDuplicateByHashSet(List<E> list) {
        // 初始化HashSet对象
        HashSet<E> set = new HashSet<E>();
        List<E> result = new ArrayList<E>();
        for (E e : result) {
            if (set.add(e)) {
                result.add(e);
            }
        }
        // 把List集合所有元素清空
        list.clear();
        // 把HashSet对象添加至List集合
        list.addAll(result);
    }

    /**
     * @Title：removeDuplicateByLinkedHashSet
     * @author：马家立
     * @date：2019年9月18日 @Description：TODO 方式2：LinkedHashSet有序去重
     * @param <E>
     * @param list
     *            void
     */
    public static <E> void removeDuplicateByLinkedHashSet(List<E> list) {
        // 初始化LinkedHashSet对象，并把list对象元素赋值给LinkedHashSet对象
        LinkedHashSet<E> set = new LinkedHashSet<E>(list);
        // 把List集合所有元素清空
        list.clear();
        // 把LinkedHashSet对象添加至List集合
        list.addAll(set);
    }

    /**
     * @Title：removeDuplicateByTreeSet
     * @author：马家立
     * @date：2019年9月18日 @Description：TODO 方式3：TreeSet去重
     * @param <E>
     * @param list
     *            void
     */
    public static <E> void removeDuplicateByTreeSet(List<E> list) {
        // 初始化TreeSet对象，并把list对象元素赋值给TreeSet对象
        TreeSet<E> treeSet = new TreeSet<E>(list);
        // 把List集合所有元素清空
        list.clear();
        // 把TreeSet对象添加至List集合
        list.addAll(treeSet);
    }

    /**
     * @Title：removeDuplicateByEquals
     * @author：马家立
     * @date：2019年9月18日 @Description：TODO 方式4：双重for_iterate循环_equals_remove去重
     * @param <E>
     * @param list
     *            void
     */
    public static <E> void removeDuplicateByEquals(List<E> list) {
        for (int i = 0; i < list.size(); i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i).equals(list.get(j))) {
                    list.remove(j);
                }
            }
        }
    }

    /**
     * @Title：removeDuplicateByContains1
     * @author：马家立
     * @date：2019年9月18日
     * @Description：TODO 方式5：forEach方式循环_contains去重
     * @param <E>
     * @param list
     *            void
     */
    public static <E> void removeDuplicateByContains1(List<E> list) {
        List<E> result = new ArrayList<E>();
        for (E e : list) {
            if (!result.contains(e)) {
                result.add(e);
            }
        }
        // 把List集合所有元素清空
        list.clear();
        // 把所有对象添加至List集合
        list.addAll(result);
    }

    /**
     * @Title：removeDuplicateByContains2
     * @author：马家立
     * @date：2019年9月18日 @Description：TODO 方式6：list.stream()方式循环_contains去重
     * @param <E>
     * @param list
     *            void
     */
    public static <E> void removeDuplicateByContains2(List<E> list) {
        List<E> result = new ArrayList<E>(list.size());
        list.stream().forEach(p -> {
            if (!result.contains(p)) {
                result.add(p);
            }
        });
    }

    public static void main(String[] args) {
        // 声明List
        final List<String> list = new ArrayList<String>();
        // List添加数据
        for (int i = 0; i < 1000; i++) {
            if (0 == (i % 50)) {
                list.add("我是皮卡兵");
            } else if (0 == (i % 25)) {
                list.add("我是皮卡乒");
            } else if (0 == (i % 10)) {
                list.add("我是皮卡乓");
            } else if (0 == (i % 5)) {
                list.add("我是皮卡皮");
            } else {
                list.add("我是第-" + i + "个皮卡丘");
            }
            list.add("哇咔哇,电光一闪");
        }
        List<String> list1 = list;
        List<String> list2 = list;
        List<String> list3 = list;
        List<String> list4 = list;
        List<String> list5 = list;
        List<String> list6 = list;
        // 循环次数
        int forTimes = 100;
        // 纳秒级别
        long time = System.nanoTime();

        // 方式一
        for (int i = 0; i < forTimes; i++) {
            removeDuplicateByHashSet(list1);
        }
        long time1 = System.nanoTime();
        System.out.println("方式1：HashSet无序去重的时间是：\t" + ((time1 - time)) + "纳秒");

        // 方式二
        for (int i = 0; i < forTimes; i++) {
            removeDuplicateByLinkedHashSet(list2);
        }
        long time2 = System.nanoTime();
        System.out.println("方式2：LinkedHashSet有序去重的时间是：\t" + ((time2 - time1)) + "纳秒");

        // 方式三
        for (int i = 0; i < forTimes; i++) {
            removeDuplicateByTreeSet(list3);
        }
        long time3 = System.nanoTime();
        System.out.println("方式3：TreeSet去重的时间是：\t" + ((time3 - time2)) + "纳秒");

        // 方式四
        for (int i = 0; i < forTimes; i++) {
            removeDuplicateByEquals(list4);
        }
        long time4 = System.nanoTime();
        System.out.println("方式4：双重for_iterate循环_equals_remove去重的时间是：\t" + ((time4 - time3)) + "纳秒");

        // 方式五
        for (int i = 0; i < forTimes; i++) {
            removeDuplicateByContains1(list5);
        }
        long time5 = System.nanoTime();
        System.out.println("方式5：forEach方式循环_contains去重的时间是：\t" + ((time5 - time4)) + "纳秒");

        // 方式六
        for (int i = 0; i < forTimes; i++) {
            removeDuplicateByContains2(list6);
        }
        long time6 = System.nanoTime();
        System.out.println("方式6：list.stream()方式循环_contains去重的时间是：\t" + ((time6 - time5)) + "纳秒");

    }
}

结果:

方式1：HashSet无序去重的时间是：    330200纳秒
方式2：LinkedHashSet有序去重的时间是：    660500纳秒
方式3：TreeSet去重的时间是：    758700纳秒
方式4：双重for_iterate循环_equals_remove去重的时间是：    37300纳秒
方式5：forEach方式循环_contains去重的时间是：    146900纳秒
方式6：list.stream()方式循环_contains去重的时间是：    41510900纳秒