List 去重的 6 种方法

方法1:contains判断去重(有序)

要进行数据去重,我们首先想到的是新建一个集合,然后循环原来的集合,每次循环判断原集合中的循环项,如果当前循环的数据,没有在新集合中存在就插入,已经存在了就舍弃,这样当循环执行完,我们就得到了一个没有重复元素的集合了,实现代码如下:

public class ListController {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(5);
            add(4);
            add(5);
            add(3);
            add(7);
            add(8);
            add(9);
            add(8);
            add(5);
            add(4);
            add(5);
            add(6);
        }};
        System.out.println("原集合:" + list);
        ListMethod(list);
    }

    /**
     * 使用迭代器去重
     *
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        // 新集合
        List<Integer> newList = new ArrayList<>(list.size());
        list.forEach(i -> {
            if (!newList.contains(i)) { 
                // 如果新集合中不存在则插入
                newList.add(i);
            }
        });
        System.out.println("去重集合:" + newList);
    }
}

以上程序执行的结果,如下所示:
在这里插入图片描述

此方法的优点的:理解起来比较简单,并且最终得到的集合也是有序的,这里的有序指的是新集合的排列顺序和原集合的顺序是一致的;但缺点是实现代码有点多,不够简洁优雅。

方法2:迭代器去重(无序)

自定义 List 去重,除了上面的新建集合之外,我们也可以使用迭代器循环判断每一项数据,如果当前循环的数据,在集合中存在两份或两份以上,就将当前的元素删除掉,这样循环完之后,也可以得到一个没有重复数据的集合,实现代码如下:

public class ListController {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(5);
            add(4);
            add(5);
            add(3);
            add(7);
            add(8);
            add(9);
            add(8);
            add(5);
            add(4);
            add(5);
            add(6);
        }};
        System.out.println("原集合:" + list);
        ListMethod(list);
    }

    /**
     * 使用迭代器去重
     *
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
       Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            // 获取循环的值
            Integer item = iterator.next();
            // 如果存在两个相同的值
            if (list.indexOf(item) != list.lastIndexOf(item)) {
                // 移除最后那个相同的值
                iterator.remove();
            }
        }
        System.out.println("去重集合:" + list);
    }
}

以上程序执行的结果,如下所示:
在这里插入图片描述
此方法的实现比上一种方法的实现代码要少一些,并且不需要新建集合,但此方法得到的新集合是无序的,也就是新集合的排列顺序和原集合不一致,因此也不是最优的解决方案。

方法3:HashSet去重(无序)

我们知道 HashSet 天生具备“去重”的特性,那我们只需要将 List 集合转换成 HashSet 集合就可以了,实现代码如下:

public class ListController {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(5);
            add(4);
            add(5);
            add(3);
            add(7);
            add(8);
            add(9);
            add(8);
            add(5);
            add(4);
            add(5);
            add(6);
        }};
        System.out.println("原集合:" + list);
        ListMethod(list);
    }

    /**
     * 使用 HashSet 去重
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        HashSet<Integer> set = new HashSet<>(list);
        System.out.println("去重集合:" + set);
    }
}

以上程序执行的结果,如下所示:
在这里插入图片描述
此方法的实现代码较为简洁,但缺点是 HashSet 会自动排序,这样新集合的数据排序就和原集合不一致了,如果对集合的顺序有要求,那么此方法也不能满足当前需求。

方法4:LinkedHashSet去重(有序)

既然 HashSet 会自动排序不能满足需求,那就使用 LinkedHashSet,它既能去重又能保证集合的顺序,实现代码如下:

public class ListController {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(5);
            add(4);
            add(5);
            add(3);
            add(7);
            add(8);
            add(9);
            add(8);
            add(5);
            add(4);
            add(5);
            add(6);
        }};
        System.out.println("原集合:" + list);
        ListMethod(list);
    }

    /**
     * 使用 LinkedHashSet 去重
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
        System.out.println("去重集合:" + set);
    }
}

以上程序执行的结果,如下所示:
在这里插入图片描述
从上述代码和执行结果可以看出,LinkedHashSet 是到目前为止,实现比较简单,且最终生成的新集合与原集合顺序保持一致的实现方法,是我们可以考虑使用的一种去重方法。

方法5:TreeSet去重(无序)

除了以上的 Set 集合之外,我们还可以使用 TreeSet 集合来实现去重功能,实现代码如下:

public class ListController {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(5);
            add(4);
            add(5);
            add(3);
            add(7);
            add(8);
            add(9);
            add(8);
            add(5);
            add(4);
            add(5);
            add(6);
        }};
        System.out.println("原集合:" + list);
        ListMethod(list);
    }

    /**
     * 使用 TreeSet 去重(无序)
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        TreeSet<Integer> set = new TreeSet<>(list);
        System.out.println("去重集合:" + set);
    }
}

以上程序执行的结果,如下所示:
在这里插入图片描述
比较遗憾的是,TreeSet 虽然实现起来也比较简单,但它有着和 HashSet 一样的问题,会自动排序,因此也不能满足我们的需求。

方法6:Stream去重(有序)

JDK 8 为我们带来了一个非常实用的方法 Stream,使用它可以实现很多功能,比如下面的去重功能:

public class ListController {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(5);
            add(4);
            add(5);
            add(3);
            add(7);
            add(8);
            add(9);
            add(8);
            add(5);
            add(4);
            add(5);
            add(6);
        }};
        System.out.println("原集合:" + list);
        ListMethod(list);
    }

    /**
     * 使用 Stream 去重
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重集合:" + list);
    }
}

以上程序执行的结果,如下所示:
在这里插入图片描述
Stream 实现去重功能和其他方法不同的是,它不用新创建集合,使用自身接收一个去重的结果就可以了,并且实现代码也很简洁,并且去重后的集合顺序也和原集合的顺序保持一致,是我们最优先考虑的去重方法。

补充: 在我们常见的集合类型中,有序的有ArrayList,LinkedList,LinkedHashSet,LinkedHashMap等,无序的有HashSet,HashMap,HashTable,TreeSet,TreeMap等,而同时TressSet和TressMap又是可排序的。

  • 5
    点赞
  • 36
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
评论 11
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值