在实际开发的时候,我们经常会碰到这么一个困难:一个集合容器里面有很多重复的对象,里面的对象没有主键,但是根据业务的需求,实际上我们需要根据条件筛选出没有重复的对象。
比较暴力的方法,就是根据业务需求,通过两层循环来进行判断,没有重复的元素就加入到新集合中,新集合中已经有的元素就跳过。
操作例子如下,创建一个实体对象PenBean
,代码如下:
/***笔实体*/publicclassPenBean{/**类型*/privateStringtype;/**颜色*/privateStringcolor;//...省略setter和getterpublicPenBean(Stringtype,Stringcolor){this.type=type;this.color=color;}@OverridepublicStringtoString(){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()
方法,内容如下:
@Overridepublicbooleanequals(Objecto){if(this==o)returntrue;if(o==null||getClass()!=o.getClass())returnfalse;PenBeanpenBean=(PenBean)o;//当type、color内容都相等的时候,才返回truereturnObjects.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
!新数据与源数据是一样的,并不能达到我们想要除去重复元素的目的
如果list里面都是字符串,可以直接用 contains 而不需要重写 equals 方法,但是如果是比较 list 里的复杂对象,需要重写 equals 方法
那么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()
方法,代码如下:
@OverridepublicinthashCode(){returnObjects.hash(type,color);}
在运行测试demo,结果如下:
=========新数据======PenBean{type='铅笔',color='black'}PenBean{type='铅笔',color='white'}PenBean{type='中性笔',color='white'}
即可实现集合元素的去重操作!
那为什么当我们使用String
类型的对象作为集合元素时,没有重写呢?
因为 java 中String
原生类,已经重写好了,源码如下:
publicfinalclassStringimplementsjava.io.Serializable,Comparable<String>,CharSequence{@Overridepublicbooleanequals(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;}@OverridepublicinthashCode(){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;}}
四、HashSet去重操作
在上面的分享中,我们介绍了 List 的集合去重操作!其中网友还提到了HashSet
可以实现元素的去重!
的确,HashSet
集合天然支持元素不重复!
实践代码如下!
还是先创建一个对象PenBean
,同时重写Object
中的equals()
和hashCode()
方法,如下:
/***笔实体*/publicclassPenBean{/**类型*/privateStringtype;/**颜色*/privateStringcolor;//...省略setter和getterpublicPenBean(Stringtype,Stringcolor){this.type=type;this.color=color;}@OverridepublicStringtoString(){return"PenBean{"+"type='"+type+'\''+",color='"+color+'\''+'}';}@Overridepublicbooleanequals(Objecto){if(this==o)returntrue;if(o==null||getClass()!=o.getClass())returnfalse;PenBeanpenBean=(PenBean)o;//当type、color内容都相等的时候,才返回truereturnObjects.equals(type,penBean.type)&&Objects.equals(color,penBean.color);}@OverridepublicinthashCode(){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()
方法进行包装,即可得到我们想要的不包含重复元素的数据!