重学java----集合

来源于 跟着韩老师学java笔记，https://www.bilibili.com/video/BV1fh411y7R8

学懂集合这一篇就够了

1. 集合特点

2. 集合的框架体系（记住，非常重要）

3. Collection 接口

特点

常用方法（使用子接口List来展示）

List list = newArrayList();
list.add("jack"); //添加单个元素
list.remove(0);//删除第一个元素
list.contains("jack")//查找元素是否存在
list.size()//获取元素个数
list.isEmpty()//判断是否为空
list.clear();//清空

ArrayList list2 = new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
list.addAll(list2); //添加多个元素
list.containsAll(list2)//查找多个元素是否都存在
list.removeAll(list2);  //删除多个元素

Collection接口遍历方式

1. 使用Iterator(迭代器)

案例

Collection col = newArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
//System.out.println("col=" + col);
//现在老师希望能够遍历 col 集合
//1. 先得到 col 对应的 迭代器
Iterator iterator = col.iterator();
//2. 使用 while 循环遍历
 while (iterator.hasNext()) {//判断是否还有数据
//返回下一个元素，类型是 Object
 Object obj = iterator.next();
System.out.println("obj=" + obj);
}

2. 使用增强for循环

4. List接口

特点

常用方法

List list = newArrayList();
list.add(“张三丰”);
//在 index = 1 的位置插入一个对象
list.add(1, “韩顺平”);

// addAll(int index, Collection eles):从 index 位置开始将 eles 中的所有元素添加进来
list.addAll(1, list2);
list.indexOf(“tom”)//int indexOf(Object obj):返回 obj 在集合中首次出现的位置
list.set(1, “玛丽”);//Object set(int index, Object ele):设置指定 index 位置的元素为 ele , 相当于是替换.
List returnlist = list.subList(0, 2);//List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合

遍历方式

5. ArrayList底层结构和源码分析

ArrayList底层操作机制源码分析（重要）

//使用无参构造器创建 ArrayList 对象
//ArrayList list = newArrayList();
ArrayList list = new ArrayList(8);
//使用 for 给 list 集合添加 1-10 数据
for (int i = 1; i <= 10; i++) {
list.add(i);
}
//使用 for 给 list 集合添加 11-15 数据
for (int i = 11; i <= 15; i++) {
list.add(i);
}
list.add(100);
list.add(200);
list.add(null);

6. Vector底层结构和源码剖析

vector介绍

ArrayList Vs Vector

7. LinkedList底层结构

LinkedList介绍

LinkedList的底层操作机制

模拟一个双向链表

package com.zut.collect;

/**
 * @author wzl
 * @create 2021--10-18 20:30
 */
public class test02 {
    public static void main(String[] args) {
        Node jack =new Node("jack");
        Node tom =new Node("tom");
        Node john =new Node("john");

        //连接3个节点，形成双向链表
        jack.next=tom;
        tom.next=john;
        john.pre=tom;
        tom.pre=jack;

        Node first=jack;//让first引用指向jack，就是双向链表的头结点
        Node last=john;//让last引用指向john，就是双向链表的尾结点

        //从头到尾遍历
        while (true) {
            if(first==null){
                break;
            }
            System.out.println(first);
            first =first.next;
        }
        System.out.println("-------------");
        //从尾到头遍历
        while (true){
            if (last==null){
                break;
            }
            System.out.println(last);
            last=last.pre;
        }

        //链表添加操作
        //1.创建一个Node节点
        Node smith =new Node("smith");

        smith.next=john;
        smith.pre=tom;

        tom.next=smith;

        first=jack; //移动指针，重新指向jack
        System.out.println("==========");

        while (true) {
            if(first==null){
                break;
            }
            System.out.println(first);
            first=first.next;
        }
    }
}
class Node{
    public Object item; //存储数据
    public Node next;//指向后一个节点
    public Node pre;//指向前一个节点
    public Node(Object name){
        this.item =name;
    }

    public String toString() {
        return "Node name=" + item;
    }
}

LinkedList增删改查案例

LinkedList linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println("linkedList=" + linkedList);

//演示一个删除结点的
linkedList.remove(); // 这里默认删除的是第一个结点
//linkedList.remove(2);

/修改某个结点对象
linkedList.set(1, 999);
System.out.println("linkedList=" + linkedList);

//得到某个结点对象
//get(1) 是得到双向链表的第二个对象
Object o = linkedList.get(1);
System.out.println(o);//999

