java list去重方式，以及效率问题

之前面试被问到关于java如何去重的问题，当时没怎么留意，今天刚好项目中用到了，所以记录一下。

实体类：

/**
 * 用户类
 */
class User{
private String username;
private String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

测试类：

 public static void main(String[] args) {

        ArrayList<User> arrayList = new ArrayList<>();
        long currentTimeMillis = System.currentTimeMillis();
        int f = 100000;
        for(int i = 0; i < f; i++){
            arrayList.add(new User(""+i, "7878"));
        }
        Iterator<User> iterator = arrayList.iterator();
        Set<String> hashSet = new HashSet<>();
        LinkedList<User> newList = new LinkedList<>();

        //  第一种：set集合去重，不改变原有的顺序,根据username唯一标识去重
        while (iterator.hasNext()){
            User u = iterator.next();
            // 根据set不能存放相同值的特性
            if(!StringUtils.isEmpty(u.getUsername())){
                if (hashSet.add(u.getUsername())){
                    //  将其重新放入在LinkedList中
                    newList.add(u);
                }
            }
        }
        long currentTimeMillis1_1 = System.currentTimeMillis();
        System.out.println("第一种set集合去重，不改变原有的顺序:"+(currentTimeMillis1_1 - currentTimeMillis));

        // 第二种：遍历后判断赋给另一个list集合，利用List的contains方法循环遍历
        List<User> listNew=new ArrayList<>();
        for (User str:arrayList) {
            if(!listNew.contains(str)){
                listNew.add(str);
            }
        }
        long currentTimeMillis1_2 = System.currentTimeMillis();
        System.out.println("第二种：遍历后判断赋给另一个list集合，利用List的contains方法循环遍历:"+(currentTimeMillis1_2 - currentTimeMillis1_1));

        //  第三种：set去重
        Set set = new HashSet();
        List<String> listNew2=new ArrayList<>();
        set.addAll(arrayList);
        listNew2.addAll(set);

        long currentTimeMillis1_3 = System.currentTimeMillis();
        System.out.println(" 第三种：set去重"+(currentTimeMillis1_3 - currentTimeMillis1_2));

        //  第四种：set去重（缩减为一行）
        List<String> listNew3=new ArrayList<>(new HashSet(arrayList));

        long currentTimeMillis1_4 = System.currentTimeMillis();
        System.out.println("第四种：set去重（缩减为一行）"+(currentTimeMillis1_4 - currentTimeMillis1_3));

        //  第五种：去重并按自然顺序排序
       /* TreeSet treeSet = new TreeSet(arrayList);
        List tempList = new ArrayList();
        tempList.addAll(treeSet);
        //List<User> listNew4=new ArrayList<>(new TreeSet<User>(arrayList));

        long currentTimeMillis1_5 = System.currentTimeMillis();
        System.out.println(currentTimeMillis1_5 - currentTimeMillis1_4);*/

        //  第六种：双重for循环,去重
        for(int i = 0 ; i < arrayList.size() - 1; i ++){
            for(int j = arrayList.size() - 1; j > i; j --){
                if(arrayList.get(j).equals(arrayList.get(i))){
                    arrayList.remove(j);
                }
            }
        }
        long currentTimeMillis1_6 = System.currentTimeMillis();
        System.out.println("第六种：双重for循环,去重"+(currentTimeMillis1_6 - currentTimeMillis1_4));

        //  第七种：利用HashSet不能添加重复数据的特性 由于HashSet不能保证添加顺序，所以只能作为判断条件
        HashSet<User> set2 = new HashSet<>(arrayList.size());
        List<User> result = new ArrayList<>(arrayList.size());
        for (User str3 : arrayList) {
            if (set2.add(str3)) {
                result.add(str3);
            }
        }
        arrayList.clear();
        arrayList.addAll(result);
        long currentTimeMillis1_7 = System.currentTimeMillis();
        System.out.println("第七种：利用HashSet不能添加重复数据的特性 由于HashSet不能保证添加顺序，所以只能作为判断条件"+(currentTimeMillis1_7 - currentTimeMillis1_6));

        //   第八种：利用LinkedHashSet不能添加重复数据并能保证添加顺序的特性
        LinkedHashSet<User> set5 = new LinkedHashSet<>(arrayList.size());
        set5.addAll(arrayList);
        arrayList.clear();
        arrayList.addAll(set5);

        long currentTimeMillis1_8 = System.currentTimeMillis();
        System.out.println("第八种：利用LinkedHashSet不能添加重复数据并能保证添加顺序的特性"+(currentTimeMillis1_8 - currentTimeMillis1_7));

    }

控制台输出：

提示：在数据量大的情况下，最好不要使用第二种和第六种，速度太慢了

至于效率问题大家自己根据实际情况选择吧。