List去除重复数据的几种方式和性能比较

以下介绍5种去除Java中ArrayList中的重复数据

1. 使用LinkedHashSet删除arrayList中的重复数据

LinkHashSet是在一个ArrarList删除重复数据的最佳方法.LinkHaseSet在内部完成两件事

• 删除重复数据
• 保持添加到其中的数据的顺序

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;

public class Temp {
    public static void main(String[] args) {
        List<Integer> numbersList=new ArrayList<>(Arrays.asList(1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8));
        System.out.println(numbersList);
        LinkedHashSet<Integer> hashSet=new LinkedHashSet<>(numbersList);
        System.out.println(hashSet);
    }
}

输出效果

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

2.使用Java8新特性stream进行List去重

要从arrayList中删除重复项,我们也可以使用java 8 stream api ,使用stream中distinct()方法返回一个由不同数据组成的流,通过对象的equals() 方法进行比较
收集所有区域数据List使用Collectors.toList()
Java程序,用于在不是用Set的情况下重java中的arrayList中删除重复项

List<Integer> numbersList=new ArrayList<>(Arrays.asList(1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8));
        System.out.println(numbersList);
        List<Integer> listWithoutDuplicates = numbersList.stream().distinct()
        .collect(Collectors.toList());
        System.out.println(listWithoutDuplicates);

输出效果

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

3.利用HashSet不能添加重复数据的特性,由于HaseSet不能保证添加的顺序,所以只能作为判读条件保证顺序

public static void removeDuplicate(List<Integer> list) {
        HashSet<Integer> set = new HashSet<>(list.size());
        List<Integer> result = new ArrayList<>(list.size());
        for (Integer item : list) {
            if (set.add(item)) {
                result.add(item);
            }
        }
        list.clear();
        list.addAll(result);
    }

输出效果

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

4.利用List的contains方法循环遍历,重写排序,只添加一次数据,避免重复

 public static void removeDuplicate(List<Integer> list) {
        List<Integer> result = new ArrayList<>(list.size());
        for (Integer item : list) {
            if (!result.contains(item)) {
                result.add(item);
            }
        }
        list.clear();
        list.addAll(result);
    }

输出效果

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

5.双重for循环去重

 for (int i = 0; i < numbersList.size(); i++) {
            for (int j = i + 1; j < numbersList.size(); j++) {
                if (numbersList.get(i) == numbersList.get(j)) {
                    numbersList.remove(numbersList.get(i));
                }
            }
        }

输出结果

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

6.使用TreeSet实现List去重(有序)

 public static List removeDuplicationByTreeSet(List<Integer> list) {
        TreeSet set = new TreeSet<>(list);
        // 把list集合所有元素清空
        list.clear();
        list.addAll(set);
        return list;
    }

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

7.使用HashSet实现List去重(无序)

 /**使用HashSet实现List去重(无序)
     *
     * @param list
     * */
    public static List removeDuplicationByHashSet(List<Integer> list) {
        HashSet set = new HashSet(list);
        //把List集合所有元素清空
        list.clear();
        //把HashSet对象添加至List集合
        list.addAll(set);
        return list;
    }

性能比较

package com.sth;

import java.util.*;
import java.util.stream.Collectors;

public class Temp {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        List<Integer> list5 = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 100000; i++) {
            int value = random.nextInt(500);
            list1.add(value);
            list2.add(value);
            list3.add(value);
            list4.add(value);
            list5.add(value);
        }
        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        removeDuplicationByHashSet(list1);
        endTime = System.currentTimeMillis();
        System.out.println("使用HashSet实现List去重时间:" + (endTime - startTime) + "毫秒");
        startTime = System.currentTimeMillis();
        removeDuplicationByTreeSet(list2);
        endTime = System.currentTimeMillis();
        System.out.println("使用TreeSet实现List去重时间:" + (endTime - startTime) + "毫秒");
        startTime = System.currentTimeMillis();
        removeDuplicationByStream(list3);
        endTime = System.currentTimeMillis();
        System.out.println("使用java8新特性stream实现List去重:" + (endTime - startTime) + "毫秒");
        startTime = System.currentTimeMillis();
        removeDuplicationBy2For(list4);
        endTime = System.currentTimeMillis();
        System.out.println("使用两个for循环实现List去重:" + (endTime - startTime) + "毫秒");
        startTime = System.currentTimeMillis();
        removeDuplicationByContains(list5);
        endTime = System.currentTimeMillis();
        System.out.println("使用List集合contains方法循环遍历:" + (endTime - startTime) + "毫秒");

    }

    public static List removeDuplicationByTreeSet(List<Integer> list) {
        TreeSet set = new TreeSet<>(list);
        // 把list集合所有元素清空
        list.clear();
        list.addAll(set);
        return list;
    }

    /**
     * 使用HashSet实现List去重(无序)
     *
     * @param list
     */
    public static List removeDuplicationByHashSet(List<Integer> list) {
        HashSet set = new HashSet(list);
        //把List集合所有元素清空
        list.clear();
        //把HashSet对象添加至List集合
        list.addAll(set);
        return list;
    }

    /**
     * 使用java8新特性stream实现List去重(有序)
     *
     * @param list
     */
    public static List removeDuplicationByStream(List<Integer> list) {
        List newList = list.stream().distinct().collect(Collectors.toList());
        return newList;
    }

    /**
     * 使用两个for循环实现List去重(有序)
     *
     * @param list
     */
    public static List removeDuplicationBy2For(List<Integer> 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);
                }
            }
        }
        return list;
    }

    /**
     * 使用List集合contains方法循环遍历(有序)
     *
     * @param list
     */
    public static List removeDuplicationByContains(List<Integer> list) {
        List<Integer> newList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            boolean isContains = newList.contains(list.get(i));
            if (!isContains) {
                newList.add(list.get(i));
            }
        }
        list.clear();
        list.addAll(newList);
        return list;
    }
}

输出

随机数字100内

使用HashSet实现List去重时间:1毫秒
使用TreeSet实现List去重时间:1毫秒
使用java8新特性stream实现List去重:74毫秒
使用两个for循环实现List去重:2毫秒
使用List集合contains方法循环遍历:0毫秒

随机数字1000内

使用HashSet实现List去重时间:3毫秒
使用TreeSet实现List去重时间:3毫秒
使用java8新特性stream实现List去重:76毫秒
使用两个for循环实现List去重:18毫秒
使用List集合contains方法循环遍历:4毫秒

随机数字10000内

使用HashSet实现List去重时间:6毫秒
使用TreeSet实现List去重时间:8毫秒
使用java8新特性stream实现List去重:77毫秒
使用两个for循环实现List去重:38毫秒
使用List集合contains方法循环遍历:14毫秒

随机数字100000内

使用HashSet实现List去重时间:22毫秒
使用TreeSet实现List去重时间:28毫秒
使用java8新特性stream实现List去重:86毫秒
使用两个for循环实现List去重:711毫秒
使用List集合contains方法循环遍历:51毫秒