//因为 LinkedList 是 实现了 List 接口, 遍历方式
System.out.println("===LinkeList 遍历迭代器====");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("next=" + next);
}

System.out.println("===LinkeList 遍历增强 for====");
for (Object o1 : linkedList) {
System.out.println("o1=" + o1);
}

System.out.println("===LinkeList 遍历普通 for====");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}

ArrayList Vs LinkedList

8. Set接口

set接口介绍

遍历方式

set接口的常用方法

//1. 以 Set 接口的实现类 HashSet 来讲解 Set 接口的方法
//2. set 接口的实现类的对象(Set 接口对象), 不能存放重复的元素, 可以添加一个 null
//3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
//4. 注意：取出的顺序虽然不是添加的顺序，但是他的固定.
Set set = new HashSet();
set.add("john");
set.add("lucy");
//遍历
//方式1： 使用迭代器
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}

set.remove(null) //移除元素

//方式2：增强for
for (Object o : set) {
System.out.println("o=" + o);
}
//set 接口对象，不能通过索引来获取

set接口的实现类----HashSet

HashSet类介绍

HashSet底层源码说明（非常重要）

这里使用数组+链表结构简单模拟

public class HashSetSource {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("java");//到此位置，第 1 次 add 分析完毕.
hashSet.add("php");//到此位置，第 2 次 add 分析完毕
hashSet.add("java");
System.out.println("set=" + hashSet);

对 上述HashSet 的源码解读
1. 执行 HashSet()
public HashSet() {
map = new HashMap<>();
}
2. 执行 add()
public boolean add(E e) {//e = "java"
return map.put(e, PRESENT)==null;//(static) PRESENT = new Object();
}
3.执行 put() , 该方法会执行 hash(key) 得到 key 对应的 hash 值 算法 h = key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {//key = "java" value = PRESENT 共享
return putVal(hash(key), key, value, false, true);
}
4.执行 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;
//(1)根据 key，得到 hash 去计算该 key 应该存放到 table 表的哪个索引位置
//并把这个位置的对象，赋给 p
//(2)判断 p 是否为 null
//(2.1) 如果 p 为 null, 表示还没有存放元素, 就创建一个 Node (key="java",value=PRESENT)
//(2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//一个开发技巧提示： 在需要局部变量(辅助变量)时候，在创建
Node<K,V> e; K k; //
//如果当前索引位置对应的链表的第一个元素和准备添加的 key 的 hash 值一样
//并且满足 下面两个条件之一:
//(1) 准备加入的 key 和 p 指向的 Node 结点的 key 是同一个对象
//(2) p 指向的 Node 结点的 key 的 equals() 和准备加入的 key 比较后相同
//就不能加入
if (p.hash == hash &&
((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) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
// 注意在把元素添加到链表后，立即判断 该链表是否已经达到 8 个结点
// , 就调用 treeifyBin() 对当前这个链表进行树化(转成红黑树)
// 注意，在转成红黑树时，要进行判断, 判断条件
// if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
// resize();
// 如果上面条件成立，先 table 扩容.
// 只有上面条件不成立时，才进行转成红黑树
//(2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接 break
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD(8) - 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)
resize();//扩容
afterNodeInsertion(evict);
return null;
}
*/
}

HashSet的扩容机制说明

Set接口实现类----LinkedHashSet

LinkedHashSet介绍

LinkedHashSet底层机制

9. Map接口

Map接口实现类的特点（Map很实用）

Map map = new HashMap();
map.put("no1", "韩顺平");//k-v
map.put("no2", "张无忌");//k-v
map.put("no1", "张三丰");//当有相同的 k , 就等价于替换.
map.put("no3", "张三丰");//k-v
map.put(null, null); //k-v
map.put(null, "abc"); //等价替换
map.put("no4", null); //k-v
map.put("no5", null); //k-v
map.put(1, "赵敏");//k-v
map.put(new Object(), "金毛狮王");//k-v
// 通过 get 方法，传入 key ,会返回对应的 value
System.out.println(map.get("no2"));//张无忌
System.out.println("map=" + map);

Map接口常用方法

Map map = new HashMap();
map.put("邓超", new Book("", 100));//添加元素

remove:根据键删除映射关系
map.remove(“邓超”);

get：根据键获取值
Object val = map.get("邓超");
System.out.println("val=" + val);

size:获取元素个数
System.out.println("k-v=" + map.size());

