【JAVA】List的去重的三种方式的效率比较

说明

list的去重一般是有三种方式：

1. Set方式
   利用Set的特性，但不能保证List的数据添加顺序。
2. LinkedHashSet
   继承HashSet并且实现了LinkedHashMap保存所有的数据，该方式是创建的双重链接列表，此列表定义了迭代顺序，能够记录list的数据添加顺序
3. list的for循环contains

效率对比

import org.apache.commons.lang.math.RandomUtils;

import java.io.UnsupportedEncodingException;
import java.util.*;

public class Demo3 {

    public static void main(String[] args) throws UnsupportedEncodingException, InterruptedException {
        List<String> list = new ArrayList<String>();

        for (int i = 0; i <200000 ; i++) {
                list.add("demo"+RandomUtils.nextInt(20000));

        }
        System.out.println("数据总量："+list.size());
        List<String> list1 = list.subList(0,list.size());
        List<String> list2 = list.subList(0,list.size());
        List<String> list3 = list.subList(0,list.size());

        long b1 = System.currentTimeMillis();
        way1(list1);
        long e1 = System.currentTimeMillis();
        System.out.println("方式一用时："+(e1-b1));
        long b2 = System.currentTimeMillis();
        way2(list2);
        long e2 = System.currentTimeMillis();
        System.out.println("方式二用时："+(e2-b2));

        long b3 = System.currentTimeMillis();
        way3(list3);
        long e3 = System.currentTimeMillis();
        System.out.println("方式三用时："+(e3-b3));

    }

    public static void way1(List<String> list){
        System.out.println("开始去重方式一，开始的数据大小："+list.size());
        Set<String> strings = new HashSet<String>();
        List<String> tmp = new ArrayList<String>();
        strings.addAll(list);
        tmp.addAll(strings);
        System.out.println("完成去重方式一，去重后的数据大小："+tmp.size());

    }

    public static void way2(List<String> list){
        System.out.println("开始去重方式二，开始的数据大小："+list.size());
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
        List<String> tmp = new ArrayList<String>();
        linkedHashSet.addAll(list);
        tmp.addAll(linkedHashSet);
        System.out.println("完成去重方式二，去重后的数据大小："+tmp.size());
    }

    public static void way3(List<String> list){
        System.out.println("开始去重方式三，开始的数据大小："+list.size());
        List<String> tmp = new ArrayList<String>();
        for (String s : list) {
            if (!tmp.contains(s)){
                tmp.add(s);
            }
        }
        System.out.println("完成去重方式三，去重后的数据大小："+tmp.size());
    }
}

输出结果：

数据总量：200000
开始去重方式一，开始的数据大小：200000
完成去重方式一，去重后的数据大小：19998
方式一用时：94
开始去重方式二，开始的数据大小：200000
完成去重方式二，去重后的数据大小：19998
方式二用时：62
开始去重方式三，开始的数据大小：200000
完成去重方式三，去重后的数据大小：19998
方式三用时：22319

Process finished with exit code 0

在数据量很多，数据重率不是很高的情况下，LinkedHashSet 》Set》contains循环

但是在数据量不多的情况下，速度都很快。没什么差别。