Java 集合类实现原理

火山引擎实时对话AI实战:5分钟搞定WebRTC+大模型+ASR/TTS全链路集成 本文详细介绍了如何利用火山引擎的实时对话AI解决方案,快速集成WebRTC、大模型、ASR和TTS服务,构建低延迟、高保真的实时语音对话应用。通过实战代码示例,从环境准备、音频流管理到全链路串联与性能优化,为开发者提供了一套端到端的集成指南,适用于智能客服、在线教育等互动场景。 阅读详情

Collection & Map

  1. Collection 子类有 List 和 Set

  2. List –> ArrayList / LinkedList / Vector

  3. Set –> HashSet / TreeSet

  4. Map –> HashMap / HashTable / TreeMap

一、ArrayList

ArrayList 是 List 接口的可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外, 此类还提供一些方法来操作内部用来存储列表的数组的大小。

每个 ArrayList 实例都有一个容量,该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素,其容量也自动增长 (每次调用添加操作时,都会调用 ensureCapacity 方法,判断是否需要自增,如果需要则自增数组) 。自动增长会带来数据向新数组的重新拷贝,因此,如果可预知数据量的多少,可在构造 ArrayList 时指定其容量。在添加大量元素前,应用程序也可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量,这可以减少递增式再分配的数量。

注意,此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步。(结构上的修改是指任何添加或删除一个或多个元素的操作,或者显式调整底层数组的大小;仅仅设置元素的值不是结构上的修改。)

不管是 ArrayList、 Vector、LinkedList 他们的 set,remove 方法的返回值都是原来该位置的元素,add 方法返回 boolean 值为是否成功插入

1、实现的接口

  1. 继承 AbstractList (实现了 List 接口)

  2. Cloneable 可克隆, Serializable 可序列化,RandomAccess 为 List 提供快速访问功能(RandomAccess 为空接口,只是一个可以快速访问的标识),即通过序号获取元素

2、构造方法

  1. 创建长度为 10 的数组

  2. 创建指定长度数组,小于 0 抛出异常

  3. 根据集合创建数组,创建长度为集合长度的数组并拷贝

3、增删查方法

  1. 每次操作之前都会创建一个新的数组引用指向被操作数组,使用新的引用操作。

  2. set 方法,指定位置赋值,检查 index ,如果不合法则抛出异常

  3. add 方法,末尾位置添加,如果超出,先创建新数组替换旧数组,新数组长度为就数组的 1.5 倍再加 1;

  4. add(int index,Object obj) 指定位置添加,检查 index ,如不合法则抛出异常。指定位置插入时,会将原来的数组以 index 为界,将 index 后的数据后移一位,后移的实现通过 System.arraycopy 方法实现。再在 index 位置插入需要插入的数据。 System.arraycopy 为 Native 层的方法,可以高效复制数组元素。

  5. remove(int index) 根据索引删除,直接操作数组,返回值为被移除的对象。将该对象所在位置之后的数组内容复制到从该位置开始,将末尾置为 null

  6. remove(Object obj) 根据对象删除,遍历数组,如果存在,将该对象所在位置之后的数组内容复制到从该位置开始,将末尾置为 null

  7. 当我们可预知要保存的元素的多少时,要在构造 ArrayList 实例时,就指定其容量,以避免数组扩容的发生。或者根据实际需求,通过调用ensureCapacity 方法来手动增加 ArrayList 实例的容量。

  8. ArrayList基于数组实现,可以通过下标索引直接查找到指定位置的元素,因此查找效率高,但每次插入或删除元素,就要大量地移动元素,插入删除元素的效率低。

  9. 在查找给定元素索引值等的方法中,源码都将该元素的值分为null和不为null两种情况处理,ArrayList中允许元素为null。

二、Vector

  1. Vector也是基于数组实现的,是一个动态数组,其容量能自动增长。
  2. Vector是JDK1.0引入了,它的很多实现方法都加入了同步语句,使用 synchronized 修饰,因此是线程安全的(其实也只是相对安全,有些时候还是要加入同步语句来保证线程的安全),可以用于多线程环境。
  3. Vector没有实现 Serializable 接口,因此它不支持序列化,实现了 RandomAccess 可以
  4. Vector 的构造函数中可以指定容量增长系数,如果不指定增长系数,增加时为增加一倍,这点有别于 ArrayList。

Vector的源码实现总体与ArrayList类似,关于Vector的源码,给出如下几点总结:

1、Vector有四个不同的构造方法。无参构造方法的容量为默认值10,仅包含容量的构造方法则将容量增长量(从源码中可以看出容量增长量的作用,第二点也会对容量增长量详细说)明置为0。

2、注意扩充容量的方法ensureCapacityHelper。与ArrayList相同,Vector在每次增加元素(可能是1个,也可能是一组)时,都要调用该方法来确保足够的容量。当容量不足以容纳当前的元素个数时,就先看构造方法中传入的容量增长量参数CapacityIncrement是否为0,如果不为0,就设置新的容量为就容量加上容量增长量,如果为0,就设置新的容量为旧的容量的2倍,如果设置后的新容量还不够,则直接新容量设置为传入的参数(也就是所需的容量),而后同样用Arrays.copyof()方法将元素拷贝到新的数组。

