四,Java之集合
1. 单列集合
1.1 集合和数组的区别
1.2 定义
//范型: 限定集合中存储的数据类型
ArrayList<String> list = new ArrayList<>();
要判断自己创建的对象集合中是否Contains, 需要改写equals方法
Collection是单列集合的顶层接口, 所有方法被List和Set系列共享
1.3 成员方法
1.4 Collection的遍历方式(对Set和List通用)
1.4.1 迭代器遍历
-
迭代器在Java中的类是Iterator, 迭代器是集合专用的遍历方式
-
Colletion集合获取迭代器:
- Iterator
iterator(): 返回迭代器对象, 默认指向当前集合的零索引
- Iterator中的常用方法
- boolean hasNext(): 判断当前位置是否有元素, 有返回true, 无返回false
- E next(): 获取当前位置的元素, 并将迭代器对象移向下一个位置
// 1. 创建集合并添加元素
Collection<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
// 2. 获取迭代器对象
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
String s = iterator.next();
System.out.println(s);
}
1.4.2 增强for遍历遍历
- 增强for的底层就是迭代器, 为了简化迭代器的代码书写的, 它是JDK5之后出现的, 其内部原理就是一个Iterator迭代器
for(元素的类型 变量名 : 数组或集合){}
修改增强for中的变量, 不会改变集合中原本的数据
1.4.3 Lambda表达式遍历
- JDK8开始, 更简单更直接
Collection<String> cl = new ArrayList<>();
cl.add("1");
cl.add("2");
cl.add("3");
cl.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
cl.forEach((s)->System.out.println(s));
1.2 List系列集合
-
Collection的方法被List继承, List有多了很多索引的方法
-
ArrayList底层是数组结构, LinkedList底层是双向链表结构
1.3 Set系列集合
Set集合的方法上基本与Collection的API一致
1. 范型
1. 范型的定义和好处
- 范型: 是JDK5引入的特性, 可以在编译阶段约束操作的数据类型, 并进行检查
- 范型的格式: <数据类型>
- 范型只能支持引用数据类型
- 如下图, 所以推出了范型
- 范型的好处
- 统一了数据类型
- 把运行期间的问题统一到了编译期间, 避免了强制类型转换可能出现的异常, 因为在编译阶段类型就能确定下来
2. 泛型的其他用处
1. 泛型类
2. 泛型方法
- 方法中类型参数不确定时:
- 方法一: 使用类名后面定义的范型(类名中所有方法都适用)
- 方法二: 在方法声明上定义自己的范型(只有本方法能用是)
3. 泛型接口
- 方法一: 实现类给出具体的类型 public class My implements List
{} - 方法二: 实现类延续范型, 创建实现类对象时, 在确定类型 public class My implements List
{}
3. 泛型的继承和通配符
- 范型不具备继承性, 但数据具备继承性
3. HashSet
-
HashSet无序, 不重复, 无索引
-
HashSet集合底层采用哈希表存储数据
-
JDK8以后, 当链表长度超过8, 而且数组长度大于等于64时, 自动转换为红黑树
-
如果集合中存储的是自定义对象, 必须要重写hashCode和equals方法
3. LinkedHashSet
-
LinkedHashSet: 有序, 不重复, 无索引
-
有序指的是保证存储和取出元素的顺序保持一致
-
原理: 底层依然是哈希表结构, 只是每个元素又额外多了一个双链表的机制记录存储的顺序
-
要数据去重, 默认使用HashSet, 如果要求去重而且存取有序, 才使用LinkedHashSet(效率较低)
4. TreeSet
4.1 TreeSet定义
-
TreeSet: 可排序(按照元素的默认规则(由小到大排序)), 不重复, 无索引
-
TreeSet集合底层是基于 红黑树的数据结构实现排序的, 增删改查性能都较好
4.2 TreeSet的两种比较方式
1. 默认排序/自然排序
- JavaBean类实现Comparable接口指定比较规则
2. 比较器排序
-
创建TreeSet对象时, 传递比较器Comparator规则
-
使用原则: 默认使用第一种, 当无法满足使用第二种(比如字符串和Integer里面的排序规则Java已经定义好了)
5. 集合工具类Collections
2. 双列集合
2.1 双列集合特点
- 双列集合的特点:
- 双列集合一次需要存一对数据, 分别为键和值
- 键不能重复, 值可以重复
- 键和值是一一对应的, 每一个键只能找到自己对应的值
- 键+值这个整体我们称之为键值对或者键值对对象, 在Java中叫作Entry对象
2.2 Map常见的API
2.3 Map的遍历方式
2.3.1 键找值
package awei.itheima.MapDemo1;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo1 {
public static void main(String[] args) {
//创建Map集合对象
Map<String,String> map = new HashMap<>();
//添加数据
map.put("张三","23");
map.put("李四","24");
map.put("王五","25");
// 通过键找值
// 获取所有的键, 把这些键放到一个单列集合当中
Set<String> set = map.keySet();
for (String key : set) {
// 通过键获取对应的值
String value = map.get(key);
System.out.println(key + "=" + value);
}
}
}
2.3.2 键值对
package awei.itheima.MapDemo1;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo1 {
public static void main(String[] args) {
//创建Map集合对象
Map<String,String> map = new HashMap<>();
//添加数据
map.put("张三","23");
map.put("李四","24");
map.put("王五","25");
// 通过键值对对象进行遍历
// 获取所有的键值对对象, 返回一个Set集合
Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> entry : entries){
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
2.3.3 Lambda表达式
package awei.itheima.MapDemo1;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
public class MapDemo1 {
public static void main(String[] args) {
//创建Map集合对象
Map<String,String> map = new HashMap<>();
//添加数据
map.put("张三","23");
map.put("李四","24");
map.put("王五","25");
// 利用lambda表达式进行遍历
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String key, String val) {
System.out.println(key + "---"+val);
}
});
map.forEach((String key, String val)->{
System.out.println(key + "---"+val);
});
map.forEach((key, val) -> System.out.println(key + "---"+val));
}
}
2.4 HashMap
2.4.1 HashMap的特点
- HashMap是Map里面的一个实现类
- 没有额外需要学习的特有方法, 可以直接使用Map里面的方法
- 特点都是由键决定的: 无序, 不重复, 无索引
- HashMap跟HashSet底层原理是一模一样的, 都是哈希表结构
- 依赖HashCode方法和equals方法保证键的唯一(如果键(值不需要)存储的是自定义对象, 需要重写HashCode方法和equals方法)
2.4.2 HashMap源码解析
1.看源码之前需要了解的一些内容
Node<K,V>[] table 哈希表结构中数组的名字
DEFAULT_INITIAL_CAPACITY： 数组默认长度16
DEFAULT_LOAD_FACTOR： 默认加载因子0.75
HashMap里面每一个对象包含以下内容：
1.1 链表中的键值对对象
包含：
int hash; //键的哈希值
final K key; //键
V value; //值
Node<K,V> next; //下一个节点的地址值
1.2 红黑树中的键值对对象
包含：
int hash; //键的哈希值
final K key; //键
V value; //值
TreeNode<K,V> parent; //父节点的地址值
TreeNode<K,V> left; //左子节点的地址值
TreeNode<K,V> right; //右子节点的地址值
boolean red; //节点的颜色
2.添加元素
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa" , 111);
hm.put("bbb" , 222);
hm.put("ccc" , 333);
hm.put("ddd" , 444);
hm.put("eee" , 555);
添加元素的时候至少考虑三种情况：
2.1数组位置为null
2.2数组位置不为null，键不重复，挂在下面形成链表或者红黑树
2.3数组位置不为null，键重复，元素覆盖
//参数一：键
//参数二：值
//返回值：被覆盖元素的值，如果没有覆盖，返回null
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//利用键计算出对应的哈希值，再把哈希值进行一些额外的处理
//简单理解：返回值就是返回键的哈希值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//参数一：键的哈希值
//参数二：键
//参数三：值
//参数四：如果键重复了是否保留
// true，表示老元素的值保留，不会覆盖
// false，表示老元素的值不保留，会进行覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
//定义一个局部变量，用来记录哈希表中数组的地址值。
Node<K,V>[] tab;
//临时的第三方变量，用来记录键值对对象的地址值
Node<K,V> p;
//表示当前数组的长度
int n;
//表示索引
int i;
//把哈希表中数组的地址值，赋值给局部变量tab
tab = table;
if (tab == null || (n = tab.length) == 0){
//1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组
//2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容的条件
//如果没有达到扩容条件，底层不会做任何操作
//如果达到了扩容条件，底层会把数组扩容为原先的两倍，并把数据全部转移到新的哈希表中
tab = resize();
//表示把当前数组的长度赋值给n
n = tab.length;
}
//拿着数组的长度跟键的哈希值进行计算，计算出当前键值对对象，在数组中应存入的位置
i = (n - 1) & hash;//index
//获取数组中对应元素的数据
p = tab[i];
if (p == null){
//底层会创建一个键值对对象，直接放到数组当中
tab[i] = newNode(hash, key, value, null);
}else {
Node<K,V> e;
K k;
//等号的左边：数组中键值对的哈希值
//等号的右边：当前要添加键值对的哈希值
//如果键不一样，此时返回false
//如果键一样，返回true
boolean b1 = p.hash == hash;
if (b1 && ((k = p.key) == key || (key != null && key.equals(k)))){
e = p;
} else if (p instanceof TreeNode){
//判断数组中获取出来的键值对是不是红黑树中的节点
//如果是，则调用方法putTreeVal，把当前的节点按照红黑树的规则添加到树当中。
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);
//判断当前链表长度是否超过8，如果超过8，就会调用方法treeifyBin
//treeifyBin方法的底层还会继续判断
//判断数组的长度是否大于等于64
//如果同时满足这两个条件，就会把这个链表转成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//e： 0x0044 ddd 444
//要添加的元素： 0x0055 ddd 555
//如果哈希值一样，就会调用equals方法比较内部的属性值是否相同
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){
break;
}
p = e;
}
}
//如果e为null，表示当前不需要覆盖任何元素
//如果e不为null，表示当前的键是一样的，值会被覆盖
//e:0x0044 ddd 444->555
//要添加的元素： 0x0055 ddd 555
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null){
//等号的右边：当前要添加的值
//等号的左边：0x0044的值
e.value = value;
}
afterNodeAccess(e);
return oldValue;
}
}
//threshold：记录的就是数组的长度 * 0.75，哈希表的扩容时机 16 * 0.75 = 12
if (++size > threshold){
resize();
}
//表示当前没有覆盖任何元素，返回null
return null;
}
2.5 LinkedHashMap
- 由键决定: 有序, 不重复, 无索引
- 这里的有序指的是保证存储和取出的元素顺序一致
- 原理: 底层数据结构依然是哈希表, 只是每个键值对元素又额外地多了一个双链表的机制记录存储的顺序
2.6 TreeMap
2.6.1 TreeMap的特点
- TreeMap跟TreeSet底层原理一样, 都是红黑树数据结构
- 由键决定特性: 不重复, 无索引, 可排序
- 可排序指的是对键进行排序
- 注意: 默认按照键的大小从小到大进行排序, 也可以自己规定键的排序规则
2.6.2 代码书写两种排序规则
- 实现Comparable 接口, 指定比较规则
- 创建集合时传递Comparator 比较器对象, 指定比较规则
2.6.3 TreeMap源码解析
1.TreeMap中每一个节点的内部属性
K key; //键
V value; //值
Entry<K,V> left; //左子节点
Entry<K,V> right; //右子节点
Entry<K,V> parent; //父节点
boolean color; //节点的颜色
2.TreeMap类中中要知道的一些成员变量
public class TreeMap<K,V>{
//比较器对象
private final Comparator<? super K> comparator;
//根节点
private transient Entry<K,V> root;
//集合的长度
private transient int size = 0;
3.空参构造
//空参构造就是没有传递比较器对象
public TreeMap() {
comparator = null;
}
4.带参构造
//带参构造就是传递了比较器对象。
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
5.添加元素
public V put(K key, V value) {
return put(key, value, true);
}
参数一：键
参数二：值
参数三：当键重复的时候，是否需要覆盖值
true：覆盖
false：不覆盖
private V put(K key, V value, boolean replaceOld) {
//获取根节点的地址值，赋值给局部变量t
Entry<K,V> t = root;
//判断根节点是否为null
//如果为null，表示当前是第一次添加，会把当前要添加的元素，当做根节点
//如果不为null，表示当前不是第一次添加，跳过这个判断继续执行下面的代码
if (t == null) {
//方法的底层，会创建一个Entry对象，把他当做根节点
addEntryToEmptyMap(key, value);
//表示此时没有覆盖任何的元素
return null;
}
//表示两个元素的键比较之后的结果
int cmp;
//表示当前要添加节点的父节点
Entry<K,V> parent;
//表示当前的比较规则
//如果我们是采取默认的自然排序，那么此时comparator记录的是null，cpr记录的也是null
//如果我们是采取比较器排序方式，那么此时comparator记录的是就是比较器
Comparator<? super K> cpr = comparator;
//表示判断当前是否有比较器对象
//如果传递了比较器对象，就执行if里面的代码，此时以比较器的规则为准
//如果没有传递比较器对象，就执行else里面的代码，此时以自然排序的规则为准
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else {
V oldValue = t.value;
if (replaceOld || oldValue == null) {
t.value = value;
}
return oldValue;
}
} while (t != null);
} else {
//把键进行强转，强转成Comparable类型的
//要求：键必须要实现Comparable接口，如果没有实现这个接口
//此时在强转的时候，就会报错。
Comparable<? super K> k = (Comparable<? super K>) key;
do {
//把根节点当做当前节点的父节点
parent = t;
//调用compareTo方法，比较根节点和当前要添加节点的大小关系
cmp = k.compareTo(t.key);
if (cmp < 0)
//如果比较的结果为负数
//那么继续到根节点的左边去找
t = t.left;
else if (cmp > 0)
//如果比较的结果为正数
//那么继续到根节点的右边去找
t = t.right;
else {
//如果比较的结果为0，会覆盖
V oldValue = t.value;
if (replaceOld || oldValue == null) {
t.value = value;
}
return oldValue;
}
} while (t != null);
}
//就会把当前节点按照指定的规则进行添加
addEntry(key, value, parent, cmp < 0);
return null;
}
private void addEntry(K key, V value, Entry<K, V> parent, boolean addToLeft) {
Entry<K,V> e = new Entry<>(key, value, parent);
if (addToLeft)
parent.left = e;
else
parent.right = e;
//添加完毕之后，需要按照红黑树的规则进行调整
fixAfterInsertion(e);
size++;
modCount++;
}
private void fixAfterInsertion(Entry<K,V> x) {
//因为红黑树的节点默认就是红色的
x.color = RED;
//按照红黑规则进行调整
//parentOf:获取x的父节点
//parentOf(parentOf(x)):获取x的爷爷节点
//leftOf:获取左子节点
while (x != null && x != root && x.parent.color == RED) {
//判断当前节点的父节点是爷爷节点的左子节点还是右子节点
//目的：为了获取当前节点的叔叔节点
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//表示当前节点的父节点是爷爷节点的左子节点
//那么下面就可以用rightOf获取到当前节点的叔叔节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
//叔叔节点为红色的处理方案
//把父节点设置为黑色
setColor(parentOf(x), BLACK);
//把叔叔节点设置为黑色
setColor(y, BLACK);
//把爷爷节点设置为红色
setColor(parentOf(parentOf(x)), RED);
//把爷爷节点设置为当前节点
x = parentOf(parentOf(x));
} else {
//叔叔节点为黑色的处理方案
//表示判断当前节点是否为父节点的右子节点
if (x == rightOf(parentOf(x))) {
//表示当前节点是父节点的右子节点
x = parentOf(x);
//左旋
rotateLeft(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
} else {
//表示当前节点的父节点是爷爷节点的右子节点
//那么下面就可以用leftOf获取到当前节点的叔叔节点
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
//把根节点设置为黑色
root.color = BLACK;
}
2.6.4 课堂思考问题：
-
TreeMap添加元素的时候，键是否需要重写hashCode和equals方法？
此时是不需要重写的。
插入和查找时，TreeMap 不使用 hashCode/equals，而是依赖 compareTo()（自然顺序） 或 Comparator 来比较键的大小和是否相等。 -
HashMap是哈希表结构的，JDK8开始由数组，链表，红黑树组成的。
既然有红黑树，HashMap的键是否需要实现Compareable接口或者传递比较器对象呢？
不需要的。
因为在HashMap的底层，默认是利用哈希值的大小关系来创建红黑树的 -
TreeMap和HashMap谁的效率更高？
如果是最坏情况，添加了8个元素，这8个元素形成了链表，此时TreeMap的效率要更高
但是这种情况出现的几率非常的少。
一般而言，还是HashMap的效率要更高。 -
你觉得在Map集合中，java会提供一个如果键重复了，不会覆盖的put方法呢？
此时putIfAbsent本身不重要。
传递一个思想：
代码中的逻辑都有两面性，如果我们只知道了其中的A面，而且代码中还发现了有变量可以控制两面性的发生。
那么该逻辑一定会有B面。习惯：
boolean类型的变量控制，一般只有AB两面，因为boolean只有两个值
int类型的变量控制，一般至少有三面，因为int可以取多个值。 -
三种双列集合，以后如何选择？
HashMap LinkedHashMap TreeMap默认：HashMap（效率最高）
如果要保证存取有序：LinkedHashMap
如果要进行排序：TreeMap
3. 不可变集合
-
在List, Set, Map接口中, 都存在静态的of方法, 可以获取一个不可变的集合
这个集合不可添加, 不可删除, 不可修改
-
创建一个不可变的Set时候, 里面的参数一定要确保唯一性
-
Map键值是不能重复的, Map里面的of方法, 参数是有上限的, 最多只能传递20个参数, 10个键值对(因为如果使用范型, of方法涉及到key和value, 但是只允许一个可变参数)
- 若涉及到超过十个键值对, 所以可以使用传递参数Entry
HashMap<String, String> hm = new HashMap<>();
hm.put("1", "1");
hm.put("2", "2");
hm.put("3", "3");
// 利用上面的数据获取一个不可变的集合
// 1.(1)获取到所有的键值对对象
Set<Map.Entry<String, String>> entries = hm.entrySet();
// (2) 把entries变成一个数组
// 如果集合的长度 > 数组的长度: 数据在数组中放不下, 此时会根据实际数据的个数, 重新创建数组
// 如果集合的长度 <= 数组的长度: 数据在数组中放的下, 不会创建数组, 而是直接用
Map.Entry[] arr1 = new Map.Entry[entries.size()];
Map.Entry[] arr2 = entries.toArray(arr1);
// 创建不可变的Map集合
Map map1 = Map.ofEntries(arr2);
// map1.pus("222", "2122"); // 报错
// 2. 较为简单写法(非最终)
Map<Object, Object> map2 = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));
// System.out.println(map2);
// 3. 最终写法(JDK>=10)
Map<String, String> map3 = Map.copyOf(hm);
System.out.println(map3);
浙公网安备 33010602011771号