详述HashSet的add方法

最新推荐文章于 2022-11-04 20:09:04 发布
最新推荐文章于 2022-11-04 20:09:04 发布
阅读量824 收藏
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43784914/article/details/99287178
版权 
package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();
		set.add("Tom");
	}	
}

解析：
HashSet set = new HashSet<>();
按住Ctrl点击new HashMap<>的HashMap，进去之后，我们可以看到下面的代码，即，这行代码的实质是，创建HashSet对象，调用该类中无参构造方法，执行了该构造方法中的map = new HashMap<>();map为HashSet全局变量。（看map的颜色，是蓝色的，）

public HashSet() {
	map = new HashMap<>();
}

在这里插入图片描述
set.add(“Tom”);
调用HashSet add方法，点add进去看到map.put(e, PRESENT)，map为全局变量，PRESENT是一个常量，因为他是全大写的。map指向的是创建HashSet对象时创建的HashMap对象。（证明：点进去看一看）。

 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

hashCode()方法。
作用：输出对应的哈希值，对象的地址。

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();
		set.add("Tom");
		Test test = new Test();
		System.out.println(test.hashCode());		
	}	
}

结果：

2018699554

注：
不同对象的hashCode一定不相同；相同对象的HashCode的值一定相同，所以HashMap中hash方法：传入相同的对象，得到相同的结果
例：

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();
		set.add("Tom");
		Test test = new Test();
		System.out.println(test.hashCode());
		test = new Test();
		System.out.println(test.hashCode());
	}	
}

结果：

2018699554
1311053135

因为第二次的test被重新赋予了一个新的对象的值。所以两次的hashcode值不一样。
例：

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();		
		String name1="Tom";
		System.out.println(name1.hashCode());
		String name2=new String("Tom");
		System.out.println(name2.hashCode());
	}	
}

结果：

84274
84274

Integer.toHexString(）方法：
作用：
返回无符号整数基数为16的整数参数的字符串表示形式。
例：

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();
		set.add("Tom");
		Test test = new Test();
		System.out.println(test.hashCode());
		System.out.println(Integer.toHexString(test.hashCode()));
	}	
}

结果：

2018699554
7852e922

System.out.println(test);默认调用toString方法。

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();
		set.add("Tom");
		Test test = new Test();
		System.out.println(test.hashCode());
		System.out.println(Integer.toHexString(test.hashCode()));
		System.out.println(test);
	}	
}

对比：

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();
		set.add("Tom");
		Test test = new Test();
		System.out.println(test.hashCode());
		System.out.println(Integer.toHexString(test.hashCode()));
		System.out.println(test);
		System.out.println(test.toString());
	}	
}

结果：

2018699554
7852e922
add.Test@7852e922
add.Test@7852e922

add()方法：

例1：

我们知道，HashSet中的add方法是不允许其中的元素重复的，那么：思考一下，我们怎么判断他不允许重复？

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();
		set.add("Tom");
		set.add("Tom");
	}	
}

我们进入add方法中，看到的是如下情形：

 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
   }

那么，第一次向其中添加元素“Tom”，所走路径如下：
由于返回的是map.put(e, PRESENT)==null是ture还是false值，但是到目前为止，我们无法判断，我们必须再进一步，判断他们的值是否相等。
再进一步我们进入map的put方法中可以看到如下代码：

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

这几行代码返回的值我们仍无法判断，那么我们就再进一步，观察putVal里面的结果。
看到的代码如下：

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
        }

我们可以看到，他定义了一个 Node<K,V>[]数组tab，Node<K,V> 类型的p变量。
往下走：
if ((tab = table) == null || (n = tab.length) == 0)
我们要想知道tab与table的值是否相等，就必须要进入tab数组里面查看。
进入tab数组：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

分析：
因为table默认值为0，所以oldTab=0，oldCap=0，又因为threshold默认值也为0.
所以走下面的分支：

 else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

那么 newCap和 newThr现在都有值了。
再往下走：

threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;