3、很多方法都加入了synchronized同步语句,来保证线程安全。

4、同样在查找给定元素索引值等的方法中,源码都将该元素的值分为null和不为null两种情况处理,Vector中也允许元素为null

5、其他很多地方都与ArrayList实现大同小异,Vector现在已经基本不再使用。

三、LinkedList

LinkedList 和 ArrayList 一样,实现了 List 接口,但其内部的数据结构有本质不同。LinkedList 是基于双向循环链表实现的,所以它的插入和删除操作比 ArrayList 更高效,不过由于是基于链表的,随机访问的效率要比 ArrayList 差。

实现了 Searializable 接口,支持序列化,实现了 Cloneable 接口,可被克隆

是非线程安全的,只是用于单线程环境下,多线程环境下可以采用concurrent并发包下的concurrentHashMap。

1、数据结构

LinkedList 是基于链表结构的实现,每一个节点的类都包含了 previous 和 next 两个 Link 指针对象,由 Link 保存,Link 中包含了上一个节点和下一个节点的引用,这样就构成了双向的链表,每个 Link 只能知道自己的前一个和后一个节点。
注意:不同版本类名不同,但是原理一样,有的版本类名是 Node

private static final class Link<ET> {
    ET data;

    Link<ET> previous, next;

    Link(ET o, Link<ET> p, Link<ET> n) {
        data = o;
        previous = p;
        next = n;
    }
}

2、插入数据

  1. LinkedList 内部的 Link 对象 voidLink ,其 previous 执向链表最后一个对象,next 指向第一个链表第一个对象,初始化 LinkedList 时默认初始化 voidLink 的前后都指向自己。

  2. 注意两个不同的构造方法。无参构造方法直接建立一个仅包含head节点的空链表,包含Collection的构造方法,先调用无参构造方法建立一个空链表,而后将Collection中的数据加入到链表的尾部后面。

  3. 往最后插入,会创建新的 Link 对象,并将 新对象的 previous 赋值为 voidLind 的 previous,将新对象的 next 赋值为 voidLink,最后将 voidLink 的 previous 指向 新对象。

  4. 往非末尾插入,会比较 index 与链表的中间值的大小,缩小检索比例,调用从后往前检索或从前往后检索,如果从前往后,会循环调用 voidLink 的 next 方法
    直到需要插入的位置得到当前位置的元素 link (注意,voidLink的 next 指向第一个元素,所以遍历next之后的位置为需要插入的位置),创建新对象,新对象的 previous 指向原来当前元素 link 的 previous ,新对象的 next 指向 link,link 的 previous 执向新对象,原来 link 的 previous 对象的 next 指向 新元素,这样就准确插入。从后往前的道理相同。

  5. LinkedList 获取非首尾元素时,也会使用与插入时相同的判断位置的加速机制

  6. 在查找和删除某元素时,源码中都划分为该元素为 null 和不为 null 两种情况来处理,LinkedList 支持插入的元素为 null

  7. LinkedList是基于链表实现的,因此不存在容量不足的问题,所以这里没有扩容的方法。

  8. LinkedList是基于链表实现的,因此插入删除效率高,查找效率低(虽然有一个加速动作)。

  9. 要注意源码中还实现了栈和队列的操作方法,因此也可以作为栈、队列和双端队列来使用 push(向顶部插入元素)、pop(删除并返回第一个元素) 等方法。

  10. Iterator 中通过元素索引是否等于“双向链表大小”来判断是否达到最后。

四、HashMap

HashMap 是基于哈希表实现的,每一个元素是一个 key-value 对,其内部通过 单链表 解决冲突问题,容量不足(超过了阀值)时,同样会自动增长。

HashMap是非线程安全的,只是用于单线程环境下,多线程环境下可以采用concurrent并发包下的concurrentHashMap。

HashMap 实现了Serializable接口,因此它支持序列化,实现了Cloneable接口,能被克隆

默认长度 16 扩容为 2 倍每次,如果扩容后还是不够则创建目标长度数组,将旧数组复制到新数组中

实现方式为数组,每个数组中都可以是一个单链表,插入时,根据 hashcode 计算在数组中位置,判断是否存在相同元素后,根据情况在相应位置的链表头中插入新元素。

初始容量: 初始哈希数组的长度,默认 16
最大容量: 2 的 30 次幂
加载因子: 默认 0.75
阈值:用于判断是否需要调整 HashMap 容量,等于 容量 * 加载因子

总结

  1. 加载因子,如果加载因子越大,对空间的利用更充分,但是查找效率会降低(链表长度会越来越长);如果加载因子太小,那么表中的数据将过于稀疏(很多空间还没用,就开始扩容了),对空间造成严重浪费。如果我们在构造方法中不指定,则系统默认加载因子为0.75,这是一个比较理想的值,一般情况下我们是无需修改的。

  2. 最大容量,无论我们指定的容量为多少,构造方法都会将实际容量设为不小于指定容量的2的次方的一个数,且最大值不能超过2的30次方。要求为 2 的整数次幂是为了使不同hash值发生碰撞的概率较小,这样就能使元素在哈希表中均匀地散列。

  3. HashMap中key和value都允许为null。

