Set的定义是一群不重复的元素的集合容器。也就是说，只要使用Set组件，应该是要保证相同的数据只能写入一份，要么报错，要么忽略。当然一般是直接忽略。
如题，HashSet是Set的一种实现，自然也符合其基本的定义。它的自然表现是，一直往里面插入数据，然后最后可以得到全部不重复的数据集合，即直到天然去重的效果。
1. 简单使用如下
先插入几个元素，得到的结果是没有重复的结果数量。
- @Test
- public void testSetAdd() {
- Set<String> data = new HashSet<>();
- data.add("a");
- data.add("b");
- data.add("a");
- Assert.assertEquals("数量不正确", 2, data.size());
- }
简单说下HashSet的实现原理，它是基于HashMap实现的一种set容器，直白说就是HashSet内部维护了一个HashMap的实例，插入和删除时委托给HashMap去实现，而HashMap中的Key就是HashSet中的值，HashMap的value就是一个常量Object.
- // Dummy value to associate with an Object in the backing Map
- private static final Object PRESENT = new Object();
- /**
- * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
- * default initial capacity (16) and load factor (0.75).
- */
- public HashSet() {
- map = new HashMap<>();
- }
- /**
- * Adds the specified element to this set if it is not already present.
- * More formally, adds the specified element <tt>e</tt> to this set if
- * this set contains no element <tt>e2</tt> such that
- * <tt>(e==null ? e2==null : e.equals(e2))</tt>.
- * If this set already contains the element, the call leaves the set
- * unchanged and returns <tt>false</tt>.
- *
- * @param e element to be added to this set
- * @return <tt>true</tt> if this set did not already contain the specified
- * element
- */
- public boolean add(E e) {
- return map.put(e, PRESENT)==null;
- }
还是比较清晰的。
2. HashSet保证元素不重复的原理
上节讲了HashSet是基于HashMap实现的，只不过它忽略了HashMap中的value信息。那么它怎么样保证不重复呢，自然也是依赖于HashMap了，HashMap中要保证key不重复有两个点：一是hashCode()要返回相同的值；二是equals()要返回true；换句话说就是要我们绝对认为该对象就是同一个时，才会替换原来的值。即要重写 hashCode()和equals()方法。样例如下：
- class TableFieldDesc {
- private String fieldName;
- private String alias;
- public TableFieldDesc(String fieldName, String alias) {
- this.fieldName = fieldName;
- this.alias = alias;
- }
- @Override
- public int hashCode() {
- return Objects.hash(fieldName, alias);
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
- TableFieldDesc that = (TableFieldDesc) o;
- return Objects.equals(fieldName, that.fieldName) &&
- Objects.equals(alias, that.alias);
- }
- }
这样一来的话， new TableFieldDesc("f_a", "a") 与 new TableFieldDesc("f_a", "a") 就可以相等了，也就是说，如果有两个这样的元素插入，只会被当作同一个来处理了，从而达到去重的效果。测试如下：
- @Test
- public void testSetAdd2() {
- Set<TableFieldDesc> data = new HashSet<>();
- data.add(new TableFieldDesc("f_a", "a"));
- data.add(new TableFieldDesc("f_a", "a"));
- Assert.assertEquals("数量不正确", 1, data.size());
- }
3. HashSet真能够保证不插入重复元素吗？
如题，hashSet真的能够保证不插入重复元素吗？我们常规理解好像是的，但是实际上还是有点问题。一般地，我们要求HashMap的key是不可变的，为什么会有这种要求呢？因为简单啊。但是，实际场景需要，也允许可变，就是要做到上节说的hashCode与equals重写。看起来一切都很美好，但是真的就没问题了吗？其实是有的。如下：
- @Test
- public void testSetAdd3() {
- Set<TableFieldDesc> data = new HashSet<>();
- TableFieldDesc fa = new TableFieldDesc("f_a", "a");
- data.add(fa);
- // 将f_a 改成了f_b，即 new TableFieldDesc("f_b", "a");
- fa.setFieldName("f_b");
- TableFieldDesc fb = new TableFieldDesc("f_b", "a");
- data.add(fb);
- System.out.println("data:" + data);
- // 此处就插入了重复的元素了
- Assert.assertEquals("数量不正确", 2, data.size());
- }
如上就是，插入了两个重复的元素了，打印信息为：
- data:[TableFieldDesc{fieldName='f_b', alias='a'}, TableFieldDesc{fieldName='f_b', alias='a'}]
完整的TableFieldDesc描述如下：
- class TableFieldDesc {
- private String fieldName;
- private String alias;
- public TableFieldDesc(String fieldName, String alias) {
- this.fieldName = fieldName;
- this.alias = alias;
- }
- public void setFieldName(String fieldName) {
- this.fieldName = fieldName;
- }
- public void setAlias(String alias) {
- this.alias = alias;
- }
- @Override
- public int hashCode() {
- return Objects.hash(fieldName, alias);
- }
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
- TableFieldDesc that = (TableFieldDesc) o;
- return Objects.equals(fieldName, that.fieldName) &&
- Objects.equals(alias, that.alias);
- }
- @Override
- public String toString() {
- return "TableFieldDesc{" +
- "fieldName='" + fieldName + '\'' +
- ", alias='" + alias + '\'' +
- '}';
- }
- }
View Code 为什么会这样呢？就像测试用例中写的，先插入了一个元素，然后再改变里面的某个值，随后再插入一个改变过之后的值，就重复了。因为hashCode是在插入的时候计算的，而当后续用户改变key的数据值，导致hashCode变更，这时就存在，在对应的slot上，不存在对应元素的情况，所以下次再插入另一个相同元素时，就被认为元素不存在从而插入重复数据了。
更严重的，当元素数据达到一定的时候，会存在扩容，会重复迁移所有元素，可能还会存在hash重新计算从而将重复的元素变为不重复的情况，就更玄乎了。（不过幸好，HashMap中的扩容不会重新计算hash，它会保留原来的hash，所以重复的元素永远会重复。）
结语警示：如果想用Set容器去做去重的工作，需要仔细了解其实现原理，而非想当然的认为会去重。能做到不改变key值就尽量避开，甚至不暴露修改数据的方法，即做到对象不可变的效果。从而避免踩坑。
经验首页