再走：return newTab;
由此，tab=table=0。所以putVal里的第一个if语句我们可以走，此时n = (tab = resize()).length;则，n=16；在往下走if ((p = tab[i = (n - 1) & hash]) == null)看我们能否走这一条分支，因为i=(n - 1) & hash，所以此时数组tab内应该是没有值的，那么p=tab[i]，所以p是null，所以我们可以走这一条分支。
tab[i] = newNode(hash, key, value, null);
所以：

++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;

返回值为null。
返回

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

他的返回值也为null，再往上一级

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

所以，返回为true，添加成功。
至此，第一次添加结束。
第二次大体仍和第一次的类似，不同之处在于putVal方法中走的路径不同。下面我们详细解释一下：
判断第一条分支是否可以走：
首先判断tab是否等于table，由于第一次走完之后tab的值被改变了，所以tab不再等于table。相同n也不再等于0，所以第一条分支我们不再走。

if ((tab = table) == null || (n = tab.length) == 0)

判断第二条分支：

if ((p = tab[i = (n - 1) & hash]) == null)

由于第二次的tab[i]和第一次的相同，所以此时p的值不再为0，走else。
走：

 if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

由于p.hash == hash 和((k = p.key) == key ， (key != null && key.equals(k))都是true，所以执行这一条语句，即e=p。
往下走执行下面的代码：

if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;

返回oldValue，由于 V oldValue = e.value;而且 if (!onlyIfAbsent || oldValue == null)语句不执行，所以返回oldValue，往上走返回put方法

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

所以，返回有一个值，再返回add方法

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

由于map.put(e, PRESENT)值不为0了，所以返回为false，添加没有成功。

例2：

思考：

package add;
import java.util.HashMap;
import java.util.HashSet;
public class Test {
	public static void main(String[] args) {		
		HashSet<String> set = new HashSet<>();		
		set.add("Tom");
		set.add(new String("Tom"));
	}	
}

这种类型的怎么判断不允许重复？
我们可以凝练成一句话：只要字符串内容相同，则其hashCode值必定相同。
第一次走：
进入Tom------>put方法------>putVal方法------>table为默认值null，所以 （tab = table) == null为true所以后面的(n = tab.length) == 0就不再走，此时第一个if语句我们要走。table是个数组，在此设置，并且tab和table指向的是同一个地址，里面的内容是一样的。n的长度为16.
------>判断第二个if语句我们要走那个分支。因为第一次走，什么都是null，所以我们走if语句，不走else。所以返回null。即加入成功。
第二次走
进入Tom------>put方法------>putVal方法------>因为tab和table值经过第一次，已经改变。而且n也不再为0，所以，第一个if语句不再走。------>由于第一次的hash和第二次的hash值相同。所以i也一样，即p值经第一次后改变。所以我们走else分支。判断里面的if语句，

   if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;

由于第二次的hash和第一次的hash值相同，但是第一次key的地址和第二次的不一样，所以k = e.key) == key为false，那么我们就需要看key != null && key.equals(k)因为key！=null是true，而且，第一次和第二次传的内容是一样的，所以他也是true，走if，得到e=p。------>

if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;

因为!onlyIfAbsent为true，逻辑运算符为||，所以一定执行，所以，value值由第一次的被覆盖成第二次的value值，但这并不影响结果。返回false。

例3：

重写hashCode和equals之前
java认为是两个对象，我们认为的是生活中的一个人。

package add;
import java.util.HashSet;
import Hashmap.Student;
public class Test {
	public static void main(String[] args) {		
		
		
		HashSet<Student> set = new HashSet<>();
		
		Student tom  = new Student("110");
		System.out.println(tom.hashCode());
		Student jim  = new Student("110");
		System.out.println(jim.hashCode());
		System.out.println(tom==jim);//如果在这里输出，为false		
		set.add(tom);
		set.add(jim);
		System.out.println(set.size());
	}	
}
public class Student{
	private  String id;
	public Student (String id ){
	this.id=id;
	}
}

结果是2.

java里是两个对象，所以地址是不一样的。
第一次走：前两个if分支，和最后的返回null。
第二次：由于table不为null，n不为0，所以第一个if分支不走。由于第一次的hash值和第二次的hash值不一样，所以i值也不一样，所以第二个if我们是要走的。