HashMap 的数据结构

HashMap 中的数组就是哈希表,也称为哈希数组,数组的每个元素都是一个单链表的头节点,链表是用来解决冲突的,如果不同的key映射到了数组的同一位置处,就将其放入单链表中。

数组中的每一个元素都是一个 HashMapEntry,也是一个单链表的表头,其 next 指向链表中下一元素。通过 HashMapEntry 中的 key 可以计算出其在数组也就是哈希数组中的位置,得到该位置之后,就可以在链表中根据 key 的 equals 方法确定某元素

其中还有一个成员遍历 entryForNullKey ,表示 key 为 null 的元素,访问和修改 key 为 null 的元素时,直接操作该值,之前是将 key 为 null 的元素放到了数组的第一个位置中的链表中,不同版本处理不同

static class HashMapEntry<K, V> implements Entry<K, V> {
    final K key;
    V value;
    final int hash;
    HashMapEntry<K, V> next;

    HashMapEntry(K key, V value, int hash, HashMapEntry<K, V> next) {
        this.key = key;
        this.value = value;
        this.hash = hash;
        this.next = next;
    }

    public final K getKey() {
        return key;
    }

    public final V getValue() {
        return value;
    }

    public final V setValue(V value) {
        V oldValue = this.value;
        this.value = value;
        return oldValue;
    }

    @Override public final boolean equals(Object o) {
        if (!(o instanceof Entry)) {
            return false;
        }
        Entry<?, ?> e = (Entry<?, ?>) o;
        return Objects.equal(e.getKey(), key)
                && Objects.equal(e.getValue(), value);
    }

    @Override public final int hashCode() {
        return (key == null ? 0 : key.hashCode()) ^
                (value == null ? 0 : value.hashCode());
    }

    @Override public final String toString() {
        return key + "=" + value;
    }
}

插入 put(K key, V value)

@Override public V put(K key, V value) {
    if (key == null) {
        return putValueForNullKey(value);
    }

    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    int index = hash & (tab.length - 1);
    for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
        if (e.hash == hash && key.equals(e.key)) {
            preModify(e);
            V oldValue = e.value;
            e.value = value;
            return oldValue;
        }
    }

    // No entry for (non-null) key is present; create one
    modCount++;
    if (size++ > threshold) {
        tab = doubleCapacity(); // 每次加入键值对时,都要判断当前已用的槽的数目是否大于等于阀值(容量*加载因子),如果大于等于,则进行扩容,将容量扩为原来容量的2倍。
        index = hash & (tab.length - 1);
    }
    addNewEntry(key, value, hash, index);
    return null;
}

void addNewEntry(K key, V value, int hash, int index) {
    table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
}
  1. 如果 key 为 null 且存在 key 为 null 的元素,如果没有则在数组中添加一个 key 为 null 的元素,如果有 key 为 null 的元素,则将该元素对应的 value 设置为新的 value

  2. key 不为 null 情况下,由 key 计算 hash 值,由 hash 值确定该元素在哈希数组中的位置

  3. 如果当前哈希数组该位置中有值,且在当前链表中有 key 与新元素的 key 相同的元素(hash 值一样,equals 也一样) 说明是修改,则将旧元素的 value 更新为新的 value ,并将旧的 value 返回,put 方法结束

  4. 如果当前哈希数组该元素为 null 或者当前位置的链表中没有 key 与新元素 key 相同的元素,那么就是插入操作。HashMap 中元素总数量加一,执行插入方法

  5. 插入时,构造新的 HashEntry ,如果当前位置为 null 就直接放入数组,如果该位置不为 null ,就讲新 HashEntry 的 next 指向当前位置的 HashEntry ,并将数组当前位置赋值为新的 HashEntry,插入结束。插入成功返回值为 null。说明每次put键值对的时候,总是将新的该键值对放在table[bucketIndex]处(即头结点处)。

删除 remove(Object key)

  1. 如果 key 为 null 则直接将 key 为 null 位置置为 null,并将其 value 返回

  2. 如果 key 不为 null,则根据 key 计算 hash 值再计算在哈希数组中的位置

  3. 如果当前位置 HashEntry 不为 null,则遍历单链表,找到元素的 key 与要删除的 key 相同的元素,将其上一位置的 next 指向其 next,将该元素从链表中移除并返回

  4. 如果当前位置为 null,或者遍历完链表没有 key 匹配的元素,直接返回 null

@Override public V remove(Object key) {
    if (key == null) {
        return removeNullKey();
    }
    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    int index = hash & (tab.length - 1);
    for (HashMapEntry<K, V> e = tab[index], prev = null;
            e != null; prev = e, e = e.next) {
        if (e.hash == hash && key.equals(e.key)) {
            if (prev == null) {
                tab[index] = e.next;
            } else {
                prev.next = e.next;
            }
            modCount++;
            size--;
            postRemove(e);
            return e.value;
        }
    }
    return null;
}

查询 get(Object key)

public V get(Object key) {
    if (key == null) {
        HashMapEntry<K, V> e = entryForNullKey;
        return e == null ? null : e.value;
    }

    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
            e != null; e = e.next) {
        K eKey = e.key;
        if (eKey == key || (e.hash == hash && key.equals(eKey))) {
            return e.value;
        }
    }
    return null;
}

