我们在操作stream时，如果遇到转map时，如果不处理key重复，就会报错Duplicate key，今天就分享一下我们在操作java stream时如何去重，有哪几种方式。
例如我们源数据有，以下很多例子都使用list来操作
```java
		List<UserInfo> list = new ArrayList();
		list.add(new UserInfo(1,"小明",1));
		list.add(new UserInfo(2,"小s",2));
		list.add(new UserInfo(1,"小明",2));
```
如果我们要将上面数据去重，按id转换成map，有三种方式；
#### distinct方法
distinct是按对象的equals方式比对去重，所以要比对UserInfo对象的话，就得重写UserInfo的equals方法：
```java
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof UserInfo) {
        	UserInfo tmp = (UserInfo) obj;
            if (this.getId().equals(tmp.getId())) {
                return true;
            }
        }
        return false;
    }
```
然后去重转map：
```java
Map<Integer, UserInfo> map = list.stream().distinct()
.collect(Collectors.toMap(UserInfo::getId, u -> u));
```
当然如果你要去重的数据是Integer或String这样基本数据类型包装类，那我们直接用distinct去重，无需重写方法。如下所示，List的去重：
```java
		List<Integer> list1 = list.stream().map(u -> u.getDeptId())
				.collect(Collectors.toList());
		System.out.println("list1:"+list1);
		List<Integer> list2 = list1.stream().distinct()
				.collect(Collectors.toList());
		System.out.println("list2:"+list2);
```
上面输出结果如下:
```
list1:[1, 2, 2]
list2:[1, 2]
```

#### filter方法
stream的filter方法可以过滤掉数据，也可以调用自己的去重逻辑，如下代码所示：
去重工具类：
```java
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;

public class DistinctKeyUtil {

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        ConcurrentHashMap<Object, Boolean> map = new ConcurrentHashMap<>();
        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}
```
filter中调用工具类去重：
```java
Map<Integer, UserInfo> map = list.stream()
			.filter(DistinctKeyUtil.distinctByKey(n -> n))
			.collect(Collectors.toMap(UserInfo::getId, u -> u));
```
filter去重方式同样适合于List去重，拿上面list1来去重，如下：
```java
		List<Integer> list3 = list1.stream().filter(DistinctKeyUtil.distinctByKey(n -> n)).collect(Collectors.toList());
```

#### Collectors.toMap方法
在Collectors.toMap方法中去重只适合转成map后的key去重，在之前的distinct和filter中默认重复的数据去重只能保留之前的，没法做到后面重复的数据覆盖前面的，那Collectors.toMap方法就可以随意定义这个操作动作。代码如下：
```java
Map<Integer, UserInfo> map4 = list.stream().collect(Collectors.toMap(UserInfo::getId, u -> u,(key1,key2) -> key1));
```
其中(key1,key2) -> key1)就是定义如果出现重复，以前面key为准，如果要以后面数据为准，也就是让重复的数据用后面的覆盖，那么就可以写成：(key1,key2) -> key2)。
这种去重的方式好处是不需要重写equals方法，也不需要定义工具类，随时可以用，但仅限于转Map的场景。

好了，分享完毕。。stream就是好用啊。
其他java stream的操作可以看看我别的文章，[http://www.classinstance.cn/detail/130.html](http://www.classinstance.cn/detail/130.html "http://www.classinstance.cn/detail/130.html")

ClassInstance

java stream去重的几种方式

相关文章

推荐文章

热门文章

标签列表