例4.

思考：怎么判断不允许重复？

package add;
import java.util.HashSet;
import Hashmap.Student;
public class Test {
	public static void main(String[] args) {						
		Student tom  = new Student("110");
		System.out.println(tom.hashCode());
		Student jim  = new Student("110");
		System.out.println(jim.hashCode());
		System.out.println(tom==jim);//false
		HashSet<Student> set = new HashSet<>();
		set.add(tom);
		set.add(jim);
		System.out.println(set.size());
	}	
}
public class Student{
	private  String id;
	public Student (String id ){
	this.id=id;
	}
	@Override
	public boolean equals(Object obj){
	Student  student =(Student)obj;
	return this.id.equals(student.id)
	}
	@Override
	public int hashCode(){
	return id.hashCode();
	}
}
重写hashCode之后，equals之前

第一次走：前两个if分支，和最后的返回null。
第二次：由于table不为null，n不为0，所以第一个if分支不走。由于第一次的hash值和第二次的hash值一样，所以i值也一样，所以我们走第二个if的else分支。

  if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))

e.hash == hash 是true，(k = e.key) == key为false， key.equals(k)也为false，所以，这一条分支我们不走。又因为p instanceof TreeNode是false，所以我们走else分支。不是else if。在else中，

重写hashCode和equals之后

第一次走：前两个if分支，和最后的返回null。
第二次：由于table不为null，n不为0，所以第一个if分支不走。由于第一次的hash值和第二次的hash值一样，所以i值也一样，所以我们走第二个if的else分支。然后走if

if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))

再走if。

例5.

思考：为什么出错？

package add;
import java.util.HashSet;
import Hashmap.Dog;
import Hashmap.Student;
public class Test {
	public static void main(String[] args) {						
		Student tom  = new Student("110");
		Dog dog = new Dog("110");
		HashSet<Object> set = new HashSet<>();
		set.add(dog);
		set.add(tom);
		System.out.println(set.size());
	}	
}

因为Dog类和student类不同，所以错。