由插入和删除的分析,查询就比较简单了,不再分析

四、HashTable

  1. Hashtable同样是基于哈希表实现的,同样每个元素是一个key-value对,其内部也是通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动增长。

  2. Hashtable也是JDK1.0引入的类,是线程安全的,能用于多线程环境中。

  3. Hashtable同样实现了Serializable接口,它支持序列化,实现了Cloneable接口,能被克隆。

针对Hashtable,我们同样给出几点比较重要的总结,但要结合与HashMap的比较来总结
  1. 二者的存储结构和解决冲突的方法都是相同的。

  2. HashTable在不指定容量的情况下的默认容量为11,而HashMap为16,Hashtable不要求底层数组的容量一定要为2的整数次幂,而HashMap则要求一定为2的整数次幂

  3. Hashtable中key和value都不允许为null,而HashMap中key和value都允许为null(key只能有一个为null,而value则可以有多个为null)。但是如果在Hashtable中有类似put(null,null)的操作,编译同样可以通过,因为key和value都是Object类型,但运行时会抛出NullPointerException异常,这是JDK的规范规定的。

  4. Hashtable扩容时,将容量变为原来的2倍加1,而HashMap扩容时,将容量变为原来的2倍。

  5. Hashtable计算hash值,直接用key的hashCode(),而HashMap重新计算了key的hash值,Hashtable在求hash值对应的位置索引时,用取模运算,而HashMap在求位置索引时,则用与运算。取模运算开销比较大

五、LinkedHashMap

LinkedHashMap 是 HashMap 的子类,是有序的,放入顺序和访问顺序两种初始化方式

LinkedHashMap 可以用来实现LRU算法

LinkedHashMap 同样是非线程安全的,只在单线程环境下使用

LinkedHashMap 中有个 boolean accessOrder 成员变量,表示双向链表中元素排序规则的标志位。accessOrder为false,表示按插入顺序排序,accessOrder为true,表示按访问顺序排序

数据结构

实际上就是 HashMap 和 LinkedList 两个集合类的存储结构的结合。在 LinkedHashMapMap 中,所有 put 进来的 Entry 都保存在哈希表中,但它又额外定义了一个 head 为头结点的空的双向循环链表,每次 put 进来 HashMapEntry ,除了将其保存到对哈希表中对应的位置上外,还要将其插入到双向循环链表的尾部。

static class LinkedEntry<K, V> extends HashMapEntry<K, V> {
    LinkedEntry<K, V> nxt;
    LinkedEntry<K, V> prv;

    /** Create the header entry */
    LinkedEntry() {
        super(null, null, 0, null);
        nxt = prv = this;
    }

    /** Create a normal entry */
    LinkedEntry(K key, V value, int hash, HashMapEntry<K, V> next,
                LinkedEntry<K, V> nxt, LinkedEntry<K, V> prv) {
        super(key, value, hash, next);
        this.nxt = nxt;
        this.prv = prv;
    }
}

LinkedHashMap 中元素的类型为 LinkedEntry,其继承了 HashMapEntry,并添加了 nxt、prv 两个成员,指向该元素在双链表中的前后节点

put 方法

LinkedHashMap 并没有重写 put 方法,而是重写了 HashMap 中添加元素时调用的 preModify 方法和 addNewEntry 方法,proModify 在 HashMap 为空实现,在 LinkedHashMap 中调用了 makeTail 方法,接着来看:

preModify 方法是加入元素时判断有对应 key 元素存在的情况执行的方法,说明原来的哈希数组中跟双向链表中有该元素,在哈希数组中会直接修改该元素的 value 值,但是双链表中的处理确有不同。此时会先将链表中该处的元素移除,再重新将元素的 value 赋值,之后重新将元素接到链表的尾端。

// 先将链表中该处的元素移除,再重新将元素的 value 赋值,之后重新将元素接到链表的尾端
private void makeTail(LinkedEntry<K, V> e) {
    // Unlink e
    e.prv.nxt = e.nxt;
    e.nxt.prv = e.prv;

    // Relink e as tail
    LinkedEntry<K, V> header = this.header;
    LinkedEntry<K, V> oldTail = header.prv;
    e.nxt = header;
    e.prv = oldTail;
    oldTail.nxt = header.prv = e;
    modCount++;
}

// 如果原链表中没有匹配的 key 对应的元素,则直接将新元素添加到尾端
// 并将新元素的 next 执行原来哈希数组中该位置元素,并为哈希数组中对应位置赋值为新元素
@Override void addNewEntry(K key, V value, int hash, int index) {
    LinkedEntry<K, V> header = this.header;

    // Remove eldest entry if instructed to do so.
    LinkedEntry<K, V> eldest = header.nxt;
    if (eldest != header && removeEldestEntry(eldest)) { // removeEldestEntry 默认返回 false,作用最后再说
        remove(eldest.key);
    }

    // Create new entry, link it on to list, and put it into table
    LinkedEntry<K, V> oldTail = header.prv;
    LinkedEntry<K, V> newTail = new LinkedEntry<K,V>(
            key, value, hash, table[index], header, oldTail);
    table[index] = oldTail.nxt = header.prv = newTail;
}
  1. 如果当前双链表中有该元素,则将该元素移出链表,再重新将该元素接到双链表尾端
  2. 如果双链表中没有对应元素,则创建一个新的 LinkedEntry ,其前一节点指向链表末端,其下节点指向 header,将其插入到链表末端,并将原来末端的下一节点指向新元素,将 header 的前一节点指向新元素,并将新元素的 next 执行原来哈希数组中该位置元素,并为哈希数组中对应位置赋值为新元素

