Java中对List去重 Stream去重的解决方法

时间:2022-09-06 07:38:38

问题

当下互联网技术成熟,越来越多的趋向去中心化、分布式、流计算,使得很多以前在数据库侧做的事情放到了java端。今天有人问道,如果数据库字段没有索引,那么应该如何根据该字段去重?大家都一致认为用java来做,但怎么做呢?

解答

忽然想起以前写过list去重的文章,找出来一看。做法就是将list中对象的hashcode和equals方法重写,然后丢到hashset里,然后取出来。这是最初刚学java的时候像被字典一样背写出来的答案。就比如面试,面过号称做了3年java的人,问set和hashmap的区别可以背出来,问如何实现就不知道了。也就是说,初学者只背特性。但真正在项目中使用的时候你需要确保一下是不是真的这样。因为背书没用,只能相信结果。你需要知道hashset如何帮我做到去重了。换个思路,不用hashset可以去重吗?最简单,最直接的办法不就是每次都拿着和历史数据比较,都不相同则插入队尾。而hashset只是加速了这个过程而已。

首先,给出我们要排序的对象user

?
1
2
3
4
5
6
7
8
9
10
11
12
@data
@builder
@allargsconstructor
public class user {
 private integer id;
 private string name;
}
list<user> users = lists.newarraylist(
    new user(1, "a"),
    new user(1, "b"),
    new user(2, "b"),
    new user(1, "a"));

目标是取出id不重复的user,为了防止扯皮,给个规则,只要任意取出id唯一的数据即可,不用拘泥id相同时算哪个。

用最直观的办法

这个办法就是用一个空list存放遍历后的数据。

?
1
2
3
4
5
6
7
8
9
10
11
@test
public void dis1() {
  list<user> result = new linkedlist<>();
  for (user user : users) {
   boolean b = result.stream().anymatch(u -> u.getid().equals(user.getid()));
   if (!b) {
    result.add(user);
   }
  }
  system.out.println(result);
}

用hashset

背过特性的都知道hashset可以去重,那么是如何去重的呢? 再深入一点的背过根据hashcode和equals方法。那么如何根据这两个做到的呢?没有看过源码的人是无法继续的,面试也就到此结束了。

事实上,hashset是由hashmap来实现的(没有看过源码的时候曾经一直直观的以为hashmap的key是hashset来实现的,恰恰相反)。这里不展开叙述,只要看hashset的构造方法和add方法就能理解了。

?
1
2
3
4
5
6
7
8
9
public hashset() {
  map = new hashmap<>();
}
/**
* 显然,存在则返回false,不存在的返回true
*/
public boolean add(e e) {
  return map.put(e, present)==null;
}

那么,由此也可以看出hashset的去重复就是根据hashmap实现的,而hashmap的实现又完全依赖于hashcode和equals方法。这下就彻底打通了,想用hashset就必须看好自己的这两个方法。

在本题目中,要根据id去重,那么,我们的比较依据就是id了。修改如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@override
public boolean equals(object o) {
  if (this == o) {
   return true;
  }
  if (o == null || getclass() != o.getclass()) {
   return false;
  }
  user user = (user) o;
  return objects.equals(id, user.id);
}
@override
public int hashcode() {
  return objects.hash(id);
}
//hashcode
result = 31 * result + (element == null ? 0 : element.hashcode());

其中, objects调用arrays的hashcode,内容如上述所示。乘以31等于x<<5-x。

最终实现如下:

?
1
2
3
4
5
@test
public void dis2() {
  set<user> result = new hashset<>(users);
  system.out.println(result);
}

使用java的stream去重

回到最初的问题,之所以提这个问题是因为想要将数据库侧去重拿到java端,那么数据量可能比较大,比如10w条。对于大数据,采用stream相关函数是最简单的了。正好stream也提供了distinct函数。那么应该怎么用呢?

?
1
users.parallelstream().distinct().foreach(system.out::println);

没看到用lambda当作参数,也就是没有提供自定义条件。幸好javadoc标注了去重标准:

