当前位置：首页 > news >正文

学习日记-day21-6.3

news 2025/6/6 10:12:52

完成目标：

知识点：

1.集合_哈希表存储过程说明

2.集合_哈希表源码查看

3.集合_哈希表无索引&哈希表有序无序详解

4.集合_TreeSet和TreeMap

5.集合_Hashtable和Vector&Vector源码分析

6.集合_Properties属性集

7.集合_集合嵌套

8.集合_小结

9.IO流_File类

10.IO流_静态变量&构造方法

11.IO流_File类常见方法

知识点：

1.集合_哈希表存储过程说明

1.HashMap底层数据数据结构:哈希表
2.jdk7:哈希表 = 数组+链表jdk8:哈希表 = 数组+链表+红黑树
3.先算哈希值,此哈希值在HashMap底层经过了特殊的计算得出如果哈希值不一样,直接存如果哈希值一样,再去比较内容,如果内容不一样,也存如果哈希值一样,内容也一样,直接去重复(后面的value将前面的value覆盖)哈希值一样,内容不一样->哈希冲突(哈希碰撞)
4.要知道的点:a.在不指定长度时,哈希表中的数组默认长度为16,HashMap创建出来,一开始没有创建长度为16的数组b.什么时候创建的长度为16的数组呢?在第一次put的时候,底层会创建长度为16的数组c.哈希表中有一个数据加[加载因子]->默认为0.75(加载因子)->代表当元素存储到百分之75的时候要扩容了->2倍d.如果对个元素出现了哈希值一样,内容不一样时,就会在同一个索引上以链表的形式存储,当链表长度达到8并且当前数组长度>=64时,链表就会改成使用红黑树存储如果后续删除元素,那么在同一个索引位置上的元素个数小于6,红黑树会变回链表e.加入红黑树目的:查询快1.问题:哈希表中有数组的存在,但是为啥说没有索引呢?       哈希表中虽然有数组,但是set和map却没有索引,因为存数据的时候有可能在同一个索引下形成链表,如果2索引上有一条链表,那么我们要是按照索引2获取,咱们获取哪个元素呢?所以就取消了按照索引操作的机制2.问题:为什么HashMap是无序的,LinkedHashMap是有序的呢?    原因:HashMap底层哈希表为单向链表        LinkedHashMap底层在哈希表的基础上加了一条双向链表

知识点	核心内容	重点
哈希表存储过程	1. 比较元素哈希值（需重写hashCode）; 2. 比较内容（需重写equals）; 3. 哈希值不同直接存储; 4. 哈希值相同内容不同（哈希碰撞）仍存储; 5. 哈希值和内容相同则去重	哈希碰撞处理逻辑; 七上八下存储规则（JDK7头插法 vs JDK8尾插法）
哈希表结构组成	三部分结构： - 横向数组（默认长度16）; - 纵向链表; - 红黑树（链表过长时转换）	数组初始化时机（首次put时创建）; 链表转红黑树条件（长度≥8且数组容量≥64）
哈希值计算规则	1. 计算原始哈希值; 2. 进行再哈希运算; 3. 通过与运算确定存储位置索引	二次哈希必要性; 存储位置计算公式（hash & (n-1)）
扩容机制	- 加载因子：0.75; - 扩容阈值：当前容量×0.75; - 扩容倍数：2倍; - 首次扩容临界值：12	性能优化设计（未满即扩容）; 扩容后元素重新散列过程
结构转换条件	- 链表→红黑树：长度≥8且数组容量≥64; - 红黑树→链表：元素≤6	树化阈值（8）; 退化阈值（6）; 最小树化容量（64）
关键常量参数	- DEFAULT_INITIAL_CAPACITY=16; - DEFAULT_LOAD_FACTOR=0.75f; - TREEIFY_THRESHOLD=8; - MIN_TREEIFY_CAPACITY=64	源码级记忆点; 各参数间的联动关系

2.集合_哈希表源码查看

