一、问题由来
在实际开发的时候,我们经常会碰到这么一个困难:一个集合容器里面有很多重复的对象,里面的对象没有主键,但是根据业务的需求,实际上我们需要根据条件筛选出没有重复的对象。
比较暴力的方法,就是根据业务需求,通过两层循环来进行判断,没有重复的元素就加入到新集合中,新集合中已经有的元素就跳过。
操作例子如下,创建一个实体对象PenBean,代码如下:
/*** 笔实体*/
public classPenBean {/**类型*/
privateString type;/**颜色*/
privateString color;//... 省略 setter 和 getter
publicPenBean(String type, String color) {this.type =type;this.color =color;
}
@OverridepublicString toString() {return "PenBean{" +
"type='" + type + '\'' +
", color='" + color + '\'' +
'}';
}
}
测试 demo,如下:
public static voidmain(String[] args) {//添加信息,PenBean中没有主键
List penBeanList = new ArrayList();
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 newPenBeanList = new ArrayList();//传统重复判断
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()方法,内容如下:
@Overridepublic booleanequals(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 voidmain(String[] args) {//添加信息
List penBeanList = new ArrayList();
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 newPenBeanList = new ArrayList();//使用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 booleancontains(Object o) {return indexOf(o) >= 0;
}
找到indexOf(o)方法,继续往下看,源码如下:public intindexOf(Object o) {if (o == null) {for (int i = 0; i < size; i++)if (elementData[i]==null)returni;
}else{for (int i = 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 中的集合元素去重写法如下:
public static voidmain(String[] args) {//添加信息
List penBeanList = new ArrayList();
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 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()方法,代码如下:
@Overridepublic inthashCode() {returnObjects.hash(type, color);
}
在运行测试demo,结果如下:=========新数据======PenBean{type='铅笔', color='black'}
PenBean{type='铅笔', color='white'}
PenBean{type='中性笔', color='white'}
即可实现集合元素的去重操作!
那为什么当我们使用String类型的对象作为集合元素时,没有重写呢?
因为 java 中String原生类,已经重写好了,源码如下:public final classStringimplements java.io.Serializable, Comparable, CharSequence {
@Overridepublic booleanequals(Object anObject) {if (this ==anObject) {return true;
}if (anObject instanceofString) {
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;
}
@Overridepublic inthashCode() {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;
}returnh;
}
}
四、HashSet去重操作
在上面的分享中,我们介绍了 List 的集合去重操作!其中网友还提到了HashSet可以实现元素的去重!
的确,HashSet集合天然支持元素不重复!
实践代码如下!
还是先创建一个对象PenBean,同时重写Object中的equals()和hashCode()方法,如下:
/*** 笔实体*/
public classPenBean {/**类型*/
privateString type;/**颜色*/
privateString color;//... 省略 setter 和 getter
publicPenBean(String type, String color) {this.type =type;this.color =color;
}
@OverridepublicString toString() {return "PenBean{" +
"type='" + type + '\'' +
", color='" + color + '\'' +
'}';
}
@Overridepublic booleanequals(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);
}
@Overridepublic inthashCode() {returnObjects.hash(type, color);
}
}
创建测试 demo,如下:
public static voidmain(String[] args) {//添加信息
List penBeanList = new ArrayList();
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 newPenBeanList = new ArrayList();//set去重
HashSet 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;returnmodified;
}
首先遍历List中的元素,然后调用add()方法,这个方法,源码如下:
public booleanadd(E e) {return map.put(e, PRESENT)==null;
}
其实,就是向HashMap对象中插入元素,其中PRESENT是一个new Object()常量!
private static final Object PRESENT = new Object();
到这里就基本很清楚了,向HashSet中添加元素,其实等同于
Map map = new HashMap();
map.put(e,new Object);//e表示要插入的元素
其中插入的元素e,就是HashMap中的key!
我们知道HashMap,是通过equals()和hashCode()来判断插入的key是否为同一个key,因此,当我们对PenBean对象进行重写equals()和hashCode()时,保证判断是同一个key时,就可以达到元素去重的目的!
最后,对已经去重的集合HashSet,再通过ArrayList中的addAll()方法进行包装,即可得到我们想要的不包含重复元素的数据!