涟涟涟涟
关注
专栏目录
HashSet去重
07-27
- **`equals`方法的作用**：当两个对象的`hashCode`相同时，`HashSet`会调用这两个对象的`equals`方法来最终确定是否为同一个对象。 - **效率问题**：对于大量数据而言，`HashSet`的效率非常高。哈希表通过`hashCode...
详述HashSet中add方法
x_j_k_jysg的博客
08-11 5342
一、HashSet中对象的创建 在分析HashSet的add方法的底层代码之前我们先要理解HashSet集合中的对象是如何创建的。 先创建一个JavaWeb工程，引入hashset的包，创建含有HashSet类的方法，然后就可以进入HashSet的底层代码： package hashset; import java.util.HashSet; public class Test { ...
HashSet中add()方法的使用
Dream It Possible
06-19 4774
HashSet 传入对象,怎么过滤 首先,我们知道所有的Set里面都套了一个Map,使用Map的Key存值,Value存放一个固定的Object,这是适配器模式。源码如下： public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable { static final long serialVersionUID =
HashSet中的add方法
YXX_decsdn的博客
04-29 2314
1，对HashSet新建对象的分析 HashSet<String> set=new HashSet<String>(); 创建一个HashSet类的对象，new HashSet<String>()调用了HashSet中的无参构造方法 public HashSet（）{ map=new HashMap<>(); } 实质又调用了HashMa...
HashSet中的add()方法
sinat_39898603的博客
05-08 1173
HashSet源码
HashSet和TreeSet使用方法的区别解析
08-28
HashSet和TreeSet使用方法的区别解析 HashSet和TreeSet都是Java集合框架中的Set接口实现，用于存储不重复的元素。但是，它们在使用方法和实现机理上有很大的区别。 首先，从使用方法上讲，HashSet和TreeSet都可以...
实例讲解Java HashSet
08-18
HashSet 类提供了很多有用的方法，添加元素可以使用 add() 方法。例如： ```java import java.util.HashSet; public class RunoobTest { public static void main(String[] args) { HashSet<String> sites = new...
java集合-HashSet的使用
06-14
HashSet 是 Java 中的一个集合类，它实现了 Set 接口并提供了...非线程安全：HashSet 类本身不是线程安全的，在多线程环境下需要进行外部同步操作，或者使用 Collections.synchronizedSet 方法封装成线程安全的集合。
HashSet和TreeSet.doc
12-25
Set是java中一个不包含重复元素的collection。更正式地说，set 不包含满足e1....HashSet与TreeSet都是基于Set接口的实现类。其中TreeSet是Set的子接口SortedSet的实现类。Set接口及其子接口、实现类的结构如下所示。
详述HashSet类中的add方法
weixin_43964847的博客
08-13 1480
详述HashSet类中的add方法 一、hashCode和toString方法 package add; import java.util.HashSet; public class Test { public static void main(String[] args) { HashSet<String> set = new HashSet<String&gt...
Java中HashSet的add元素方法源代码个人总结
du29571的博客
09-01 1741
Java中HashSet的add元素方法源代码个人总结
JAVA学习心得——详述HashSet中的.add();方法
low1101的博客
08-12 6018
下列代码是向set集合中添加元素。 public class Test { public static void main(String[] args) { HashSet<String> set = new HashSet<>(); set.add("Tom"); 一个简单的.add方法，但是源码有很多值得耐人寻味的东西。 首先： HashSet<Str...
Java学习笔记 --- HashSet
乌云的博客
11-04 1308
1、HashSet 实现了 Set 接口2、HashSet 实际上是 HashMap3、可以存放 null 值，但是只能有一个 null4、HashSet 不保证元素是有序的，取决于hash后，再确定索引的结果5、不能有重复元素/对象。
Java 详述 HashSet 的 add 方法
qq_44971038的博客
11-11 702
HashSet 的 add 方法 HashSet 的实质是利用 HashMap 的 key 值存储数据的容器，其有很多方法供我们使用，今天我们就详细说一下其中一个很重要的方法 add；即添加数据的方法；话不多少，先上例子和源码： import java.util.HashSet; public class Test { public static void main(String[] a...
Java中的HashSet的常用方法总结
热门推荐
Liuxiaoyang1999的博客
08-08 1万+
目录 一、引言 二、HashSet中的常用方法 1.add(Objectobj)方法（详述）： 2.size() 方法： 3.remove(Object obj)方法： 4.isEmpty()方法： 5.clear()方法： 6.iterator()迭代器： 7.contains(Object o)方法： 三、结语 一、引言 在我之前的博客ArrayL...
HashSet中add方法详解
qq_43285445的博客
11-10 2193
详解HashSet中的add方法 HashSet方法调用 HashSet<String> names = new HashSet<String>();//调用构造方法，创建HashMap集合对象 names.add("jim");//向HashMap集合中添加key值，value值是一个静态Object对象。 源码分析： add方法： public boolean add(E e) { return map.put(e, PRESENT)==null;//P
HashSet的add方法
YJT180的博客
08-12 1826
我们使用过ArrayList类的add方法，其add方法是可以任意添加元素的，而HashSet的add方法则会限制添加重复元素，那么它是如何做到的呢？这需要我们通过查看底层代码来研究。 import java.util.HashSet; public class HashSetLearn { public static void main(String[] args) { HashSe...
HashSet.add（）方法解析
qq_26817225的博客
04-09 536
这篇文章主要是记录学习HashSet时关于add()方法的解析，以便个人理解HashSet大概的工作原理，仅作参考。 范例一： TestObj类的任意实例对象a, b, a.equals(b)方法都返回true，并且a.hashcode() == b.hashcode(),即hashcode值一样。 /** * TestObj类的任意实例对象a, b, a.equals(b)方法都...
C#hashset方法
最新发布
08-24
3. 添加元素：使用Add方法向HashSet中添加元素。例如：`numbers.Add(5);`将整数5添加到HashSet中。 4. 移除元素：使用Remove方法从HashSet中移除元素。例如：`numbers.Remove(5);`从HashSet中移除整数5。 5. 判断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

涟涟涟涟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值