get(Object key)

由 HashMap 中遍历数组,改为了遍历双链表,效率更高。

需要注意的是如果 LinkedHashMap 的 accessOrder 为 true 时,会将需要获取的元素移出双链表,并重新连接到链表的尾端。

@Override public V get(Object key) {
    /*
     * This method is overridden to eliminate the need for a polymorphic
     * invocation in superclass at the expense of code duplication.
     */
    if (key == null) {
        HashMapEntry<K, V> e = entryForNullKey;
        if (e == null)
            return null;
        if (accessOrder)
            makeTail((LinkedEntry<K, V>) e);
        return e.value;
    }

    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
            e != null; e = e.next) {
        K eKey = e.key;
        if (eKey == key || (e.hash == hash && key.equals(eKey))) {
            if (accessOrder)
                makeTail((LinkedEntry<K, V>) e);
            return e.value;
        }
    }
    return null;
}

remove(Object key)

LinkedHashMap 重写了 HashMap 的 postRemove 方法,HashMap 的 remove 方法中会将哈希数组中的元素移除,同时还会调用 postRemove 方法,该方法在 HashMap 中是空实现,在 LinkedHashMap 中实现如下:

@Override void postRemove(HashMapEntry<K, V> e) {
    LinkedEntry<K, V> le = (LinkedEntry<K, V>) e;
    le.prv.nxt = le.nxt;
    le.nxt.prv = le.prv;
    le.nxt = le.prv = null; // Help the GC (for performance)
}

postRemove 方法中,会将对应元素在双链表中删除

LinkedHashMap 实现 LRU 算法

刚才分析 addNewEntry 时提到了 removeEldestEntry 方法,其在 LinkedHashMap 中是个空实现


@Override void addNewEntry(K key, V value, int hash, int index) {
    ...
    LinkedEntry<K, V> eldest = header.nxt;
    if (eldest != header && removeEldestEntry(eldest)) {
        remove(eldest.key);
    }
    ...
}

protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
    return false;
}

在每次添加元素是都会调用 removeEldestEntry 方法,如果该方法返回 true 则删除 header.nxt 处的元素,其实也就是删除哈希数组中对应元素与双向链表的头部的元素,因为在 accessOrder 为 true 时每次插入和访问都会将最近访问的元素移动到双向链表的尾部,这样链表头部的元素就是最久没有被访问到的。在 removeEldestEntry 中可以根据当前链表节点数到达最大容量时返回 true,此时就会删除链表头部节点,这样就完成了 LRU 算法。

总结

  1. 实际上就是HashMap和LinkedList两个集合类的存储结构的结合。在LinkedHashMapMap中,所有put进来的Entry都保存在如第一个图所示的哈希表中,但它又额外定义了一个以head为头结点的空的双向循环链表,每次put进来Entry,除了将其保存到对哈希表中对应的位置上外,还要将其插入到双向循环链表的尾部。

2、LinkedHashMap由于继承自HashMap,因此它具有HashMap的所有特性,同样允许key和value为null。

  1. 注意构造方法,前四个构造方法都将accessOrder设为false,说明默认是按照插入顺序排序的,而第五个构造方法可以自定义传入的accessOrder的值,因此可以指定双向循环链表中元素的排序规则,一般要用LinkedHashMap实现LRU算法,就要用该构造方法,将accessOrder置为true。

  2. 最后说说LinkedHashMap是如何实现LRU的。首先,当accessOrder为true时,才会开启按访问顺序排序的模式,才能用来实现LRU算法。我们可以看到,无论是put方法还是get方法,都会导致目标Entry成为最近访问的Entry,因此便把该Entry加入到了双向链表的末尾(get方法通过调用recordAccess方法来实现,put方法在覆盖已有key的情况下,也是通过调用recordAccess方法来实现,在插入新的Entry时,则是通过createEntry中的addBefore方法来实现),这样便把最近使用了的Entry放入到了双向链表的后面,多次操作后,双向链表前面的Entry便是最近没有使用的,这样当节点个数满的时候,删除的最前面的Entry(head后面的那个Entry)便是最近最少使用的Entry。

六、TreeMap

TreeMap是基于红黑树实现的,这里只对红黑树做个简单的介绍,红黑树是一种特殊的二叉排序树,红黑树通过一些限制,使其不会出现二叉树排序树中极端的一边倒的情况,相对二叉排序树而言,这自然提高了查询的效率。

红黑树规则

  1. 每个节点都只能是红色或者黑色
  2. 根节点是黑色
  3. 每个叶节点(NIL节点,空节点)是黑色的。
  4. 如果一个结点是红的,则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。
  5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

