在实际开发的时候，我们经常会碰到这么一个困难：一个集合容器里面有很多重复的对象，里面的对象没有主键，但是根据业务的需求，实际上我们需要根据条件筛选出没有重复的对象。
比较暴力的方法，就是根据业务需求，通过两层循环来进行判断，没有重复的元素就加入到新集合中，新集合中已经有的元素就跳过。
操作例子如下，创建一个实体对象PenBean，代码如下：
/**
*笔实体
*/
publicclassPenBean{
/**类型*/
privateStringtype;
/**颜色*/
privateStringcolor;
//...省略setter和getter
publicPenBean(Stringtype,Stringcolor){
this.type=type;
this.color=color;
}
@Override
publicStringtoString(){
return"PenBean{"
"type='" type '\''
",color='" color '\''
'}';
}
}
测试 demo，如下：
publicstaticvoidmain(String[]args){
//添加信息，PenBean中没有主键
List<PenBean>penBeanList=newArrayList<PenBean>();
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("铅笔","white"));
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("中性笔","white"));
penBeanList.add(newPenBean("中性笔","white"));
//新数据
List<PenBean>newPenBeanList=newArrayList<PenBean>();
//传统重复判断
for(PenBeanpenBean:penBeanList){
if(newPenBeanList.isEmpty()){
newPenBeanList.add(penBean);
}else{
booleanisSame=false;
for(PenBeannewPenBean: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(PenBeanpenBean: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
publicbooleanequals(Objecto){
if(this==o)returntrue;
if(o==null||getClass()!=o.getClass())returnfalse;
PenBeanpenBean=(PenBean)o;
//当type、color内容都相等的时候，才返回true
returnObjects.equals(type,penBean.type)&&
Objects.equals(color,penBean.color);
}
修改测试 demo，如下：
publicstaticvoidmain(String[]args){
//添加信息
List<PenBean>penBeanList=newArrayList<PenBean>();
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("铅笔","white"));
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("中性笔","white"));
penBeanList.add(newPenBean("中性笔","white"));
//新数据
List<PenBean>newPenBeanList=newArrayList<PenBean>();
//使用contain判断，是否有相同的元素
for(PenBeanpenBean:penBeanList){
if(!newPenBeanList.contains(penBean)){
newPenBeanList.add(penBean);
}
}
//输出结果
System.out.println("=========新数据======");
for(PenBeanpenBean: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()方法，源码如下：
publicbooleancontains(Objecto){
returnindexOf(o)>=0;
}
找到indexOf(o)方法，继续往下看，源码如下：
publicintindexOf(Objecto){
if(o==null){
for(inti=0;i<size;i )
if(elementData[i]==null)
returni;
}else{
for(inti=0;i<size;i )
//对象通过equals方法，判断是否相同
if(o.equals(elementData[i]))
returni;
}
return-1;
}
此时，非常清晰了，如果传入的对象是null，for循环判断数组中的元素是否有null，如果有就返回下标；如果传入的对象不是null，通过对象的equals()方法，for循环判断是否有相同的元素，如果有就返回下标！
如果是数组返回的下标，肯定是大于0，否则返回-1！
这就是为什么在List中使用contains()方法，对象需要重写equals()方法的原因！
三、java 8中去重操作当然，有些朋友可能会想到 JDK1.8 中的流式写法，例如 jdk1.8 中的集合元素去重写法如下：
publicstaticvoidmain(String[]args){
//添加信息
List<PenBean>penBeanList=newArrayList<PenBean>();
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("铅笔","white"));
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("中性笔","white"));
penBeanList.add(newPenBean("中性笔","white"));
//使用java8新特性stream进行List去重
List<PenBean>newPenBeanList=penBeanList.stream().distinct().collect(Collectors.toList());
//输出结果
System.out.println("=========新数据======");
for(PenBeanpenBean:newPenBeanList){
System.out.println(penBean.toString());
}
}
利用 jdk1.8 中提供的Stream.distinct()列表去重，Stream.distinct()使用hashCode()和equals()方法来获取不同的元素，因此使用这种写法，对象需要重写hashCode()和equals()方法！
对PenBean对象重写hashCode()方法，代码如下：
@Override
publicinthashCode(){
returnObjects.hash(type,color);
}
在运行测试demo，结果如下：
=========新数据======
PenBean{type='铅笔',color='black'}
PenBean{type='铅笔',color='white'}
PenBean{type='中性笔',color='white'}
即可实现集合元素的去重操作！
那为什么当我们使用String类型的对象作为集合元素时，没有重写呢？
因为 java 中String原生类，已经重写好了，源码如下：
publicfinalclassString
implementsjava.io.Serializable,Comparable<String>,CharSequence{
@Override
publicbooleanequals(ObjectanObject){
if(this==anObject){
returntrue;
}
if(anObjectinstanceofString){
StringanotherString=(String)anObject;
intn=value.length;
if(n==anotherString.value.length){
charv1[]=value;
charv2[]=anotherString.value;
inti=0;
while(n--!=0){
if(v1[i]!=v2[i])
returnfalse;
i ;
}
returntrue;
}
}
returnfalse;
}
@Override
publicinthashCode(){
inth=hash;
if(h==0&&value.length>0){
charval[]=value;
for(inti=0;i<value.length;i ){
h=31*h val[i];
}
hash=h;
}
returnh;
}
}
在上面的分享中，我们介绍了 List 的集合去重操作！其中网友还提到了HashSet可以实现元素的去重！
的确，HashSet集合天然支持元素不重复！
实践代码如下！
还是先创建一个对象PenBean，同时重写Object中的equals()和hashCode()方法，如下：
/**
*笔实体
*/
publicclassPenBean{
/**类型*/
privateStringtype;
/**颜色*/
privateStringcolor;
//...省略setter和getter
publicPenBean(Stringtype,Stringcolor){
this.type=type;
this.color=color;
}
@Override
publicStringtoString(){
return"PenBean{"
"type='" type '\''
",color='" color '\''
'}';
}
@Override
publicbooleanequals(Objecto){
if(this==o)returntrue;
if(o==null||getClass()!=o.getClass())returnfalse;
PenBeanpenBean=(PenBean)o;
//当type、color内容都相等的时候，才返回true
returnObjects.equals(type,penBean.type)&&
Objects.equals(color,penBean.color);
}
@Override
publicinthashCode(){
returnObjects.hash(type,color);
}
}
创建测试 demo，如下：
publicstaticvoidmain(String[]args){
//添加信息
List<PenBean>penBeanList=newArrayList<PenBean>();
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("铅笔","white"));
penBeanList.add(newPenBean("铅笔","black"));
penBeanList.add(newPenBean("中性笔","white"));
penBeanList.add(newPenBean("中性笔","white"));
//新数据
List<PenBean>newPenBeanList=newArrayList<PenBean>();
//set去重
HashSet<PenBean>set=newHashSet<>(penBeanList);
newPenBeanList.addAll(set);
//输出结果
System.out.println("=========新数据======");
for(PenBeanpenBean:newPenBeanList){
System.out.println(penBean.toString());
}
}
输出结果如下：
=========新数据======
PenBean{type='铅笔',color='white'}
PenBean{type='铅笔',color='black'}
PenBean{type='中性笔',color='white'}
很明细，返回的新集合没有重复元素！
那HashSet是怎么做的的呢？
打开HashSet的源码，查看我们传入的构造方法如下：
publicHashSet(Collection<?extendsE>c){
map=newHashMap<>(Math.max((int)(c.size()/.75f) 1,16));
addAll(c);
}
很显然，首先创建了一个HashMap对象，然后调用addAll()方法，继续往下看这个方法！
publicbooleanaddAll(Collection<?extendsE>c){
booleanmodified=false;
for(Ee:c)
if(add(e))
modified=true;
returnmodified;
}
首先遍历List中的元素，然后调用add()方法，这个方法，源码如下：
publicbooleanadd(Ee){
returnmap.put(e,PRESENT)==null;
}
其实，就是向HashMap对象中插入元素，其中PRESENT是一个new Object()常量！
privatestaticfinalObjectPRESENT=newObject();
到这里就基本很清楚了，向HashSet中添加元素，其实等同于
Map<Object,Object>map=newHashMap<Object,Object>();
map.put(e,newObject);//e表示要插入的元素
其中插入的元素e，就是HashMap中的key！
我们知道HashMap，是通过equals()和hashCode()来判断插入的key是否为同一个key，因此，当我们对PenBean对象进行重写equals()和hashCode()时，保证判断是同一个key时，就可以达到元素去重的目的！
最后，对已经去重的集合HashSet，再通过ArrayList中的addAll()方法进行包装，即可得到我们想要的不包含重复元素的数据！
五、参考JDK1.8-源码分析
,
