Set接口和常用方法
基本介绍
- 无序（添加和取出的顺序不一样），没有索引
- 不允许重复元素，所以最多包含一个null
- JDK API 中Set接口的实现类有：
public static void main(String[] args) {
//1.以set接口的实现类HashSet来讲解Set 接口的方法
//2.set接口的实现类的对象（Set接口对象），不能存放重复的元素，可以添加一个null
//3.set接口对象存放数据是无序的--即添加的顺序和取出的顺序不一致
//4.注意：取出的顺序虽然不是添加的顺序，但是其是固定的，即放入和取出只会打乱一次，
// 并不是说同样的一组数据，取得第二次和第三次顺序不一样；
Set set = new HashSet();
set.add("bingo!!");
set.add("冲冲冲！！");
set.add("kerwin");
set.add("enjoy");
set.add(true);
set.add(null);
set.add(null);
System.out.println(set);
//输出 [null, bingo!!, 冲冲冲！！, enjoy, kerwin, true]
for (int i = 0; i < 5; i++) {
System.out.println(set);
}
//输出结果如下
/**
* [null, bingo!!, 冲冲冲！！, enjoy, kerwin, true]
* [null, bingo!!, 冲冲冲！！, enjoy, kerwin, true]
* [null, bingo!!, 冲冲冲！！, enjoy, kerwin, true]
* [null, bingo!!, 冲冲冲！！, enjoy, kerwin, true]
* [null, bingo!!, 冲冲冲！！, enjoy, kerwin, true]
* [null, bingo!!, 冲冲冲！！, enjoy, kerwin, true]
*/
}
常用方法
和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collecton接口一样
Set接口遍历方式（2种）
同Collection的遍历方式一样，因为Set接口是Collection接口的子接口
- 可以使用迭代器
- 增强for
- 不能使用索引的方式来获取
@SuppressWarnings({"all"})
public class Journey {
public static void main(String[] args) {
Set set = new HashSet();
set.add("bingo!!");
set.add("冲冲冲！！");
set.add("kerwin");
set.add("enjoy");
set.add(true);
set.add(null);
set.add(null);
//遍历--使用迭代器
System.out.println("================迭代器遍历===============");
Iterator iterator = set.iterator();
//此时要联想到迭代器的结构
while (iterator.hasNext()) {//判断还有没有下个元素
Object obj = iterator.next();
System.out.println(obj);
}
//输出结果如下
/**
* null
* bingo!!
* 冲冲冲！！
* enjoy
* kerwin
* true
*/
//遍历--增强for
System.out.println("=========增强for遍历===========");
for (Object o : set){
System.out.println("for->"+o);
}
//输出如下
/**
* for->null
* for->bingo!!
* for->冲冲冲！！
* for->enjoy
* for->kerwin
* for->true
*/
//set接口对象，不能通过索引来获取，所以无法用normal-for来循环获取
}
}
HashSet的全面说明
- HashSet实现了Set接口
- HashSet实际上是HashMap 源码如下：
public HashSet() {
map = new HashMap<>();
}
- HashSet可以存放null值，但是只能有一个null
- HashSet不保证元素是有序的，取决于Hash后，再确定索引的结果
- 不能有重复元素/对象；
import java.util.*;
@SuppressWarnings({"all"})
public class Journey {
public static void main(String[] args) {
Set hashSet = new HashSet();
hashSet.add(true);
hashSet.add(null);
hashSet.add(null);
System.out.println("存放了两个null,此时的hashSet为"+hashSet);
//存放了两个null,此时的hashSet为[null, true]
hashSet.add("bingo!!");
hashSet.add("冲冲冲！！");
hashSet.add("kerwin");
hashSet.add("enjoy");
System.out.println("不保证存入顺序和取出顺序一致哈");
System.out.println("此时的hashset"+hashSet);
//此时的hashset[null, bingo!!, 冲冲冲！！, enjoy, true, kerwin]
//顺便一提，在执行add方法之后，会返回一个boolean值
//如果添加成功，return true,else return false
System.out.println(hashSet.add("fulture"));//true
System.out.println(hashSet.add("kerwin"));//false
hashSet = new HashSet();
//此时是重置了hashSet引用的指向，让其指向一个新的空HashSet对象
System.out.println(hashSet);//[]
hashSet.add("lucky");
hashSet.add("lucky");//不能加进去
hashSet.add(new Dog("star"));//能加进去
hashSet.add(new Dog("star"));//能加进去
System.out.println("此时的hashset="+hashSet);
//此时的hashset=[lucky, star, star]
//注意，此时的两个star是同名的不一样的两只狗哈，
//再加深下理解，一道经典的面试题
hashSet.add(new String("K"));//能加进去
hashSet.add(new String("K"));//不能加进去
//之后，看源码，分析，就可以知晓缘由了
System.out.println(hashSet);
//[lucky, star, star, K] 只有一个K
}
}
@SuppressWarnings({"all"})
class Dog{//定义了一个Dog类
private String name;
public Dog(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
}
HashSet底层机制说明
说明：HashSet底层是HashMap，HashMap底层是数组+链表+红黑树
@SuppressWarnings({"all"})
public class Journey {
public static void main(String[] args) {
//模拟一个HashSet的底层（HashMap的底层结构）
//1.创建一个数组，数组的类型是Node[]
//2.有些人，直接把Node[] 数组称为表
Node[] table = new Node[16];
System.out.println("table = "+table);
//3.创建结点
Node john = new Node("john", null);
table[2]= john;
Node jack = new Node("jack",null);
john.next = jack;//将jack结点挂载到john 上
Node rose = new Node("Rose",null);
jack.next = rose;//将rose结点挂载到jack上
Node lucy = new Node("lucy", null);
table[3] = lucy;
System.out.println(table);
}
}
class Node{//结点，存储数据，可以指向下一个结点，从而形成链表
Object item;//存放数据
Node next;//指向下一个结点
public Node(Object item, Node next) {
this.item = item;
this.next = next;
}
}
此时的table内部结构如图所示
HashSet扩容机制剖析
- HashSet底层是HashMap
- 添加一个元素时，先得到hash值，会转化成索引值
- 找到存储数据表table,看这个索引位置是否已经存放了元素，如果没有，直接加入，如果有，则调用equals比较【这个equals程序员是可以自己重写的】，如果相同，就放弃添加，如果不相同，则添加到最后；
- 比如经过hash函数，kerwin字符串放到了2号索引处，再添加一个kerwin字符串，经过hash函数计算，还是会映射到2号索引处，那么此时调用equals比较，得出相同，则放弃添加，反之，第二次如果加的是个luck的字符串，同样被映射到了2号索引处，那么，此时再比较，发现不一样，则会将luck挂载到kerwin字符串的后面；
- 在Java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化（红黑树）
//以下剖析加进去一个元素“java”的整个流程
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("java");
hashSet.add("php");
hashSet.add("java");
System.out.println("set=" + hashSet);//set=[java, php]
}
//对HashSet的add方法的源码剖析，先加第一个字符串java
//先进入add方法内部，发现，执行put方法，继续进去
public boolean add(E e) {//E 是泛型，之后会讲的
//此中的key始终是随着你数据的添加再变化的，比如第一个事Java，第二个是php
return map.put(e, PRESENT)==null;
//PRESENT=(static) new Object(); 是可共享的哈
//最后最后看
//返回了个null,则二者一对比，返回true,说明可以塞元素进去，反之，如果不是null,则false
//说明你添加的这个元素已经存在了 整个流程看完，java才加进去
}
//这是深挖PRESENT源码发现其是一个新创建的Object对象 作为value
private static final Object PRESENT = new Object();
//进入put方法，发现其会先调用hash(),进去，之后再看下putVal方法
// 此中的value是add方法中创建，初始化的一个带有final static 的对象
// 其起初没有什么意义，用来占位，就是先统一在HashSet的value部分用这个PRESENT
// 来占位，即不管add多少次，key变化，但value始终是这个PRESENT
public V put(K key, V value) {//此时key="java" value=PRESENT
return putVal(hash(key), key, value, false, true);//这句最后也返回null给add()
}
//进入hash()方法内部，可以看到它是怎么hash的
//key不为空，则先得到key的hash值h，然后将其算术右移16位;
//这样做的目的是为了让不同的key尽量得到不同的哈希值，避免哈希碰撞
//hash值不是hashCode哈，是hashCode经过处理后的
// 通过hash(key),我们就得到了hash值，但其不等价于hashCode
// 还需要经过h= key.hashCode()^(h>>>16) 经过hashCode,再按位异或，将h算术右移16位
/**
假设 key.hashCode() 返回 -1299402055。
h >>> 16 是将 h 无符号右移 16 位。
计算结果为：49950。
计算按位异或 h ^ (h >>> 16)：
-1299402055 ^ 49950 = -1299451681
返回结果：
hashValue = -1299451681
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//接下来就到了源码的核心部分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语句表示如果当前table是null,或者大小=0，则说明是第一次扩容，到16
if ((tab = table) == null || (n = tab.length) == 0)
//table 就是hashMap的一个数组，类型是Node[],起初为null,于是进入resize()
//将resize()的结果交给tab,然后取长度length,赋给n
//可以往下跳着看resize()实现,其最后就会返回一个16
n = (tab = resize()).length;
//(1)这个if是根据你上面的key接下来计算其对应的hash值进而来计算该key应该存放在
// table表的哪一个索引位置，并把这个位置的对象，赋给辅助变量p
//(2)判断p是否为null
// 2.1如果p 为null,表示还没有存放过元素，就创建一个Node,把key,value一起
// 放进去，key是你当前存放的哪个元素，value就是之前提到的PRESENT
// Node(key="java", value=PRESENT)
// 2.2然后就放到该位置tab[i] = newNode(hash, key, value, null);
//此时返回去，查看变量tab空间情况，就会发现已经有个位置被放进去了元素"java"
//可以看到其hash值比如3254803，其value {Object@550},还有next为null
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;
//判断当前大小是否超过12，if yes
//再进入resize扩容，此时只加了一个元素，不用扩容
if (++size > threshold)
resize();
//底下这个方法是hashMap留给它的子类，eg LinkedHashMap去实现，再做些其他动作的
//而对于HashMap而言，其就是个空方法，原因在于让子类去重新实现它，比如形成个有序链表啊，
//挂在一个双向链表啊啥的 而设置的，对于HashMap，这个方法可以忽略
afterNodeInsertion(evict);
//接下来就返回个null，代表成功了，返回给put方法，其也返回个null
//如果不返回null,则return 其旧的值oldValue，可以往上瞅瞅
return null;
}
//进入resize(),
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//把起初的table赋给了oldTab
//起初为null,所以oldCap为0，然后往下走，进入if-else的第三个分支
//使得newCap为默认的初始化容量
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
//第一次是跳到了这儿，在这儿深挖下DEFAULT_INITIAL_CAPACITY
/**
将1左移4位，也就是连乘以4个2，即16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
*/
newCap = DEFAULT_INITIAL_CAPACITY;
//初始化了容量为16后，接下来又计算了一个临界值threshold（阈值）
//这里的临界值就是放元素到了什么程度会考虑扩容的一条划定线
//假设有16个空间，但hashSet是个未雨绸缪的人，它在容量到了75%时就会扩容
//即当放的元素到了16*0.75=12个时，它就扩容了
//它担心，余下的4个万一放不下之后万一一次性放进来的多个元素造成阻塞，so do it
//就是一个教室，50个座位，已经陆陆续续报到了45个人，那么班主任就会赶紧扩容
//二者的本质有点相似
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"})
//底下这句话是关键，执行完后，newTab就有了16个空间
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//newCap=16
//接下来就把newTab赋给了table
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;
}
}
}
}
}
//最后把newTab给返回，使得n=16
return newTab;
}
附上此时数组中加进去了第一个元素"java"字符串后的空间情况
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
