文章目录
课程视频：https://www.bilibili.com/video/BV1YA411T76k
Set接口和常用方法
基本介绍
-
无序（添加和取出的顺序不一致），没有索引
-
不允许重复元素，所以最多包含一个null
-
JDK API中Set接口的实现类有
set接口常用方法
和List接口一样，set接口也是Collection的子接口，因此，常用方法和Collection接口一样。
| Modifier and Type | Method and Description |
|---|---|
boolean | add(E e)如果指定的元素不存在，则将其指定的元素添加（可选操作）。 |
boolean | addAll(Collection<? extends E> c)将指定集合中的所有元素添加到此集合（如果尚未存在）（可选操作）。 |
void | clear()从此集合中删除所有元素（可选操作）。 |
boolean | contains(Object o)如果此集合包含指定的元素，则返回 true 。 |
boolean | containsAll(Collection<?> c)返回 true如果此集合包含所有指定集合的元素。 |
boolean | equals(Object o)将指定的对象与此集合进行比较以实现相等。 |
int | hashCode()返回此集合的哈希码值。 |
boolean | isEmpty()如果此集合不包含元素，则返回 true 。 |
Iterator<E> | iterator()返回此集合中元素的迭代器。 |
boolean | remove(Object o)如果存在，则从该集合中删除指定的元素（可选操作）。 |
boolean | removeAll(Collection<?> c)从此集合中删除指定集合中包含的所有元素（可选操作）。 |
boolean | retainAll(Collection<?> c)仅保留该集合中包含在指定集合中的元素（可选操作）。 |
int | size()返回此集合中的元素数（其基数）。 |
default Spliterator<E> | spliterator()在此集合中的元素上创建一个 Spliterator 。 |
Object[] | toArray()返回一个包含此集合中所有元素的数组。 |
<T> T[] | toArray(T[] a)返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。 |
set接口的遍历方式
同Collection的遍历方法一样，因为set接口是Collection接口的子接口。
- 可以使用迭代器
- 增强for
- 不能使用索引的方式遍历
// 以set接口的实现子类 HashSet举例 set接口方法
/*
1. set接口的实现类（Set接口对象），不能存放重复的元素，可以添加一个null
2. set接口对象存放的数据是无序的（即添加的顺序和取出的顺序不一致）
3. 注意：取出的顺序虽然不是添加的顺序，但是它是固定的。
*/
Set set = new HashSet();
set.add("1");
set.add("2");
set.add("3");
set.add("3");//重复
set.add("4");
set.add("100");
set.add(null);
set.add(null);//重复添加null
System.out.println(set);//[null, 1, 100, 2, 3, 4]
//遍历(两种方式)
//1. 迭代器
System.out.println("====迭代器遍历");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
//2. 增强for遍历, 本质就是迭代器
System.out.println("====增强for遍历");
for (Object o : set) {
System.out.println(o);
}
//set接口对象，不能通过索引来获取，无法使用普通for循环遍历
Set实现类–HashSet
基本介绍
-
HashSet 实现了Set接口
-
HashSet 实际上是HashMap（源码如下）
public HashSet() { map = new HashMap<>(); } -
可以存放null值，但是只能有一个null
-
HashSet不保证元素是有序的，取决于hash值，再确定索引的结果
-
不能有重复元素/对象
//1. HashSet 实际上是HashMap
HashSet hashSet = new HashSet();
/* 默认构造器源码
public HashSet() {
map = new HashMap<>();
}
*/
//2. 可以存放null值，但是只能有一个null
hashSet.add(null);
hashSet.add(null);
System.out.println(hashSet);
HashSet set = new HashSet();
//1.在执行add方法后，会返回一个boolean值
//2.如果添加成功，返回true，否则返回false
//3.可以通过remove指定删除哪个对象
System.out.println(set.add("Tom")); // true
System.out.println(set.add("Mike")); // true
System.out.println(set.add("john")); // true
System.out.println(set.add("Tom")); // false
System.out.println(set.add("Jerry")); //true
set.remove("Tom");
System.out.println(set);//[Mike, john, Jerry]
set = new HashSet();
//hashSet 不能添加相同的元素/数据
set.add("lucy"); // true
set.add("lucy"); // false
set.add(new Cat("tom")); //true
set.add(new Cat("tom")); //true
System.out.println(set);//[Cat{name='tom'}, Cat{name='tom'}, lucy]
//经典面试题
System.out.println(set.add(new String("kobe")));//true
System.out.println(set.add(new String("kobe")));//false
System.out.println(set);//[kobe, Cat{name='tom'}, Cat{name='tom'}, lucy]
HashSet底层机制
HashSet 底层是HashMap，HashMap底层是（数组+链表+红黑树）
相较数组存储效率高
代码实现
//模拟一个HashSetMap的底层(HashMap的底层结构)
//1.创建一个数组，数组的类型是Node[]
//2.有些人，直接把Node[]数组称为表
Node[] table = new Node[16];
//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;//将roes结点挂载到jack后
Node lucy = new Node("lucy", null);
table[3] = lucy;
System.out.println(table);
存储结构
源码分析
HashSet的add方法
- HashSet 底层是 HashMap
- 添加一个元素时，先得到hash值 会转成 -> 索引值，（不是hashcode，是hashcode经过相关运算得到hash值）
- 找到存储数据表table，看这个索引位置是否已经存放的有元素
- 如果没有，直接加入
- 如果有，调用equals() 比较， 如果相同，就放弃添加，如果不相同，则添加到最后
- 在 java8 中，如果一条链表的元素个数大于等于TREEIFY_THRESHOLD（默认是8），并且table的大小 >= MIN_TREEIFY_CAPCAITY（默认64），就会进行树化（红黑树）
HashSet hashSet = new HashSet();
hashSet.add("java");
hashSet.add("php");
hashSet.add("java");
System.out.println("haseSet="+hashSet);
/*
1. 执行Hashset()
public HashSet() {
map = new HashMap<>();
}
2. 执行hashSet.add()
public boolean add(E e) { //e="java"
return map.put(e, PRESENT)==null;//private static final Object PRESENT = new Object();
}
3. 执行put方法
public V put(K key, V value) {//key = "java" , value = PRESENT (静态)
return putVal(hash(key), key, value, false, true);
}
4. hash(key)方法，得到key对应的一个”hash值“，但不是hashcode！
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//>>>无符号右移16位
}
5. 执行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; //定义了辅助变量
//table 就是HashMap 的一个数组，类型是Node[]
//if语句标识如果当前table是null或者大小为0
//第一次扩容，空间大小为16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;//resize():扩容，第一次生成Node[16],数组扩展的阈值为0.75*16=12
//(1)根据key，得到hash去计算该key应该存放到table表的哪个索引位置
//并把这个位置的对象，赋给p
//(2)判断这个p是否为空
//(2.1)如果p为null
//如果p为null，标识还没有存放元素，就创建一个Node(key=”java“，value=PRESENT)
//就放在该位置tab[i] = newNode(hash, key, value, null);
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//开发技巧：在需要辅助变量或者局部变量的时候再创建
//2.2如果p不为null
Node<K,V> e; K k;
//2.2.1 假如数组位置的元素与key（相同）
//如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
//并且满足 （准备加入的key和p指向的Node结点的key相同） 或（key动态绑定的equals()方法为真）
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//2.2.2 判断p是不是红黑树结点
// 调用putTreeVal方法添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//2.2.3 假如是链表
// 顺次比较链表的每一个元素是否相同(和2.2.1比较方法相同)，都不相同加在最后一个位置，相同就break
// 注意在把元素添加到链表后，立即判断，该链表是否到达8个结点，就调用treeifyBin对链表进行树化（转成红黑树）
// 注意，在转成红黑树时，要进行判断，判断条件：tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY（默认64）
//上述条件成立，先table扩容，否则不成立才转成红黑树
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;
}
}
//3 判断是否存在
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//size 就是我们每加入一个结点Node(k,v,h,next),size++,不论是加在数组还是链表
if (++size > threshold)
resize();//扩容
afterNodeInsertion(evict);//空方法，给HashMap子类去实现
return null;
}
*/
HashSet扩容机制
- HashSet 底层是HashMap，第一次添加时，table数组扩容到16，临界值（threshold）是 16 * 加载因子（loadFactor）是0.75 = 12
- 如果table数组使用到了临界值12，就会扩容到 16 * 2 = 32，新的临界值就是 32*0.75 = 24，依次类推
- 在Java8中，如果一条链表的元素个数到 TREEIFY_THRESHOLD（默认是8），并且table的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树），否则仍然采用数组扩容机制
注意：
- 每添加一个元素（包括在table表，与表中链表）即添加一个节点，会执行一次 ++size，当size > threshold 时就会执行扩容。
- table表扩容并不是表的16个大小被添加完才执行，当所有元素的个数大于临界值时就会执行扩容。
具体可以查看博客 https://blog.csdn.net/weixin_39667787/article/details/86678215
代码实践
题目描述：
定义一个Eeployee类，该类包括：private成员属性name,age
- 创建3个Employee对象放入 HashSet中
- 当 name和age的值相同时，认为是相同员工，不能添加到HashSet集合中
关键：重写hashCode()与equals()方法
快捷键：Alt+Insert => equals() and hashCode() => 选择相应的参数
public class Demo17_HashSetExercise {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add(new Employee("jack", 18));
hashSet.add(new Employee("mike", 28));
hashSet.add(new Employee("jack", 18));
System.out.println(hashSet);//[Employee{name='mike', age=28}, Employee{name='jack', age=18}]
}
}
class Employee
{
String name;
int age;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return age == employee.age && Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Set实现类–LinkedHashSet
基本介绍
- LinkedHashSet 是 HashSet的子类
- LinkedHashSet 底层是一个LinkedHashMap，底层维护了一个 数组 + 双向链表
- LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存得。
- LinkedHashSet 不允许添加重复元素
说明：
- 在LinkedHashSet中维护了一个hash表和双向链表（LinkedHashSet 有 head和tail）
- 每一个节点有 before和after属性，这样可以形成双向链表
- 在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表（如果已经存在，不添加【原则和hashset一样】）
- 这样遍历LinkedHashSet 也能确保插入顺序和遍历顺序一致
源码分析
public class Demo19_LinkedHashSet_Source {
public static void main(String[] args) {
LinkedHashSet set = new LinkedHashSet();
set.add(new String("AA"));
set.add(456);
set.add(456);
set.add(new Customer("刘",1001));
set.add(123);
set.add("kobe");
for (int i = 0; i < 100; i++) {
set.add(new Customer("kobe",24));
}//也会树化 parent、left、right
System.out.println(set);
//1. LinkedHashSet 加入顺序和遍历顺序一致
//2. LinkedHashSet 底层是一个LinkedHashMap(是hashMap的子类)
//3. LinkedHashSet 底层结构(数组table+双向列表)
//4. 添加第一次时，直接将数组table扩容到16，存放的结点类型 LinkedHashMap$Entry
//5. 数组是HashMap$Node[] , 存放的元素/数据是 LinkedHashMap$Entry 类型
/*
//继承关系是在内部类完成 ， 都是静态内部类
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
*/
}
}
class Customer{
private String name;
private int no;
public Customer(String name, int no) {
this.name = name;
this.no = no;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", no=" + no +
'}';
}
@Override
public int hashCode() {
return 1;
}
}
树化后的结点结构
Set实现类–TreeSet
基本介绍
- 不允许添加重复元素，不允许添加 null，不允许添加
- 无序（没有按照输入顺序进行输出）
- 遍历结果有顺序
- 底层为排序二叉树(红黑树)，且采用中序遍历得到结果 （左节点，根节点，右节点）
源码分析
public class Demo_TreeSet {
public static void main(String[] args) {
//TreeSet treeSet = new TreeSet();
//使用匿名内部类实现Comparator接口，并重写compare方法，指定排序方法
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length() - ((String)o2).length();
}
});
//添加数据
treeSet.add("jack");
treeSet.add("tom");
treeSet.add("sp");
treeSet.add("abc");//tom 和 abc 长度相等，key相等，添加失败
System.out.println(treeSet);//[sp, tom, jack]
//1.当我们使用无参构造器时，创建TreeSet时,底层默认创建TreeMap
/*
public TreeSet() {
this(new TreeMap<E,Object>());
}
*/
//TreeMap 如果使用默认构造函数，要求key是实现了Comparable接口的，并且使用key的compareTo方法比较，
//也就是说仍然按照key排序，如果key没有实现Comparable方法就会报错
/*
String类实现了Comparable接口，重写了compareTo方法：按升序排序,首字母先比较，相等再用第二个字母，以此类推
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
}
*/
//2.上面的的代码实现了添加元素按照字符串长度来排序
//3.
/*
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;//传入的比较器
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);//动态绑定到我们的comparator
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);//如果比较器比较结果相同，更改value，不更改key
//TreeSet的value是类,private static final Object PRESENT = new Object();
} while (t != null);
}
else {
//如果使用默认构造函数，即没有比较器对象
//要求key是实现了Comparable接口的，并且使用key的compareTo方法比较，
if (key == null)//key不能为空
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
//要求key是实现了Comparable接口的
do {
parent = t;
cmp = k.compareTo(t.key);//使用key的compareTo方法比较
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);//加入后红黑树旋转
size++;
modCount++;
return null;
}
*/
treeSet = new TreeSet();
treeSet.add(new C(1));
treeSet.add(new C(2));
treeSet.add(new C(1));
System.out.println(treeSet);
}
}
class C implements Comparable<C>{
int num;
public C(int num) {
this.num = num;
}
public int compareTo( C c) {
return this.num - c.num;
}
@Override
public String toString() {
return "C{" +
"num=" + num +
'}';
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
