每天早上七点三十，准时推送干货
一、问题由来
在实际开发的时候，我们经常会碰到这么一个困难：一个集合容器里面有很多重复的对象，里面的对象没有主键，但是根据业务的需求，实际上我们需要根据条件筛选出没有重复的对象。
比较暴力的方法，就是根据业务需求，通过两层循环来进行判断，没有重复的元素就加入到新集合中，新集合中已经有的元素就跳过。
操作例子如下，创建一个实体对象PenBean，代码如下：
-
/**
-
* 笔实体
-
*/
-
public class PenBean {
-
-
/**类型*/
-
private String
type;
-
-
/**颜色*/
-
private String color;
-
-
//... 省略 setter 和 getter
-
-
public PenBean(String
type, String color) {
-
this.
type =
type;
-
this.color = color;
-
}
-
-
@Override
-
public String toString() {
-
return
"PenBean{" +
-
"type='" +
type +
'\'' +
-
", color='" + color +
'\'' +
-
'}';
-
}
-
}
测试 demo，如下：
-
public static void main(String[] args) {
-
//添加信息，PenBean中没有主键
-
List<PenBean> penBeanList =
new ArrayList<PenBean>();
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"铅笔",
"white"));
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
-
//新数据
-
List<PenBean> newPenBeanList =
new ArrayList<PenBean>();
-
//传统重复判断
-
for (PenBean penBean : penBeanList) {
-
if(newPenBeanList.isEmpty()){
-
newPenBeanList.add(penBean);
-
}
else{
-
boolean isSame =
false;
-
for (PenBean newPenBean : newPenBeanList) {
-
//依靠type、color来判断，是否有重复元素
-
//如果新集合包含元素，直接跳过
-
if(penBean.getType().equals(newPenBean.getType()) && penBean.getColor().equals(newPenBean.getColor())){
-
isSame =
true;
-
break;
-
}
-
}
-
if(!isSame){
-
newPenBeanList.add(penBean);
-
}
-
}
-
}
-
-
//输出结果
-
System.out.
println(
"=========新数据======");
-
for (PenBean penBean : newPenBeanList) {
-
System.out.
println(penBean.toString());
-
}
-
}
输出结果：
-
=========新数据======
-
PenBean{
type=
'铅笔', color=
'black'}
-
PenBean{
type=
'铅笔', color=
'white'}
-
PenBean{
type=
'中性笔', color=
'white'}
一般处理数组类型的对象时，可以通过这种方法来对数组元素进行去重操作，以筛选出没有包含重复元素的数组。
那有没有更加简洁的写法呢？
答案肯定是有的，List中的contains()方法就是！
二、利用list中contains方法去重
在使用contains()之前，必须要对PenBean类重写equals()方法，为什么要这么做？等会会详细解释！
我们先在PenBean类中重写equals()方法，内容如下：
-
@Override
-
public boolean equals(Object o) {
-
if (this == o)
return
true;
-
if (o == null || getClass() != o.getClass())
return
false;
-
PenBean penBean = (PenBean) o;
-
//当type、color 内容都相等的时候，才返回true
-
return Objects.equals(
type, penBean.
type) &&
-
Objects.equals(color, penBean.color);
-
}
修改测试 demo，如下：
-
public static void main(String[] args) {
-
//添加信息
-
List<PenBean> penBeanList =
new ArrayList<PenBean>();
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"铅笔",
"white"));
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
-
//新数据
-
List<PenBean> newPenBeanList =
new ArrayList<PenBean>();
-
//使用contain判断，是否有相同的元素
-
for (PenBean penBean : penBeanList) {
-
if(!newPenBeanList.contains(penBean)){
-
newPenBeanList.add(penBean);
-
}
-
}
-
-
//输出结果
-
System.out.
println(
"=========新数据======");
-
for (PenBean penBean : newPenBeanList) {
-
System.out.
println(penBean.toString());
-
}
-
}
输出结果如下：
-
=========新数据======
-
PenBean{
type=
'铅笔', color=
'black'}
-
PenBean{
type=
'铅笔', color=
'white'}
-
PenBean{
type=
'中性笔', color=
'white'}
如果PenBean对象不重写equals()，contains()方法的都是false！新数据与源数据是一样的，并不能达到我们想要除去重复元素的目的
那么contains()是怎么做到，判断一个集合里面有相同的元素呢？
我们打开ArrayList中contains()方法，源码如下：
-
public boolean contains(Object o) {
-
return indexOf(o) >=
0;
-
}
找到indexOf(o)方法，继续往下看，源码如下：
-
public
int indexOf(Object o) {
-
if (o == null) {
-
for (
int i =
0; i < size; i++)
-
if (elementData[i]==null)
-
return i;
-
}
else {
-
for (
int i =
0; i < size; i++)
-
//对象通过 equals 方法，判断是否相同
-
if (o.equals(elementData[i]))
-
return i;
-
}
-
return
-1;
-
}
此时，非常清晰了，如果传入的对象是null，for循环判断数组中的元素是否有null，如果有就返回下标；如果传入的对象不是null，通过对象的equals()方法，for循环判断是否有相同的元素，如果有就返回下标！
如果是数组返回的下标，肯定是大于0，否则返回-1！
这就是为什么在List中使用contains()方法，对象需要重写equals()方法的原因！
三、java 8中去重操作
当然，有些朋友可能会想到 JDK1.8 中的流式写法，例如 jdk1.8 中的集合元素去重写法如下：
-
public static void main(String[] args) {
-
//添加信息
-
List<PenBean> penBeanList =
new ArrayList<PenBean>();
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"铅笔",
"white"));
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
-
//使用java8新特性stream进行List去重
-
List<PenBean> newPenBeanList = penBeanList.stream().distinct().collect(Collectors.toList());
-
-
//输出结果
-
System.out.
println(
"=========新数据======");
-
for (PenBean penBean : newPenBeanList) {
-
System.out.
println(penBean.toString());
-
}
-
}
利用 jdk1.8 中提供的Stream.distinct()列表去重，Stream.distinct()使用hashCode()和equals()方法来获取不同的元素，因此使用这种写法，对象需要重写hashCode()和equals()方法！
对PenBean对象重写hashCode()方法，代码如下：
-
@Override
-
public
int hashCode() {
-
return Objects.hash(
type, color);
-
}
在运行测试demo，结果如下：
-
=========新数据======
-
PenBean{
type=
'铅笔', color=
'black'}
-
PenBean{
type=
'铅笔', color=
'white'}
-
PenBean{
type=
'中性笔', color=
'white'}
即可实现集合元素的去重操作！
那为什么当我们使用String类型的对象作为集合元素时，没有重写呢？
因为 java 中String原生类，已经重写好了，源码如下：
-
public final class String
-
implements java.io.Serializable, Comparable<String>, CharSequence {
-
-
@Override
-
public boolean equals(Object anObject) {
-
if (this == anObject) {
-
return
true;
-
}
-
if (anObject instanceof String) {
-
String anotherString = (String)anObject;
-
int n = value.length;
-
if (n == anotherString.value.length) {
-
char v1[] = value;
-
char v2[] = anotherString.value;
-
int i =
0;
-
while (n-- !=
0) {
-
if (v1[i] != v2[i])
-
return
false;
-
i++;
-
}
-
return
true;
-
}
-
}
-
return
false;
-
}
-
-
@Override
-
public
int hashCode() {
-
int h = hash;
-
if (h ==
0 && value.length >
0) {
-
char val[] = value;
-
-
for (
int i =
0; i < value.length; i++) {
-
h =
31 * h + val[i];
-
}
-
hash = h;
-
}
-
return h;
-
}
-
}
四、HashSet去重操作
在上面的分享中，我们介绍了 List 的集合去重操作！其中网友还提到了HashSet可以实现元素的去重！
的确，HashSet集合天然支持元素不重复！
实践代码如下！
还是先创建一个对象PenBean，同时重写Object中的equals()和hashCode()方法，如下：
-
/**
-
* 笔实体
-
*/
-
public class PenBean {
-
/**类型*/
-
private String
type;
-
/**颜色*/
-
private String color;
-
//... 省略 setter 和 getter
-
public PenBean(String
type, String color) {
-
this.
type =
type;
-
this.color = color;
-
}
-
@Override
-
public String toString() {
-
return
"PenBean{" +
-
"type='" +
type +
'\'' +
-
", color='" + color +
'\'' +
-
'}';
-
}
-
-
@Override
-
public boolean equals(Object o) {
-
if (this == o)
return
true;
-
if (o == null || getClass() != o.getClass())
return
false;
-
PenBean penBean = (PenBean) o;
-
//当type、color 内容都相等的时候，才返回true
-
return Objects.equals(
type, penBean.
type) &&
-
Objects.equals(color, penBean.color);
-
}
-
-
@Override
-
public
int hashCode() {
-
return Objects.hash(
type, color);
-
}
-
-
}
创建测试 demo，如下：
-
public static void main(String[] args) {
-
//添加信息
-
List<PenBean> penBeanList =
new ArrayList<PenBean>();
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"铅笔",
"white"));
-
penBeanList.add(
new PenBean(
"铅笔",
"black"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
penBeanList.add(
new PenBean(
"中性笔",
"white"));
-
-
//新数据
-
List<PenBean> newPenBeanList =
new ArrayList<PenBean>();
-
//set去重
-
HashSet<PenBean> set =
new HashSet<>(penBeanList);
-
newPenBeanList.addAll(set);
-
-
//输出结果
-
System.out.
println(
"=========新数据======");
-
for (PenBean penBean : newPenBeanList) {
-
System.out.
println(penBean.toString());
-
}
-
}
输出结果如下：
-
=========新数据======
-
PenBean{
type=
'铅笔', color=
'white'}
-
PenBean{
type=
'铅笔', color=
'black'}
-
PenBean{
type=
'中性笔', color=
'white'}
很明细，返回的新集合没有重复元素！
那HashSet是怎么做的的呢？
打开HashSet的源码，查看我们传入的构造方法如下：
-
public HashSet(Collection<? extends E> c) {
-
map =
new HashMap<>(Math.max((
int) (c.size()/
.75f) +
1,
16));
-
addAll(c);
-
}
很显然，首先创建了一个HashMap对象，然后调用addAll()方法，继续往下看这个方法！
-
public boolean addAll(Collection<? extends E> c) {
-
boolean modified =
false;
-
for (E e : c)
-
if (add(e))
-
modified =
true;
-
return modified;
-
}
首先遍历List中的元素，然后调用add()方法，这个方法，源码如下：
-
public boolean add(E e) {
-
return
map.put(e, PRESENT)==null;
-
}
其实，就是向HashMap对象中插入元素，其中PRESENT是一个new Object()常量！
private static final Object PRESENT = new Object();
到这里就基本很清楚了，向HashSet中添加元素，其实等同于
-
Map<Object,Object>
map =
new HashMap<Object,Object>();
-
map.put(e,
new Object);
//e表示要插入的元素
其中插入的元素e，就是HashMap中的key！
我们知道HashMap，是通过equals()和hashCode()来判断插入的key是否为同一个key，因此，当我们对PenBean对象进行重写equals()和hashCode()时，保证判断是同一个key时，就可以达到元素去重的目的！
最后，对已经去重的集合HashSet，再通过ArrayList中的addAll()方法进行包装，即可得到我们想要的不包含重复元素的数据！
五、参考
JDK1.8-源码分析
最后说两句（求关注）
最近大家应该发现微信公众号信息流改版了吧，再也不是按照时间顺序展示了。这就对阿粉这样的坚持的原创小号主，可以说非常打击，阅读量直线下降，正反馈持续减弱。
所以看完文章，哥哥姐姐们给阿粉来个在看吧，让阿粉拥有更加大的动力，写出更好的文章，拒绝白嫖，来点正反馈呗~。
如果想在第一时间收到阿粉的文章，不被公号的信息流影响，那么可以给Java极客技术设为一个星标。
最后感谢各位的阅读，才疏学浅，难免存在纰漏，如果你发现错误的地方，由于本号没有留言功能，还请你在后台留言指出，我对其加以修改。
最后谢谢大家支持~
最最后，重要的事再说一篇~
快来关注我呀~
快来关注我呀~
快来关注我呀~
< END >
如果大家喜欢我们的文章，欢迎大家转发，点击在看让更多的人看到。也欢迎大家热爱技术和学习的朋友加入的我们的知识星球当中，我们共同成长，进步。
转载：https://blog.csdn.net/javageektech/article/details/107852903