Java集合
集合的基本框架
单列集合Collection
双列集合Map
package com.集合;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Collection_ {
public static void main(String[] args) {
//Collection 接口有两个重要的子接口 List Set,他们的实现子类都是单列集合
List list = new ArrayList();
list.add("jack");
list.add(true);
//Map 接口的实现子类 是双列集合,存放的是 Key-Value
HashMap hashMap = new HashMap();
hashMap.put("No1","北京");
hashMap.put("No2","上海");
}
}
Collection接口和常用方法
- Collection实现子类可以存放多个元素,每个元素可以是Object
- 有些Collection的实现类,可以存放重复的元素,有些不可以
- 有些Collection的实现类,有些是有序的(List),有些不是有序的(Set)
- Collection接口没有直接的实现子类,是通过它的子接口Set和List来实现的
Collection接口常用方法
以实现子类ArrayList来演示
package com.集合.collection;
import java.util.ArrayList;
import java.util.List;
public class CollectionMethod {
@SuppressWarnings("all")
public static void main(String[] args) {
List list = new ArrayList();
// add:添加单个元素
list.add("jack");//list.add其实是添加了一个个对象,不再是一个个字符串,数字的基本数据类型了
list.add(10);//相当于是list.add(new Integer(10))
list.add(true);
System.out.println("list="+list);
// remove:删除指定元素
list.remove(0);//通过下标,删除第一个元素
list.remove(true);//删除指定元素
System.out.println("list"+list);
// contains:查找指定元素是否存在
System.out.println(list.contains("jack~"));
// size:获取元素个数
System.out.println(list.size());
// isEmpty:判断是否为空
System.out.println(list.isEmpty());
// clear: 清空
list.clear();
// addAll:添加多个元素 只要是实现了Collection的对象都可以作为参数传入
ArrayList list2 = new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
list.addAll(list2);
System.out.println("list"+list);
// containsAll:查找多个元素是否都存在
System.out.println(list.containsAll(list2));
// removeAll:删除多个元素
list.add("西游记");
list.removeAll(list2);
System.out.println("list"+list);
}
}
Collection接口遍历元素方式1——使用Iterator(迭代器)
-
Iterator对象称为迭代器,主要用于遍历Collection集合中的元素(Iterator在Collection的父类Iterable类中)
-
所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器
-
Iterator的结构
-
Iterator仅用于遍历集合,Iterator本身并不存放对象
package com.集合.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionIterator {
@SuppressWarnings("ALL")
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",5.1));
col.add(new Book("红楼梦","曹雪芹",34.6));
//遍历col集合
//1.先得到 col对应的迭代器
Iterator iterator = col.iterator();
//2.使用while循环遍历
while (iterator.hasNext()){ //判断是否还有数据
Object obj = iterator.next();//返回下一个元素,类型是Object
System.out.println("obj="+obj);
}
//快速生成 迭代器的while结构 => 使用快捷键 itit
//显示所有的快捷键的 快捷键是 ctrl + j
//3.当退出这个while循环后,这时iterator迭代器,指向最后的元素
//调用 iterator.next() 会报 NoSuchElementException的异常
//4.如果希望再次遍历,需要重置我们的迭代器
iterator = col.iterator();
}
}
class Book{
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
}
Collection接口遍历元素方式2——增强for循环
package com.集合.collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionFor {
@SuppressWarnings("all")
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",5.1));
col.add(new Book("红楼梦","曹雪芹",34.6));
for (Object book : col) { //快捷键 iter 或者 I
System.out.println("book="+book);
}
//增强for循环,既可以用于数组,也可以用于Collection集合
//增强for循环的底层,仍是迭代器,可下断点调试发现
}
}
List接口方法和常用方法
List接口基本介绍
- List接口是Collection接口的子接口
- List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
- List集合中的每个元素都有其对应的顺序索引,即支持索引
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素
- JDK API中List接口的实现类不止:ArrayList、LinkedList和Vector,这几个是常用的
package com.集合.list_;
import java.util.ArrayList;
import java.util.List;
public class List_ {
@SuppressWarnings("ALL")
public static void main(String[] args) {
//1.List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
List list = new ArrayList();
list.add("jack");
list.add("tom");
list.add("mary");
list.add("jack");
System.out.println("list="+list);//list=[jack, tom, mary, jack]
//2.List集合中的每个元素都有其对应的顺序索引,即支持索引
//索引是从0开始的
System.out.println(list.get(3));//jack
}
}
List接口方法
package com.集合.list_;
import java.util.ArrayList;
import java.util.List;
public class ListMethod {
public static void main(String[] args) {
List list = new ArrayList();//将ArrayList()换为 LinkedList/Vector,这些方法都是通用的
list.add("张三丰");
list.add("贾宝玉");
//1.void add(int index, Object element); 在index位置插入ele对象
//在index = 1的位置插入一个对象
list.add(1,"刘备");
System.out.println("list="+list);//list=[张三丰, 刘备, 贾宝玉]
//2.boolean addAll(int index, Collection c); 从index位置开始将c中的所有对象加进来
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1,list2);
System.out.println("list="+list);//list=[张三丰, jack, tom, 刘备, 贾宝玉]
//3.int indexOf(Object obj); 返回obj在集合中第一次出现的位置
System.out.println(list.indexOf("tom"));//2
//4.int lastIndexOf(Object obj); 返回obj在集合中最后一次出现的位置
list.add("tom");
System.out.println(list.lastIndexOf("tom"));//5
//5.Object remove(int index); 移除指定index位置的元素,并返回此元素
list.remove(0);
System.out.println("list="+list);//list=[jack, tom, 刘备, 贾宝玉, tom]
//6.Object set(int index, Object element); 设置指定index位置的元素为element,相当于替换
list.set(1,"玛丽");
System.out.println("list="+list);//list=[jack, 玛丽, 刘备, 贾宝玉, tom]
//7.List subList(int fromIndex, int toIndex); 返回从fromIndex到toIndex位置的子集合
List returnlist = list.subList(0,2);//左闭右开
System.out.println("returnlist="+returnlist);//returnlist=[jack, 玛丽]
}
}
List的三种遍历方式
- 方法一:使用iterator
- 方法二:使用增强for循环
- 方法三,使用普通for(前面两种在上面演示过了,我们来看第三种也很简单)
for (int i = 0; i < list.size(); i++) {
System.out.println("对象="+list.get(i));
}
ArrayList底层结构和源码分析
ArrayList注意事项
- ArrayList可以加入多个null值
ArrayList arrayList = new ArrayList();
arrayList.add(null);
arrayList.add("jack");
arrayList.add(null);
System.out.println(arrayList);//[null, jack, null]
- ArrayList是由数组来实现数据存储的
- ArrayList基本等同于Vector,ArrayList是线程不安全的(源码中的方法并无 synchronized修饰),但是执行效率高,在多线程的情况下,不建议使用ArrayList
ArrayList的底层操作机制源码分析(重点、难点)
- ArrayList中维护了一个Object类型的数组 elementData
- transient Object[ ] elementData
- transient (瞬间、短暂的) 表示该属性不会被序列化
- 当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData容量为0,第一次添加。则扩容elementData为10.如需再次扩容,则扩容成现在elementData容量的1.5倍
- 如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容成现在elementData容量的1.5倍
示例:
package com.集合.list_;
import java.util.ArrayList;
@SuppressWarnings("all")
public class ArrayListSource {
public static void main(String[] args) {
ArrayList list = new ArrayList(); //无参构造的情况
//ArrayList arrayList = new ArrayList(8); //有参构造的情况
for (int i = 1; i <= 10; i++) {
list.add(i);
}
for (int i = 11; i <= 15 ; i++) {
list.add(i);
}
list.add(100);
list.add(200);
list.add(null);
}
}
-
第一步: ArrayList list = new ArrayList();
无参构造函数:
获得一个空的Object类型的数组:DEFAULTCAPACITY_EMPTY_ELEMENTDATA
- 第二步:list.add(i);
add方法: 先确定是否要扩容,然后再执行赋值
- 确定elementData的容量:
- 计算elementData的容量:如果elementData是DEFAULTCAPACITY_EMPTY_ELEMENTDATA即新创建出来的,在默认的 DEFAULT_CAPACITY(等于10)与 minCapacity之间返回最大值。
如果elementData不是默认的空数组,直接返回minCapacity
- 判断是否扩容: modCount进行计数当前这个集合被修改的次数,如果有多线程修改这个值,则会抛出异常
这里将 minCapacity 与 elementData的实际长度进行比较,判断是否扩容
- 进行扩容 grow(minCapacity): int newCapacity = oldCapacity + (oldCapacity >> 1); >>1位运算,右移一位
(oldCapacity >> 1) 右移一位相当于,oldCapacity除以2,这里实现扩容为原来的1.5倍
扩容使用的是 Arrays.copuOf()
有参构造函数的情况:
创建了一个指定大小的elementData数组,在add中elementData就不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA,会直接返回minCapacity(这里的minCapacity可以理解为已占的空间+即将需要的1个空间)
Vector底层结构和源码分析
Vector的基本介绍
- Vector类的定义说明
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
- Vector底层也是一个对象数组 protected Object[ ] elementData
- Vector是线程同步的,即线程安全,Vector类的操作方法带有synchronized
- 在开发中,需要线程同步安全时,考虑使用Vector
Vector和ArrayList的比较
底层结构 | 版本 | 线程安全(同步)效率 | 扩容倍数 | |
---|---|---|---|---|
ArrayList | 可变数组 | jdk1.2 | 不安全,效率高 | 如果是无参构造时,1.第一次10,2.第二次开始按1.5倍扩容;如果有参构造不足时扩容1.5倍 |
Vector | 可变数组 | jdk1.0 | 安全,效率不高 | 如果是无参构造时,1.默认为10,2.第二次开始按2倍扩容;如果有参,不足时按2倍扩容 |
Vector的底层操作机制源码分析
- 第一步:无参构造器:
直接调用有参构造器,并指定容量大小为10
- 第二步:add()方法中,确定是否要扩容
- ensureCapacityHelper( )
-
判断确实需要扩容了:grow( ) , capacityIncrement这里实现了扩容两倍,capacityIncrement在上面的构造函数中被初始化
LinkedList底层结构和源码分析
LinkedList的简单介绍
- LinkedList底层实现了双向链表和双端队列特点
- 可以添加任意元素(元素可以重复),包括null
- 线程不安全,没有实现同步
LinkedList的底层操作机制
-
LinkedList底层维护了一个双向链表
-
LinkedList中维护了两个属性first和last分别指向 首节点和尾节点
-
每个节点(Node对象),里面维护了 prev 、next、item三个属性,其中通过prev指向前一个,通过next指向后一个节点,最终实现双向链表
-
所以LinkedList的元素的添加和删除,不是通过数组完成的,相对来说效率较高。
- 第一步:
无参构造器创建一个空的列表,此时 first为null,last也是null
-
执行add方法:
-
首先拿到尾节点last赋给 l ,新建一个node节点,将node的前驱节点指向 l ,后驱节点设为null,则此时 last节点 即为新建的node节点
-
此时判断前一个节点 l ,l=null是初始的情况下,会将 first 和 last 都指向新建的node,在第二次及以后的时候则会走else,将前一个节点 l 的next 指向新建的这个节点node,至此形成一个双向链表
- 因为LinkedList是实现了List接口,在list中提到的 remove删除,set修改,get按索引得到对象,几种遍历方式都可以使用。
LinkedList和ArrayList的比较
底层结构 | 增删的效率 | 改查的效率 | |
---|---|---|---|
ArrayList | 可变数组 | 较低,通过数组扩容 | 较高 |
LinkedList | 双向链表 | 较高,通过链表追加 | 较低 |
如何选择ArrayList和LinkedList:(LinkedList和ArrayList都是线程不安全的)
- 如果我们改查的操作多,选择ArrayList
- 如果我们增删的操作多,选择LinkedList
- 一般来说,在实际开发中,大部分操作都是查询,因此大部分情况下会选择ArrayList
- 在一个项目中,根据业务灵活选择,也可能,一个模块使用的是ArrayList,另一个模块是LinkedList。
Collections工具类
工具类方法1
package com.集合.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
@SuppressWarnings("ALL")
public class Collections_ {
public static void main(String[] args) {
//创建ArrayList集合,用于测试
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("milan");
//reverse(List):反转List中元素的顺序
Collections.reverse(list);
System.out.println(list);//[milan, king, smith, tom]
//shuffle(List):对List集合元素进行随机排序
Collections.shuffle(list);//每次排序顺序都不一样
//sort(List):根据元素的自然排序对指定的List集合元素按升序排列
Collections.sort(list);
System.out.println(list);//[king, milan, smith, tom]
//sort(List,Comparator) 根据指定的Comparator产生的顺序对List集合进行排序
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o2).length()-((String)o1).length();
}
});
System.out.println(list);//[milan, smith, king, tom]
//swap(List list,int i,int j):将指定list集合中的i处元素和j处元素进行交换
Collections.swap(list,0,1);
System.out.println(list);//[smith, milan, king, tom]
}
}
工具类方法2
package com.集合.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@SuppressWarnings("all")
public class Collections2_ {
public static void main(String[] args) {
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("milan");
list.add("tom");
//Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
System.out.println("自然排序中的最大元素是"+ Collections.max(list));//自然排序中的最大元素是tom
//Object max(Collection,Comparator)也可自定义排序方法
//Object min(Collection)
//Object min(Collection,Comparator):同上max中的示例
//int frequency(Collection,Object):返回指定集合中指定元素的出现次数
System.out.println("tom出现的次数="+Collections.frequency(list,"tom"));//tom出现的次数=2
//void copy(List dest,List src):将src中的内容复制到dest中
ArrayList dest = new ArrayList();
//为了完成一个完整的拷贝,我们需要献给dest赋值,大小和list.size()一样
for (int i = 0; i < list.size(); i++) {
dest.add("");
}
Collections.copy(dest,list);
System.out.println("dest="+dest);//dest=[tom, smith, king, milan, tom]
//boolean replace(List list,Object oldVal,Object newVal):使用新值替换List中所有的旧值
Collections.replaceAll(list,"tom","汤姆");
System.out.println(list);//[汤姆, smith, king, milan, 汤姆]
}
}
Set接口和常用方法
- 无序(添加和取出的顺序不一致),没有索引
- 不允许重复元素,所以最多包含一个null
- JDK API中Set接口的实现类不止:HashSet、TreeSet这两个是最常用的
Set接口的常用方法
和List接口一样,Set接口也是Collection的子接口,因此,常用方法和Collection接口一样
Set接口的遍历方式
同Collection的遍历方式一样(两种),因为Set接口是Collection接口的子接口
- 可以使用迭代器
- 增强for循环
- 不可以使用索引的方式来获取,因为根本就没有索引
HashSet
HashSet的全面说明
-
HashSet实现了Set接口
-
HashSet实际上是HashMap
-
HashSet可以存放null值,但是只能有一个null
-
HashSet不保证元素是有序的,取决于hash后,再确定索引的结果(不能保证添加和取出的顺序一致)
-
不能有重复元素/对象,在前面Set接口使用已经讲过
package com.集合.set_;
import java.util.HashSet;
@SuppressWarnings("all")
public class HashSet01 {
public static void main(String[] args) {
HashSet set = new HashSet();
//HashSet不能添加相同的元素/数据?
set.add("lucy");//添加成功,在执行add方法后,会返回一个boolean值,添加成功返回true
set.add("lucy");//添加不了
set.add(new Dog("tom"));//ok
set.add(new Dog("tom"));//ok
System.out.println("set="+set); //set=[Dog{name='tom'}, Dog{name='tom'}, lucy]
//面试题
set.add(new String("zmc"));//添加成功
set.add(new String("zmc"));//加入不了,请看下面分析源码
}
}
class Dog{
private String name;
public Dog(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
'}';
}
}
HashSet底层机制说明
HashSet的底层是HashMap,HashMap底层是(数组+链表+红黑树)
模拟数组+链表的结构
package com.集合.set_;
@SuppressWarnings("all")
public class HashSetStructure {
public static void main(String[] args) {
//模拟一个HashSet的底层 (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;
Node rose = new Node("Rose",null);
jack.next=rose;
System.out.println("table="+table);
}
}
class Node{//结点,存储数据,可以指向下一个节点,从而形成链表
Object item;//存放数据
Node next;//指向下一个节点
public Node(Object item, Node next) {
this.item = item;
this.next = next;
}
}
HashSet扩容机制(hash()+equals())
- 添加一个元素的时候,会先得到hash值—> 转成索引值
- 找到存储数据库表table,看这个索引位置是否已经存放元素
- 如果没有,直接加入
- 如果有,调用equals比较,如果相同,就放弃添加,如果不相同,则添加到最后
- 在Java8中,如果一条链表的元素个数 >= TREEIFY_THRESHOLD(默认是8),并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树)
- 如果table数组使用到了临界值12,就会扩容到16*2=32,新的临界值就是32 *0.75=24,依次类推,每次扩容两倍
源码分析:
HashSet set = new HashSet();
set.add("java");
set.add("php");
set.add("java");
第一步:进入HashSet的构造函数
第二步:执行add( )方法
第三步:进入HashMap的put方法
key的值是传入的"java" value=PRESENT
(PRESENT在HashMap类中,是为了从HashSet转到HashMap,起到占位作用)
第四步:hash( )计算索引值,按位异或
第五步:紧接第三步进入 putVal( )源码
/**
* Implements Map.put and related methods.
*
* @param hash - hash for key
* @param key - the key
* @param value - the value to put
* @param onlyIfAbsent - if true, don't change existing value
* @param evict - if false, the table is in creation mode.
* @Returns previous value, or null if none
*/
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
//tab=resize()就是第一次扩容,到16个空间,可见下面resize()源码
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(1)根据key的hash值 进行(n - 1) & hash (&的意思是与,两个位都为1时,结果才为1),去计算该key应该存放到table表中的哪一个索引位置
//并把这个位置的对象,赋给p
//(2)判断p是否为null
//(2.1)如果p为null,表示还没有存放元素,就创建一个Node(key="java",value=PRESENT),并放在tab[i]这个位置
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 &&//如果当前索引位置对应链表的第一个元素和准备添加的key的hash值一样
//并且满足下面两个条件之一:
//准备加入的key和p指向的Node节点的key是同一个对象
//p指向的Node节点的key的equals()和准备加入的key比较后相同
//此时就不能加入,对于上面的Dog对象,equals并未重写,两个对象是不一样的,对于String对象,重写了equals方法,比较的是两个字符串是否相等,因此不添加
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//再判断p是不是一颗红黑树,如果是就调用putTreeVal来添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {//这种情况下,table对应的位置,已经是一个链表,就使用for循环比较
//(1)依次和该链表的每一个元素依次比较
//(2)如果有相同的情况,就直接break不添加了,如果没有,加入到链表的最后
//(3)注意在把元素添加到链表后,立即判断当前这个链表是否已达到8个结点,就调用treeifyBin()当前这个链表进行树化(转成红黑树)
//注意:在就调用treeifyBin()中还会判断MIN_TREEIFY_CAPACITY,即表的长度有没有达到64,否则会先进行扩容表长,当上述这两个条件都满足时,才会转成红黑树
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;
//size就是我们每加入一个节点Node(k,v,h,next),size就++
if (++size > threshold)//threshold是下面resize()第一次进入算出的12,大于这个值会进行扩容,而且注意!!!,扩容时并不是看table表上有12个位置上有12条链表时才会扩容,而是链表上的节点个数,即这里的size大小,达到12个以上就会扩容
resize();//除第一次初始化,以后都在这里进行真正的扩容
afterNodeInsertion(evict);//空,HashMap留给子类去实现其他功能
return null;
}
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @Returns the table
*/
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;//默认的初始容量16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
//DEFAULT_LOAD_FACTOR是负载因子为0.75,默认初始容量为16,当容量变为0.75*16=12个时,就会进行扩容,而不是等待 16个位置全被占满了才进行扩容
}
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;
}
HashSet练习
package com.集合.set_;
import java.util.HashSet;
import java.util.Objects;
@SuppressWarnings("all")
public class HashSetExercise {
public static void main(String[] args) {
/*
* 定义一个Employee类,该类包含:private成员属性name,age要求:
* 创建3个Employee对象放入HashSet中
* 当name和age的值相同时,认为是相同员工,不能添加进
* */
HashSet set = new HashSet();
set.add(new Employee("milan",18));//OK
set.add(new Employee("lucy",20));//OK
set.add(new Employee("milan",18));//hashcode相同,table索引一致找到同一个链表上,equals比较,发现这个对象的name和age与之前的相同,添加不进去
System.out.println(set);//[Employee{name='milan', age=18}, Employee{name='lucy', age=20}]
}
}
class Employee{
private String name;
private int age;
public Employee(String name, int age) {
this.name = name;
this.age = 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;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + 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);
}
}
LinkedHashSet
LinkedHashSet的全面说明
- LinkedHashSet是HashSet的子类
- LinkedHashSet底层是一个LinkedHashMap,底层维护了一个 数组+双链表
- LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序,这使元素看起来是以插入顺序保存的
- LinkedHashSet不允许添加重复的元素
LinkedHashSet底层机制说明
-
在LinkedHashSet中维护了一个hash表和一个双向链表
-
每一个节点都有before和after属性,这样可以形成双向链表
-
在添加一个元素时,先求hash值,再求索引,确定该元素在table中的位置,然后将添加的元素加入到双向链表(如果存在,则不添加)
tail.next = newElement newElement.pre = tail tail = newEelment
-
这样的话,我们遍历LinkedHashSet也能确保插入顺序和遍历顺序一致
源码分析
第一步:LinkedHashSet底层维护的是一个LinkedHashMap(是HashMap的子类)
第二步:添加第一次时,直接将数组table扩容到16,存放的节点类型时 LinkedHashMap$Entry
数组的存放类型是HashMap N o d e [ ] 存 放 的 元 素 / 数 据 是 L i n k e d H a s h M a p Node[ ] 存放的元素/数据是 LinkedHashMap Node[]存放的元素/数据是LinkedHashMapEntry类型
果然 Entry继承于HashMap里的Node类(静态内部类)
第三步:进入add方法:
发现进入还是HashSet的add方法,与上述的HashSet一致,实际上呢又是进入了HashMap的那一套方法中
Map接口和常用方法
这里讲的是JDK8的Map接口特点
- Map和Collection并列存在,用于保存具有映射关系的数据:Key-Value
- Map中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中
- Map中的key不允许重复, 原因和HashSet一样,当有相同的k时,新的value值会替换之前的value值
- Map中的value可以重复
- Map的key可以为null,value也可以是null,注意key为null,只能有一个,value为null可以有多个
- 常用String类作为Map的 key
- key和value之间存在单向一对一的关系,即通过指定的 key总能找到对应的value
- Map存放一对 k-v 是放在一个**HashMap N o d e ∗ ∗ 中 的 , 又 因 为 H a s h M a p Node**中的,又因为HashMap Node∗∗中的,又因为HashMapNode实现了Entry接口,有些书上也说 一对 k-v 就是一个Entry
下面具体解释一下上述的最后一点特性:
1.Node是HashMap中的一个静态内部类
2.同时我们发现Node实现了 Map.Entry的接口
3.k-v最后是放在了 HashMap$Node node = newNode(hash, key, value, null) 中
4.k-v为了方便遍历,还会创建EntrySet集合,该集合存放的元素类型为Entry,而一个Entry对象中就有k-v
EntrySet<Entry<K,V>>,即:Set<Map.Entry<K,V>> entrySet
5.实际上是让Set<Map.Entry<K,V>>中的K,指向HashMap N o d e 中 的 K e y , S e t < M a p . E n t r y < K , V > > 中 的 V , 指 向 H a s h M a p Node中的Key,Set<Map.Entry<K,V>>中的V,指向HashMap Node中的Key,Set<Map.Entry<K,V>>中的V,指向HashMapNode中的Value
6.看下面,entrySet(Set<>)中,定义的类型是 Map.Entry,但实际上存放的还是HashMap N o d e , 因 为 这 里 做 了 一 个 向 上 转 型 , 因 为 H a s h M a p Node,因为这里做了一个向上转型,因为HashMap Node,因为这里做了一个向上转型,因为HashMapNode实现了Map.Entry<K,V>的接口,他们两者是存在关系的,所以实际的运行类型是HashMap$Node
Map map = new HashMap();
map.put("no1","zmc");
map.put("no2","张无忌");
Set set = map.entrySet();
System.out.println(set.getClass());//class java.util.HashMap$EntrySet
for (Object entry : set) {
System.out.println(entry.getClass());//class java.util.HashMap$Node
}
7.当把HashMap$Node对象存放到entrySet中,就方便我们的遍历,因为Map.Entry 提供了重要方法 getKey( )与getValue( );
Map接口方式
package com.集合.map_;
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings("all")
public class MapMethod {
public static void main(String[] args) {
Map map = new HashMap();
//put添加
map.put("邓超","**");
map.put("邓超","孙俪");
map.put("王宝强","马蓉");
map.put("宋喆","马蓉");
map.put("刘令博",null);
map.put(null,"刘亦菲");
map.put("鹿晗","关晓彤");
System.out.println("map=" + map);//map={邓超=孙俪, 宋喆=马蓉, 刘令博=null, null=刘亦菲, 王宝强=马蓉, 鹿晗=关晓彤}
//remove:根据键值删除映射关系
map.remove("宋喆");
System.out.println("map="+map);//map={邓超=孙俪, 刘令博=null, null=刘亦菲, 王宝强=马蓉, 鹿晗=关晓彤}
//get:根据键获取值
Object val = map.get("鹿晗");
System.out.println("val="+val);//val=关晓彤
//size:获取元素个数
System.out.println("k-v="+map.size());//k-v=5
//isEmpty:判断个数是否为0
System.out.println(map.isEmpty());//false
//clear:清除k-v
map.clear();
System.out.println("map="+map);//map={}
//containsKey:查找键是否存在
System.out.println("结果="+map.containsKey("王宝强"));//结果=false
}
}
Map六大遍历方式
package com.集合.map_;
import java.util.*;
@SuppressWarnings("ALL")
public class MapFor {
public static void main(String[] args) {
Map map = new HashMap();
map.put("邓超","**");
map.put("邓超","孙俪");
map.put("王宝强","马蓉");
map.put("宋喆","马蓉");
map.put("刘令博",null);
map.put(null,"刘亦菲");
map.put("鹿晗","关晓彤");
//第一组:先取出所有的Key,通过Key取出对应的Value
Set keySet = map.keySet();
//(1)增强for循环
System.out.println("---取出所有的K-V 增强for---");
for (Object key : keySet) {
System.out.println(key+"-"+map.get(key));
}
//(2)迭代器
System.out.println("---取出所有的K-V 迭代器---");
Iterator iterator = keySet.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key+"-"+map.get(key));
}
//第二组:把所有的values取出
Collection values = map.values();
//这里可以使用所有Collection使用的遍历方法
//(3)增强for循环
System.out.println("---取出所有的value 增强for---");
for (Object value : values) {
System.out.println(value);
}
//(4)迭代器
System.out.println("---取出所有的value 迭代器---");
Iterator iterator2 = values.iterator();
while (iterator2.hasNext()) {
Object value = iterator2.next();
System.out.println(value);
}
//第三组: 通过EntrySet来获取K-V
Set entrySet = map.entrySet();// EntrySet<Entry<K,V>>
//(5)增强for循环
System.out.println("---使用EntrySet的 增强for");
for (Object entry : entrySet) {
Map.Entry m =(Map.Entry)entry;
System.out.println(m.getKey()+"-"+m.getValue());
}
//(6)迭代器
System.out.println("---使用EntrySet的 迭代器");
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
Object entry = iterator3.next();
System.out.println(entry.getClass());//HashMap$Node 实现 -> Map.Entry (getKey,getValue)
//向下转型 Map.Entry
Map.Entry m = (Map.Entry)entry;
System.out.println(m.getKey()+"-"+m.getValue());
}
}
}
Map接口练习题
使用HashMap添加3个员工对象,要求 键:员工id 值:员工对象 并遍历显示 工资>18000 的员工
员工类:姓名、工资、员工id
package com.集合.map_;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapExercise {
public static void main(String[] args) {
Map hashMap = new HashMap();
hashMap.put(1,new Emp("jack",30000,1));
hashMap.put(2,new Emp("tom",21000,2));
hashMap.put(3,new Emp("milan",12000,3));
//遍历(2种方式)
//1.使用KeySet -> 增强for
Set keySetet = hashMap.keySet();
for (Object key : keySetet) {
//先获取value
Emp emp = (Emp) hashMap.get(key);
if(emp.getSal()>18000){
System.out.println(emp);
}
}
//2.使用EntrySet -> 迭代器
Set entrySet = hashMap.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()){
Map.Entry entry = (Map.Entry)iterator.next();
Emp emp =(Emp)entry.getValue();
if(emp.getSal()>18000){
System.out.println(emp);
}
}
}
}
class Emp{
private String name;
private double sal;
private int id;
public Emp(String name, double sal, int id) {
this.name = name;
this.sal = sal;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Emp{" +
"name='" + name + '\'' +
", sal=" + sal +
", id=" + id +
'}';
}
}
HashMap
HashMap小结
- Map接口的常用实现类:HashMap、Hashtable和Properties
- HashMap是Map接口使用频率最高的实现类
- HashMap是以 key-val 对的方式来存储数据
- key不能重复,但是值可以重复,允许使用null键和null值
- 如果添加相同的key,则会覆盖原来的key-val,等同于修改,key不会被替换,val会替换
- 与HashSet一样,不保证映射的顺序,因为底层是以hash表的方式来存储的(jdk8的HashMap底层 数组+链表+红黑树)
- HashMap没有实现线程同步,因此线程是不安全的(没有synchronized)
HashMap底层机制及源码剖析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hXet3Ftf-1651137212098)(…/…/source/image-20220428083339499.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-THj92FkG-1651137212099)(…/…/source/image-20220428083613986.png)]
具体内容可以看HashSet的源码分析,HashSet的底层就是HashMap
HashTable
HashTable的基本介绍
- 存放的元素是键值对,即 K-V
- HashTable的键和值都不能为null
- HashTable使用方法基本上和HashMap一样
- HashTable是线程安全的(synchronized),HashMap是线程不安全的
HashTable的底层及扩容
- 底层有数组 Hashtable$Entry[ ] 初始化大小为11
- 临界值 threshold为 8 = 11 * 0.75
- 在添加的put方法中执行方法 addEntry(hash, key, value, index);
- 在addEntry方法中,判断count当前的计数是否大于等于临界值,进入rehash( )
- 在rehash方法中可以看到扩容的大小是原来大小的2倍再+1
HashMap和HashTable的对比
版本 | 线程安全(同步) | 效率 | 允许null键null值 | |
---|---|---|---|---|
HashMap | 1.2 | 不安全 | 高 | 可以 |
HashTable | 1.0 | 安全 | 低 | 不可以 |
Properties
Properties基本介绍
- Properties类继承自HashTable类,并且实现了Map接口,也是使用一种键值对的形式来保存数据
- 他的使用特点和HashTable类似
- Properties还可以用于xxx.properties文件中,加载数据到Properties类对象,并进行读取和修改
- xxx.properties文件通常作为开发中的配置文件
TreeSet
简单介绍
- 当我们使用无参构造器,创建TreeSet时,value是按自然排序的方法排序的(自然排序可见下面TreeMap中的介绍)
- 使用TreeSet的Comparator有参构造器,可以传入一个比较器(匿名内部类),并指定排序规则(在Arrays类的介绍中,详细解释了这种定制排序的方法)
package com.集合.set_;
import java.util.Comparator;
import java.util.TreeSet;
@SuppressWarnings("all")
public class TreeSetSource {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//调用String的compareTo方法进行字符串大小比较
return ((String)o1).compareTo((String)o2);
}
});
treeSet.add("jack");
treeSet.add("tom");
treeSet.add("sp");
treeSet.add("a");
treeSet.add("ab");
System.out.println(treeSet);//[a, ab, jack, sp, tom]
}
}
源码分析
1.TreeSet的Comparator有参构造器,将传入的比较器对象,赋给了TreeSet的底层的TreeMap的属性
2.在treeSet.add(“jack”);中,进入add方法的底层中是TreeMap中的put方法中:将cpr动态绑定到我们的匿名内部类对象comparator
TreeMap
1.使用元素自然排序(比较的是key)
在使用自然顺序排序时候,需要区分两种情况:一种是Jdk定义的对象,一种是我们应用自己定义的对象;
在自然顺序比较中,需要让被比较的元素实现Comparable接口,否则在向集合里添加元素时报:"java.lang.ClassCastException: com.jiaboyan.collection.map.SortedTest cannot be cast to java.lang.Comparable"异常;
这是因为在调用put()方法时,会将传入的元素转化成Comparable类型对象,所以当你传入的元素没有实现Comparable接口时,就无法转换,遍会报错;
2.使用自定义比较器排序(比较的是key)
使用自定义比较器排序,需要在创建TreeMap对象时,将自定义比较器对象传入到TreeMap构造方法中;
自定义比较器对象,需要实现Comparator接口,并实现比较方法compare(T o1,T o2);
值得一提的是,使用自定义比较器排序的话,被比较的对象无需再实现Comparable接口了;