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納秒