正是这些性质的限制,使得红黑树中任一节点到其子孙叶子节点的最长路径不会长于最短路径的2倍,因此它是一种接近平衡的二叉树。

构造方法

  1. 采用无参构造方法,不指定比较器,这时候,排序的实现要依赖key.compareTo()方法,因此key必须实现Comparable接口,并覆写其中的compareTo方法。

  2. 采用带比较器的构造方法,这时候,排序依赖该比较器,key可以不用实现Comparable接口。

  3. 带Map的构造方法,该构造方法同样不指定比较器,调用putAll方法将Map中的所有元素加入到TreeMap中。putAll的源码如下:

  4. TreeMap是根据key进行排序的,它的排序和定位需要依赖比较器或覆写Comparable接口,也因此不需要key覆写hashCode方法和equals方法,就可以排除掉重复的key,而HashMap的key则需要通过覆写hashCode方法和equals方法来确保没有重复的key。

  5. TreeMap的查询、插入、删除效率均没有HashMap高,一般只有要对key排序时才使用TreeMap。

  6. TreeMap的key不能为null,而HashMap的key可以为null。

七、HashSet

实现原理基于 HashMap set 中的 value 都一样,key 为添加的元素

HashSet 中有一个 HashMap 成员,每次操作时都是操作该 HashMap,操作的元素的 key 为 Set 中要操作的元素,value 为 HashSet 本身的引用。

八、TreeSet

实现原理基于 TreeMap

YOLOv11改进 | Neck篇 | 双向特征金字塔网络BiFPN助力YOLOv11有效涨点 本文给大家带来的改进机制是BiFPN双向特征金字塔网络,其是一种特征融合层的结构,也就是我们本文改进YOLOv11模型中的Neck部分,它的主要思想是通过多层级的特征金字塔和双向信息传递来提高精度。本文给大家带来的结构可以让大家自行调节网络结构大小,同时能够达到一定的轻量化效果,为什么发BiFPN呢因为它算是YOLO系列改进中的常青树了,大家可以借鉴它的双向特征思想来创新自己的Neck结构本文的BiFPN通过yaml文件配置可以让大家自行调配其结构。 阅读详情

相关推荐

炼丹-Pyecharts: JupyterLab无法render_notebook

炼丹-Pyecharts: JupyterLab无法render_notebook问题描述Jupyter-Lab 环境下render_notebook显示空白 问题描述Jupyter-Lab 环境下render_notebook显示空白 首先需要使用pyecharts自带的config来申明一下使用pyecharts的运行环境 from pyecharts.globals import Curre...

MichaelZzzzz的博客 4689

Java 集合-实现原理总结

HashMap,从字面意思可以看出一定的数据结构,是基于哈希表(散列表结构)的 Map 接口的非同步实现,允许使用 null 值和 null 键。HashMap 不保证映射的顺序,特别是它不保证该顺序恒久不变。至于为什么呢?来轻轻地看看HashMap 的数据结构:

啊噶啦哇呀的博客 1124

GPS-SDR-SIM使用详解

GPS-SDR-SIM 是一款开源工具,能够生成 GPS 基带信号数据流,这些数据流可通过软件定义无线电(SDR)平台(如 ADALM-Pluto、bladeRF、HackRF、USRP 等)转换为射频(RF)信号。简单来说,它能模拟 GPS 卫星信号,帮助开发者或爱好者测试 GPS 接收设备的性能,而无需依赖真实的卫星信号。

qq_35621280的博客 1243

Java中集合详解,带你了解各个集合的底层原理。

在调用hashMap的put方法时,会先把当前的key传入到HashMap的hash方法之中,利用hashmap的hash算法,计算出一个值,这个值就是元素在数组中的位置,然后再把key和value存储在一个entry对象中,判断当前的数组中是否存在元素,若存在元素了,再判断当前key的原始值和存在元素的元素值,若一致则覆盖,不一致则将元素放入链表的尾部存储。在java7中,HashMap是由数组+链表的形式存储数据的,在java8中,HashMap是由数组+链表+红黑树形式存储数据的。

只为code醉的博客 1551

1020空心杯电机驱动设计与ESP32实战

空心杯电机是一种高动态响应的直流微特电机,其驱动本质是解决电感负载下的大di/dt启动、反电动势耦合与电流纹波抑制问题。核心原理在于建立包含内阻、电感和反电动势的等效电路模型,并据此匹配开关器件、PWM参数与采样闭环。技术价值体现在小体积下实现毫秒级响应、低噪声(>30kHz)、高精度电流保护(±50mA)及热鲁棒性。典型应用于微型航模、手持云台与精密执行器等对功率密度和动态性能敏感的嵌入式系统。本文以1020规格空心杯电机为对象,基于ESP32平台完成从MOSFET选型、32kHz硬件PWM生成到INA2

weixin_42298164的博客 593

【深大算法设计与分析】实验六 最大流应用问题(棒球赛问题) 实验报告 附代码、数据集

【内附代码与数据集】【深大算法设计与分析】实验六 最大流应用问题(棒球赛问题)

m0_74268508的博客 1295

Java集合类原理详解