?
1
2
returns a stream consisting of the distinct elements
(according to {@link object#equals(object)}) of this stream.

我们知道,也必须背过这样一个准则:equals返回true的时候,hashcode的返回值必须相同. 这个在背的时候略微有些逻辑混乱,但只要了解了hashmap的实现方式就不会觉得拗口了。hashmap先根据hashcode方法定位,再比较equals方法。

所以,要使用distinct来实现去重,必须重写hashcode和equals方法,除非你使用默认的。

那么,究竟为啥要这么做?点进去看一眼实现。

?
1
2
3
4
5
6
7
<p_in> node<t> reduce(pipelinehelper<t> helper, spliterator<p_in> spliterator) {
  // if the stream is sorted then it should also be ordered so the following will also
  // preserve the sort order
  terminalop<t, linkedhashset<t>> reduceop
      = reduceops.<t, linkedhashset<t>>makeref(linkedhashset::new, linkedhashset::add,                           linkedhashset::addall);
  return nodes.node(reduceop.evaluateparallel(helper, spliterator));
}

内部是用reduce实现的啊,想到reduce,瞬间想到一种自己实现distinctbykey的方法。我只要用reduce,计算部分就是把stream的元素拿出来和我自己内置的一个hashmap比较,有则跳过,没有则放进去。其实,思路还是最开始的那个最直白的方法。

?
1
2
3
4
5
6
7
8
9
@test
public void dis3() {
  users.parallelstream().filter(distinctbykey(user::getid))
    .foreach(system.out::println);
}
public static <t> predicate<t> distinctbykey(function<? super t, ?> keyextractor) {
  set<object> seen = concurrenthashmap.newkeyset();
  return t -> seen.add(keyextractor.apply(t));
}

当然,如果是并行stream,则取出来的不一定是第一个,而是随机的。

上述方法是至今发现最好的,无侵入性的。但如果非要用distinct。只能像hashset那个方法一样重写hashcode和equals。

小结

会不会用这些东西,你只能去自己练习过,不然到了真正要用的时候很难一下子就拿出来,不然就冒险用。而若真的想大胆使用,了解规则和实现原理也是必须的。比如,linkedhashset和hashset的实现有何不同。

附上贼简单的linkedhashset源码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class linkedhashset<e>
  extends hashset<e>
  implements set<e>, cloneable, java.io.serializable {
  private static final long serialversionuid = -2851667679971038690l;
  public linkedhashset(int initialcapacity, float loadfactor) {
    super(initialcapacity, loadfactor, true);
  }
  public linkedhashset(int initialcapacity) {
    super(initialcapacity, .75f, true);
  }
  public linkedhashset() {
    super(16, .75f, true);
  }
  public linkedhashset(collection<? extends e> c) {
    super(math.max(2*c.size(), 11), .75f, true);
    addall(c);
  }
  @override
  public spliterator<e> spliterator() {
    return spliterators.spliterator(this, spliterator.distinct | spliterator.ordered);
  }
}

Java中对List去重 Stream去重的解决方法

Java中对List去重 Stream去重的解决方法

补充:

java中list集合去除重复数据的方法

1. 循环list中的所有元素然后删除重复

?
1
2
3
4
5
6
7
8
9
10
public  static  list removeduplicate(list list) {   
 for ( int i =  0 ; i < list.size() -  1 ; i ++ ) {   
   for ( int j = list.size() -  1 ; j > i; j -- ) {   
      if (list.get(j).equals(list.get(i))) {   
       list.remove(j);   
      }   
    }   
   }   
  return list;   
}

2. 通过hashset踢除重复元素

?
1
2
3
4
5
6
public static list removeduplicate(list list) { 
hashset h = new hashset(list); 
list.clear(); 
list.addall(h); 
return list; 
}

3. 删除arraylist中重复元素,保持顺序

?
1
2
3
4
5
6
7
8
9
10
11
12
13
// 删除arraylist中重复元素,保持顺序  
 public static void removeduplicatewithorder(list list) { 
  set set = new hashset(); 
   list newlist = new arraylist(); 
  for (iterator iter = list.iterator(); iter.hasnext();) { 
     object element = iter.next(); 
     if (set.add(element)) 
      newlist.add(element); 
   }  
   list.clear(); 
   list.addall(newlist); 
  system.out.println( " remove duplicate " + list); 
 }

4.把list里的对象遍历一遍,用list.contain(),如果不存在就放入到另外一个list集合中

?
1
2
3
4
5
6
7
8
9
public static list removeduplicate(list list){
    list listtemp = new arraylist();
    for(int i=0;i<list.size();i++){
      if(!listtemp.contains(list.get(i))){
        listtemp.add(list.get(i));
      }
    }
    return listtemp;
  }

原文链接:https://www.cnblogs.com/woshimrf/p/java-list-distinct.html