## 1.HashMap无参数构造方法的分析//HashMap中的静态成员变量
static final float DEFAULT_LOAD_FACTOR = 0.75f;
public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}解析：使用无参数构造方法创建HashMap对象，将加载因子设置为默认的加载因子，loadFactor=0.75F。========================================================================================
## 2.HashMap有参数构造方法分析HashMap(int initialCapacity, float loadFactor) ->创建Map集合的时候指定底层数组长度以及加载因子public HashMap(int initialCapacity, float loadFactor) {if (initialCapacity < 0)throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;if (loadFactor <= 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: " +loadFactor);this.loadFactor = loadFactor;this.threshold = tableSizeFor(initialCapacity);//10
}解析：带有参数构造方法，传递哈希表的初始化容量和加载因子- 如果initialCapacity（初始化容量）小于0，直接抛出异常。
- 如果initialCapacity大于最大容器，initialCapacity直接等于最大容器- MAXIMUM_CAPACITY = 1 << 30 是最大容量  (1073741824)
- 如果loadFactor（加载因子）小于等于0，直接抛出异常
- tableSizeFor（initialCapacity）方法计算哈希表的初始化容量。- 注意：哈希表是进行计算得出的容量，而初始化容量不直接等于我们传递的参数。========================================================================================
## 3.tableSizeFor方法分析static final int tableSizeFor(int cap) {int n = cap - 1;n |= n >>> 1;n |= n >>> 2;n |= n >>> 4;n |= n >>> 8;n |= n >>> 16;return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}8  4  2  1规则->无论指定了多少容量,最终经过tableSizeFor这个方法计算之后,都会遵循8421规则去初始化列表容量为了存取高效，尽量较少碰撞解析：该方法对我们传递的初始化容量进行位移运算，位移的结果是 8 4 2 1 码- 例如传递2，结果还是2，传递的是4，结果还是4。
- 例如传递3，结果是4，传递5，结果是8，传递20，结果是32。======================================================================================
## 4.Node 内部类分析哈希表是采用数组+链表的实现方法，HashMap中的内部类Node非常重要，证明HashSet是一个单向链表static class Node<K,V> implements Map.Entry<K,V> {final int hash;final K key;V value;Node<K,V> next;Node(int hash, K key, V value, Node<K,V> next) {this.hash = hash;this.key = key;this.value = value;this.next = next;
}解析：内部类Node中具有4个成员变量- hash，对象的哈希值
- key，作为键的对象
- value，作为值得对象（讲解Set集合，不牵扯值得问题）
- next，下一个节点对象======================================================================================
## 5.存储元素的put方法源码public V put(K key, V value) {return putVal(hash(key), key, value, false, true);
}解析：put方法中调研putVal方法，putVal方法中调用hash方法。- hash(key)方法：传递要存储的元素，获取对象的哈希值
- putVal方法，传递对象哈希值和要存储的对象key=======================================================================================
## 6.putVal方法源码Node<K,V>[] tab; Node<K,V> p; int n, i;if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;解析：方法中进行Node对象数组的判断，如果数组是null或者长度等于0，那么就会调研resize()方法进行数组的扩容。========================================================================================
## 7.resize方法的扩容计算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
}解析：计算结果，新的数组容量=原始数组容量<<1，也就是乘以2。========================================================================================
## 8.确定元素存储的索引if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);解析：i = (数组长度 - 1) & 对象的哈希值，会得到一个索引，然后在此索引下tab[i]，创建链表对象。不同哈希值的对象，也是有可能存储在同一个数组索引下。其中resize()扩容的方法,默认是16tab[i] = newNode(hash, key, value, null);->将元素放在数组中  i就是索引i = (n - 1) & hash0000 0000 0000 0000 0000 0000 0000 1111->15&   0&0=0 0&1=0 1&1=10000 0000 0000 0001 0111 1000 0110 0011->96355
--------------------------------------------------------0000 0000 0000 0000 0000 0000 0000 0011->30000 0000 0000 0000 0000 0000 0000 1111->15&   0&0=0 0&1=0 1&1=10000 0000 0001 0001 1111 1111 0001 0010->1179410
--------------------------------------------------------0000 0000 0000 0000 0000 0000 0000 0010->2=========================================================================================
## 9.遇到重复哈希值的对象Node<K,V> e; K k;if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;解析：如果对象的哈希值相同，对象的equals方法返回true，判断为一个对象，进行覆盖操作。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 1sttreeifyBin(tab, hash);break;}解析：如果对象哈希值相同，但是对象的equals方法返回false，将对此链表进行遍历，当链表没有下一个节点的时候，创建下一个节点存储对象.