文章目录1 集合框架1.1 集合框架概述1.1.1 容器简介1.1.1 容器的分类1.2 Collection1.2.1 常用方法1.2.2 迭代器1.3 List1.3.1 概述1.3.2 常用方法 1 集合框架 1.1 集合框架概述 1.1.1 容器简介 到目前为止,我们已经学习了如何创建多个不同的对象,定义了这些对象以后,我们就可以利用它们来做一些有意义的事情。 举例来说,假设要存储许多雇员,不同的雇员的区别仅在于雇员的身份证号。我们可以通过身份证号来顺序存储每个雇员,但是在内存中实现呢?是不是要准备

liaowenxiong的博客 1370

核心组件大换血:Backbone与Neck魔改篇:YOLO26结合StarNet结构:2026星状网络在YOLO生态的即插即用实战

本文将介绍如何将StarNet作为Backbone替换YOLO26原生架构,以提升边缘设备上的目标检测性能。文章首先分析了YOLO26在特定场景下的精度瓶颈,指出其通用Backbone设计存在不足。随后深入解析StarNet的核心创新——星操作(Star Operation),这一低维计算却能获得高维特征表达的数学魔术,以及其极简的StarBlock模块设计。通过对比YOLO26原生架构的三大创新与痛点,作者提出两种替换策略:完整替换Backbone或局部替换+Neck联调。文中提供了StarNet核心代码

ZDQ58818的博客 290

一篇搞定Java集合类原理

Java集合类实现原理 1.Iterable接口 定义了迭代集合的迭代方法 iterator() forEach() 对1.8的Lambda表达式提供了支持 2. Collection接口 定义了集合添加的通用方法 int size(); boolean isEmpty(); boolean contains(); boolean add() boolean addAll() boolean remove() removeAll() Object[] toArray() 3.List接

qq_42760613的博客 369

小米15修复“NV损坏” 去除主板校验电阻步骤解析与图示

小米15系列将搭载骁龙8至尊版处理器,采用台积电3nm工艺。文章分析了手机出现"NV损坏"故障的表现及修复方法,包括通信异常、系统启动问题等典型症状,并介绍了去除主板校验电阻和刷写工程固件两种修复方案。重点讲解了去除主板电阻后刷写QCN文件的操作流程,强调在维修过程中需要结合分析与思考。适用于小米15系列特定机型(24129PN74G/I/C)的硬件修复。

小马哥的专栏 315

【Google Play 上架】内部 / 封闭 / 开放 测试全解 — “只跑一个就能上架”?不行!

Google Play新规要求个人开发者账号在2023年11月13日后必须通过封闭测试(Closed testing)才能上架应用。封闭测试需要至少12名测试者连续14天保持参与状态,而内部测试和开放测试不能替代这一要求。三类测试轨道各有特点:内部测试用于快速内部验证,封闭测试是上架必经环节,开放测试面向更广泛用户但非必需。上架流程建议先内部测试修复问题,再启动封闭测试满足14天要求,最后申请生产发布。组织账号和早期个人账号可能不受此限制。开发者应提前规划测试人群,确保持续测试周期,并关注Play Cons

技术小甜甜:传播可落地技术,帮助个人和企业降低解决真实场景问题的成本 2803

Java基础之集合实现类

ArrayList、LinkedList、Vector 它们三都实现了list接口,首先都是有序的、可重复的,可变数组 一.ArrayList:最为常用的list接口实现类 ①首先是线程不安全的,所以效率较高 ②底层是Object[ ] elementdata 数组,所以适合于多查询的场景 在jdk1.7中: new ArrayList():默认声明一个长为10的数组 add()方法:添加一个超过容量的对象时,默认的扩容机制是:1.5n(n为原来容量) 在jdk1.8中: new Arra

weixin_56674682的博客 532

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

java 底层的实现_Java集合类,从源码解析底层实现原理

Java集合类,从源码解析底层实现原理Java集合类,从源码解析底层实现原理为什么80%的码农都做不了架构师?>>>总体框架Java之一致性hash算法原理及实现下面对上面的文章做一下总结,一些在上面文章中没有涉及到的点,在详细的说明一下。Set和Map的关系Set代表一种无序不可重复的集合,Map代表一种由多个Key-Value对组成的集合。表面上看它们之间似乎没有啥关系,但是...

weixin_39835607的博客 218

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

java 对象数组 多个列 存值_Java集合类实现原理