isEmpty:判断个数是否为 0
System.out.println(map.isEmpty());//F

clear:清除 k-v
//map.clear();
System.out.println("map=" + map);

containsKey:查找键是否存在
System.out.println("结果=" + map.containsKey("邓超"));//T

Map接口遍历方法

Map map = new HashMap();
map.put("邓超", "孙俪");
map.put("王宝强", "马蓉");
map.put("宋喆", "马蓉");
map.put("刘令博", null);
map.put(null, "刘亦菲");
map.put("鹿晗", "关晓彤");

第一组：先取出 所有的 Key , 通过 Key 取出对应的 Value
Set keyset = map.keySet();

第一种：增强for
System.out.println("-----第一种方式-------");
for (Object key : keyset) {
System.out.println(key + "-" + map.get(key));
}

第二种：迭代器
System.out.println("----第二种方式--------");
Iterator iterator = keyset.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key + "-" + map.get(key));
}

第二组：把所有的values取出
Collection values = map.values();
//这里可以使用所有的 Collections 使用的遍历方法

第一种：增强for
System.out.println("---取出所有的 value 增强 for----");
for (Object value : values) {
System.out.println(value);
}

第二种：迭代器
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<Map.Entry<K,V>>
//(1) 增强 for
System.out.println("----使用 EntrySet 的 for 增强(第 3 种)----");
for (Object entry : entrySet) {
//将 entry 转成 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
//(2) 迭代器
System.out.println("----使用 EntrySet 的 迭代器(第 4 种)----");
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
Object entry = iterator3.next();
//System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
//向下转型 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}

Map接口实现类----HashMap

HashMap底层源码解析

HashMap map = new HashMap();
map.put("java", 10);//ok
map.put("php", 10);//ok
map.put("java", 20);//替换 value
System.out.println("map=" + map);//


解读 HashMap 的源码+图解
1. 执行构造器 new HashMap()
初始化加载因子 loadfactor = 0.75
HashMap$Node[] table = null

2. 执行 put 调用 hash 方法，计算 key 的 hash 值 (h = key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {//K = "java" value = 10
return putVal(hash(key), key, value, false, true);
}

3. 执行 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 数组为 null, 或者 length =0 , 就扩容到 16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//取出 hash 值对应的 table 的索引位置的 Node, 如果为 null, 就直接把加入的 k-v
//, 创建成一个 Node ,加入该位置即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;//辅助变量
// 如果 table 的索引位置的 key 的 hash 相同和新的 key 的 hash 值相同，
// 并满足(table 现有的结点的 key 和准备添加的 key 是同一个对象 || equals 返回真)
// 就认为不能加入新的 k-v
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)//如果当前的 table 的已有的 Node 是红黑树，就按照红黑树的方式处理
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 方法进行红黑树的转换
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && //如果在循环比较过程中，发现有相同,就 break,就只是替换 value
((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; //替换，key 对应 value
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//每增加一个 Node ,就 size++
if (++size > threshold[12-24-48])//如 size > 临界值，就扩容
resize();
afterNodeInsertion(evict);
return null;
}
5. 关于树化(转成红黑树)
//如果 table 为 null ,或者大小还没有到64，暂时不树化，而是进行扩容.
//否则才会真正的树化 -> 剪枝
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
}
*/
}

Map接口实现类----HashTable

HashTable Vs HashMap

Map接口实现类----Properties

//1. Properties 继承 Hashtable
//2. 可以通过 k-v 存放数据，当然 key 和 value 不能为 null
//增加
Properties properties = new Properties();
//properties.put(null, "abc");//抛出 空指针异常
//properties.put("abc", null); //抛出 空指针异常
properties.put("john", 100);//k-v
properties.put("lucy", 100);
properties.put("lic", 100);
properties.put("lic", 88);//如果有相同的 key ， value 被替换
System.out.println("properties=" + properties);
//通过 k 获取对应值
System.out.println(properties.get("lic"));//88
//删除
properties.remove("lic");
System.out.println("properties=" + properties);
//修改
properties.put("john", "约翰");
System.out.println("properties=" + properties);

10. 如何选择集合类（重点）

11. Collections工具类

排序操作（均为static方法）

Collections.frequency(list, "tom") //返回list集合中“tom”的出现次数

Collections.copy(dest, list);//将dest的内容复制到list中

Collections.replaceAll(list, "tom", "汤姆");//使用新值“汤姆”替换list对象中的“tom”