学习日记-day21-6.3

完成目标：

知识点：

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()扩容的方法,默认是16
 tab[i] = newNode(hash, key, value, null);->将元素放在数组中  i就是索引

 i = (n - 1) & hash
     0000 0000 0000 0000 0000 0000 0000 1111->15
                                                    &   0&0=0 0&1=0 1&1=1
     0000 0000 0000 0001 0111 1000 0110 0011->96355
--------------------------------------------------------
     0000 0000 0000 0000 0000 0000 0000 0011->3


     0000 0000 0000 0000 0000 0000 0000 1111->15
                                                    &   0&0=0 0&1=0 1&1=1
     0000 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 1st
     		treeifyBin(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

## TreeSet

1.概述:TreeSet是Set的实现类
2.特点:
  a.对元素进行排序
  b.无索引
  c.不能存null
  d.线程不安全
  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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public 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);
    }

    @Override
    public 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>() {
            @Override
            public 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);
    }
}

================================================================================

## TreeMap


1.概述: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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public 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);
    }

    @Override
    public 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>() {
            @Override
            public 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表达式简化代码