知识点	核心内容	重点
哈希表源码解析	哈希表的无参构造、put方法、扩容方法（resize）、元素存储位置计算	默认加载因子、数组初始化、链表转红黑树条件
默认加载因子	默认加载因子为0.75	加载因子的作用和影响
数组初始化	首次put时，数组初始化为长度16	数组初始长度和扩容机制
元素存储位置计算	通过哈希值与数组长度-1进行与运算得到存储位置	哈希碰撞和存储位置的计算方法
链表转红黑树	链表长度>=8且数组长度>=64时，链表转为红黑树	链表转红黑树的条件和目的
值覆盖	新值覆盖老值	值覆盖的机制和实现
指定长度和加载因子	可以自行指定哈希表的初始容量和加载因子	指定容量和加载因子的方法和注意事项
数组容量计算	实际数组容量为指定容量的二次幂（如8, 16, 32等）	数组容量计算规则和目的（减少哈希碰撞）

3.集合_哈希表无索引&哈希表有序无序详解

知识点	核心内容	易混淆点
哈希表结构特性	哈希表包含数组但取消索引机制	数组存在与索引缺失的因果关系
哈希冲突处理	同一索引下可能形成链表结构	链表长度与查询效率的关系
HashMap无序原理	使用单向链表导致遍历顺序与存储顺序不一致	存储顺序与检索顺序的差异
LinkedHashMap有序原理	通过双向链表维护元素插入顺序	双向链表的前驱/后继指针机制
数据结构对比	普通HashMap vs LinkedHashMap的底层实现差异	单向链表与双向链表的结构差异

4.集合_TreeSet和TreeMap

## TreeSet1.概述:TreeSet是Set的实现类
2.特点:a.对元素进行排序b.无索引c.不能存nulld.线程不安全e.元素唯一
3.数据结构:红黑树      构造:TreeSet() -> 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序 -> ASCII TreeSet(Comparator<? super E> comparator)构造一个新的空 TreeSet，它根据指定比较器进行排序     public class Person {private String name;private Integer age;public Person() {}public Person(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return Objects.equals(name, person.name) && Objects.equals(age, person.age);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}public class Demo01TreeSet {public static void main(String[] args) {TreeSet<String> set1 = new TreeSet<>();set1.add("c.白毛浮绿水");set1.add("a.鹅鹅鹅");set1.add("b.曲项向天歌");set1.add("d.红掌拨清波");System.out.println(set1);System.out.println("=====================");TreeSet<Person> set2 = new TreeSet<>(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {return o1.getAge()-o2.getAge();}});set2.add(new Person("柳岩",18));set2.add(new Person("涛哥",12));set2.add(new Person("张三",20));System.out.println(set2);}
}================================================================================## TreeMap1.概述:TreeMap是Map的实现类
2.特点:a.对key进行排序b.无索引c.key唯一d.线程不安全e.不能存null
3.数据结构:红黑树      构造:TreeMap() -> 使用键的自然顺序构造一个新的、空的树映射 -> ASCII TreeMap(Comparator<? super E> comparator)构造一个新的、空的树映射，该映射根据给定比较器进行排序public class Person {private String name;private Integer age;public Person() {}public Person(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return Objects.equals(name, person.name) && Objects.equals(age, person.age);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}public class Demo02TreeMap {public static void main(String[] args) {TreeMap<String, String> map1 = new TreeMap<>();map1.put("c","白毛浮绿水");map1.put("a","鹅鹅鹅");map1.put("b","曲项向天歌");map1.put("d","红掌拨清波");System.out.println(map1);System.out.println("=============");TreeMap<Person, String> map2 = new TreeMap<>(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {return o1.getAge()-o2.getAge();}});map2.put(new Person("柳岩",18),"北京");map2.put(new Person("涛哥",12),"北京");map2.put(new Person("三上",20),"北京");System.out.println(map2);}
}

知识点

核心内容

重点

TreeSet

- Set接口实现类;

- 红黑树数据结构;

- 元素唯一且自动排序;

- 无索引、线程不安全;

- 不允许存储null

- 排序规则：自然排序（如ASCII码）或自定义比较器;

- 自定义对象需实现Comparable或传入Comparator

TreeMap

- Map接口实现类;

- 红黑树数据结构;

- 对Key自动排序;

- Key唯一且不可为null;

- 线程不安全

- Key排序逻辑与TreeSet一致;

- 自定义Key需处理比较逻辑

红黑树特性

- 自平衡二叉查找树;

- 保证基本操作时间复杂度为O(log n);

- 排序依赖节点比较规则

- 与哈希表（HashMap）的查询效率对比;

- 平衡性维护机制

Comparator使用

- 通过比较器定制排序规则;

- 示例：(o1, o2) -> o1.getAge() - o2.getAge()

- 升序/降序写法易混淆;

- Lambda表达式简化代码