Java集合类实现原理1.Iterable接口定义了迭代集合的迭代方法iterator() forEach() 对1.8的Lambda表达式提供了支持 2. Collection接口定义了集合添加的通用方法int size(); boolean isEmpty(); boolean contains(); boolean add() boolean addAll() boolean remove(...

weixin_36462845的博客 511

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

java集合类实现原理,Java 集合类实现原理

转载自:http://blog.youkuaiyun.com/qq_25868207/article/details/55259978ArrayList是List接口的可变数组非同步实现,并允许包括null在内的所有元素。底层使用数组实现该集合是可变长度数组,数组扩容时,会将老数组中的元素重新拷贝一份到新的数组中,每次数组容量增长大约是其容量的1.5倍,这种操作的代价很高。采用了Fail-Fast机制,面对并...

weixin_30529479的博客 190

java集合类实现原理_Java 集合类实现原理

转载自:http://blog.youkuaiyun.com/qq_25868207/article/details/55259978ArrayList是List接口的可变数组非同步实现,并允许包括null在内的所有元素。底层使用数组实现该集合是可变长度数组,数组扩容时,会将老数组中的元素重新拷贝一份到新的数组中,每次数组容量增长大约是其容量的1.5倍,这种操作的代价很高。采用了Fail-Fast机制,面对并...

weixin_32026659的博客 220

Java的集合类以及hashMap的实现原理

Java集合类 Collection List ArrayList LinkedList Vector Set HashSet LinkedHashSet SortedSet TreeSet Map HashMap HashTable WeakHashMap Collection是所有集合类的根接口,其被

北京叮咚的博客 463

【Java集合类】HashMap实现原理

ConcurrentHashMap将哈希表分成多个段,每个段拥有一个独立的锁,这样可以在多个线程同时访问哈希表时,只需要锁住需要操作的那个段,而不是整个哈希表,从而提高了并发性能。简单点说,就是为了把高位的特征和低位的特征组合起来,降低哈希冲突的概率,也就是说,尽量做到任何一位的变化都能对最终得到的结果产生影响。,即将哈希表分成多个段,每个段拥有一个独立的锁。当上面的操作完结后,HashMap会检测两个链表的长度,当元素小于等于6的时候,就会执行取消树化的操作,否则就会将新生成的链表重新树化。

xueping_wu的博客 758

QPST底层原理与高通9008模式深度解析

QPST(Qualcomm Product Support Tools)是高通SoC设备底层调试与固件烧录的核心工具集,其本质是EDL(Emergency Download Mode)协议的可视化封装。理解QPST需从USB通信协议、Firehose命令栈、eMMC多LUN分区映射及GPT结构出发——它并非普通刷机软件,而是连接PC与高通Boot ROM的协议桥梁。技术价值在于提供产线级稳定烧录能力、单分区精准修复能力以及绕过AVB/dm-verity等安全校验的底层访问权限。典型应用场景包括全分区线刷、m

weixin_34187862的博客 279

Java集合类HashMap实现原理

HashMap的一些特性: 1.能存储键值对; 2.接收null键或null值; 3.无需定义其长度,自动扩容,通过put方法存储键值对,通过get()获得key对应的值 4.存储是无序的,即打印出所有键值对时无法按照放入的顺序打印出来; 5.key不能重复,重复的key后入的替换前入的键值对。 这些特性是由其数据结构和内部处理逻辑决定的,通过研读其源码,我们可以深刻理解HashMap

没标题 483

经典面试题1(Java 的集合类,HashMap 的实现原理)

主要分为:set list mapJava容器分为Collection 和 Map 两大类,其中Collection集合的子接口有Set、List、Queue三种子接口,Map也是一个接口,但是不是Collection的子接口。List:一个有序容器,元素可以重复,可以插入多个null元素,元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。Set:一个无序容器,不可以存储重复元素,只允许存入一个null元素,必须保证元素唯一性。

qq_52485934的博客 184

Java集合类,从源码解析底层实现原理

总体框架 Java集合总体框架及主要接口,抽象类分析 ArrayList底层实现和原理 Vector底层实现和原理 LinkedList底层实现和原理(也是queue的实现) ConcurrentLinkedQueue底层实现和原理(常用于并发编程) HashSet底层实现(是由HashMap实现)和原理 TreeSet底层实现(是由TreeMap实现)和原理 HashMap底...

xjanting的博客 1028

Java多线程编程深入解析并发集合类的实现原理与应用场景

Java并发集合类通过不同的并发控制机制(分段锁、CAS、写时复制等)提供了高效的线程安全集合解决方案。在实际应用中,开发者需要根据具体的业务场景、读写比例和性能要求选择合适的并发集合类,以达到最佳的性能和可靠性平衡。在Java多线程编程中,传统的集合类如ArrayList、HashMap等是非线程安全的,当多个线程同时访问这些集合时可能会导致数据不一致或程序异常。为了解决这个问题,Java在java.util.concurrent包中提供了一系列线程安全的并发集合类。// 链表或红黑树插入操作。

pvfzulOA的博客 644

Java集合类补充—Set中实现元素不重复的原理

刚开始写Java集合类中的Set的时候,只知道要是让存入的元素不重复,必须实现hashCode和equals方法,但是当时不知道原因,最近看到一篇文章就是介绍这个的,拿出来分享一下点击打开链接

孟祥月的专栏 6756

java 集合类 原理以及实现--ArrayList

ArrayList 是数组实现并可以自动扩容的数组集合模式 具体实现如下: /**  * 自己实现的ArrayList 没有用到泛型,只是一个模拟 原理  * @author jiang  *  */ public class MyArrayList { //定义一个数组 用于装在数据 Object[] elementData; //数组实际大小 有数据的 private i

o11111112345的博客 159

JAVA - 集合类 - List - ArrayList 实现原理

ArrayList 实现原理

代码能让我保持心静,心静能让我保持动力 212
上一篇: Android 序列化 Parcelable VS Serializable
下一篇: ListView 源码解析
任教主来也
博客等级 码龄11年 12粉丝 28原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值