ArrayList:用Set代替contains

博客讨论了ArrayList去重问题,介绍两种去重方法:一是生成新ArrayList添加前检查是否包含,二是利用HashSet再返回ArrayList。通过代码测试对比两种方法效率,指出当ArrayList大小超100时差异明显,还提及直接删除重复元素方法效率低。

在前面的一篇讨论中已经指出了ArrayList的contains方法也是效率比较低的,应该尽量避免使用它!这里有一个很实际的问题,就是已经有一个ArrayList,我要除去其中相同的元素,也就是希望得到一个不存在重复元素的List!

这里同样使用两种方法:
1.生成一个新的ArrayList,添加之前看是否包含。
2.直接利用HashSet(HashMap的一个视图),然后返回一个ArrayList。

public class Test {
  private static List testContains(List l) {
  List list = new ArrayList(100);
  for (int i = 0; i < l.size(); i++) {
    Object o = l.get(i);
    if (!list.contains(o)) {
      list.add(o);
    }
  }
  return list;
}

private static List testSet(List l) {
  return new ArrayList(new HashSet(l));
}

public static void test(int total, int cnt) {
  long t1, t2;
  List l = new ArrayList();
  for (int i = 0; i < cnt; i++) {
    l.add(new Integer(i));
  }
  t1 = System.currentTimeMillis();
  for (int i = 0; i < total / cnt; i++) {
    testContains(l);
  }
  t2 = System.currentTimeMillis();
  long a = t2 - t1;

  t1 = System.currentTimeMillis();
  for (int i = 0; i < total / cnt; i++) {
    testSet(l);
  } 
  t2 = System.currentTimeMillis();
  long b = t2 - t1;
  System.out.println("List Size:" + cnt);
  System.out.println("using Contains:" + a + "ms");
  System.out.println("using Set:" + b + "ms");
  System.out.println("Contains VS Set:" + (double) a / b + ":1");
}

public static void main(String[] args) {
  int total = 100 * 1000;
  int cnt = 1;

  while (cnt < total) {
    test(total, cnt);
    cnt *= 10;
  }

}

看一下输出结果:

List Size:1
using Contains:94ms
using Set:203ms
Contains VS Set:0.4630541871921182:1
List Size:10
using Contains:47ms
using Set:47ms
Contains VS Set:1.0:1
List Size:100
using Contains:172ms
using Set:47ms
Contains VS Set:3.6595744680851063:1
List Size:1000
using Contains:1625ms
using Set:46ms
Contains VS Set:35.32608695652174:1
List Size:10000
using Contains:16047ms
using Set:94ms
Contains VS Set:170.7127659574468:1

当ArrayList的大小超过100,差别就比较明显,不知道有没有想过用删除的方法,直接在列表中删除重复的元素!
for(int i=0;i<l.size();i++){
  if (indexOf(l.get(i))!=lastIndexOf(l.get(i))){
    l.remove(i);
  }
}
这样确实也可行呀,能想到这个方法还真不容易呢!除非你嫌你的CPU太快,否则根本不用考虑。这里同时调用了三个效率低下的方法:indexOf,lastIndexOf,remove。

在 Java 中,`List<Integer>` 和 `Set<Integer>` 是两种不同类型的集合,虽然它们都可以存储多个 `Integer` 元素,但由于其内部特性和设计目的不同,`List<Integer>` 通常不能完全替代 `Set<Integer>`。 ### 1. `List<Integer>` 和 `Set<Integer>` 的主要区别 - **有序性**:`List<Integer>` 是一个有序集合,其元素的存取顺序是固定的,可以通过索引访问元素。而 `Set<Integer>` 是无序集合(某些实现类如 `LinkedHashSet` 可以保持插入顺序),不支持索引访问。 - **重复性**:`List<Integer>` 允许元素重复,而 `Set<Integer>` 不允许重复的元素存在。如果尝试向 `Set<Integer>` 添加重复元素,该操作会返回 `false` 并且不会添加新元素。 - **访问方式**:由于 `List<Integer>` 支持索引,因此可以通过索引快速访问或修改特定位置的元素。而 `Set<Integer>` 不支持索引,只能通过迭代器或增强型 `for` 循环遍历元素。 ### 2. `List<Integer>` 是否可以替代 `Set<Integer>` - **元素唯一性需求**:如果需求中要求集合中的元素必须唯一,那么 `List<Integer>` 无法直接替代 `Set<Integer>`。此时,必须通过额外的逻辑判断来确保元素唯一性,例如每次添加元素时都检查是否已存在该元素。 - **顺序控制需求**:如果需要集合按照特定顺序存储元素(如插入顺序),可以使用 `ArrayList<Integer>` 或 `LinkedList<Integer>` 来模拟 `Set` 的行为,但需要手动处理重复性问题。 - **性能需求**:对于频繁的查找和去重操作,`Set<Integer>` 的实现类(如 `HashSet<Integer>`)通常具有更高的性能,其查找和插入的时间复杂度接近 O(1)。而 `List<Integer>` 的去重操作需要遍历整个列表,时间复杂度为 O(n),效率较低 [^2]。 ### 3. 使用 `List<Integer>` 模拟 `Set<Integer>` 的示例 如果需要使用 `List<Integer>` 来模拟 `Set<Integer>` 的行为(如确保元素唯一性),可以通过手动检查来实现: ```java List<Integer> list = new ArrayList<>(); public void addUnique(Integer value) { if (!list.contains(value)) { list.add(value); } } ``` 上述代码通过 `contains()` 方法检查元素是否已经存在,从而实现了类似 `Set<Integer>` 的去重功能。然而,这种实现方式在性能上通常不如直接使用 `Set<Integer>` 高效。 ### 4. 总结 虽然 `List<Integer>` 可以通过额外的逻辑来实现部分 `Set<Integer>` 的功能,但由于两者在设计目标和特性上的差异,`List<Integer>` 通常不能完全替代 `Set<Integer>`。在需要确保元素唯一性的场景中,推荐使用 `Set<Integer>` 及其相关实现类。 ---
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值