Java集合类及内部部分实现浅析

最新推荐文章于 2025-01-15 16:35:39 发布
转载 最新推荐文章于 2025-01-15 16:35:39 发布 · 2k 阅读 · 1

本文深入探讨Java集合框架的内部实现，包括List、Set、Map的主要类型及其特性。详细解析了ArrayList、LinkedList、HashSet、TreeSet、HashMap等核心类的运作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java集合类的简单结构图：



事实上Collection的父接口为 Iterable

目的：简单的了解一下Java常用集合的特性以及内部实现。
参考博客： http://blog.sina.com.cn/s/blog_3fba24680100y2yr.html
常用List集合：
特性：
有顺序的，元素可以重复；
遍历：for，迭代；
排序：Comparable Comparator Collections.sort()
ArrayList：
用数组实现的List；
特点：查询效率高，增删效率低 轻量级 线程不安全；
部分源码分析：
构造：
Java代码
  1. private transient Object[] elementData;
  3. public ArrayList(int initialCapacity) {
  4. super();
  5. if (initialCapacity < 0)
  6. throw new IllegalArgumentException("Illegal Capacity: "+
  7. initialCapacity);
  8. this.elementData = new Object[initialCapacity];
  9. }
  11. public ArrayList() {
  12. this(10);
  13. } 
    private transient Object[] elementData;
    
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

    public ArrayList() {
        this(10);
    }

这段源代码表示的是一个ArrayList的内部实现为一个Object数组，重载的两个构造方法，默认长度为10。
增加元素：
Java代码
  1. public boolean add(E e) {
  2. ensureCapacityInternal(size + 1); // Increments modCount!!
  3. elementData[size++] = e;
  4. return true;
  5. }
  7. public boolean addAll(Collection<? extends E> c) {
  8. Object[] a = c.toArray();
  9. int numNew = a.length;
  10. ensureCapacityInternal(size + numNew); // Increments modCount
  11. System.arraycopy(a, 0, elementData, size, numNew);
  12. size += numNew;
  13. return numNew != 0;
  14. } 
     public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

添加对象的代码块，size表示数组长度。后一个为添加集合对象的代码块。

删除元素：
Java代码
  1. public E remove(int index) {
  2. rangeCheck(index);
  4. modCount++;
  5. E oldValue = elementData(index);
  7. int numMoved = size - index - 1;
  8. if (numMoved > 0)
  9. System.arraycopy(elementData, index+1, elementData, index,
  10. numMoved);
  11. elementData[--size] = null; // Let gc do its work
  13. return oldValue;
  14. } 
     public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // Let gc do its work

        return oldValue;
    }

首先检查下标是否越界，List删除后会自懂向前移动下标向前移动一位又是通过 System.arraycopy(elementData, index+1, elementData, index,numMoved);来实现。

那么ArrayList是怎么实现容量自增的呢？
ensureCapacityInternal(size+numNew)表示数组容量的自增函数，调用下面的函数：
Java代码
  1. private void grow(int minCapacity) {
  2. // overflow-conscious code
  3. int oldCapacity = elementData.length;
  4. int newCapacity = oldCapacity + (oldCapacity >> 1);
  5. if (newCapacity - minCapacity < 0)
  6. newCapacity = minCapacity;
  7. if (newCapacity - MAX_ARRAY_SIZE > 0)
  8. newCapacity = hugeCapacity(minCapacity);
  9. // minCapacity is usually close to size, so this is a win:
  10. elementData = Arrays.copyOf(elementData, newCapacity);
  11. } 
     private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


LinkedList：
底层用双向循环链表实现的List；
特点：查询效率低，增删效率高；
构造：
Java代码
  1. transient Node<E> first;
  2. transient Node<E> last;
  3. public LinkedList() {
  4. }
  5. public LinkedList(Collection<? extends E> c) {
  6. this();
  7. addAll(c);
  8. } 
    transient Node<E> first;
    transient Node<E> last;
    public LinkedList() {
    }
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

对于定义来说没有数组，却有个Node对象来看看静态内部类Node的结构：
Java代码
  1. private static class Node<E> {
  2. E item;
  3. Node<E> next;
  4. Node<E> prev;
  6. Node(Node<E> prev, E element, Node<E> next) {
  7. this.item = element;
  8. this.next = next;
  9. this.prev = prev;
  10. }
  11. } 
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

双向链表结构更像是一群牵着手的孩子只知道前后是谁。

添加元素：
Java代码
  1. void linkLast(E e) {
  2. final Node<E> l = last;
  3. final Node<E> newNode = new Node<>(l, e, null);
  4. last = newNode;
  5. if (l == null)
  6. first = newNode;
  7. else
  8. l.next = newNode;
  9. size++;
  10. modCount++;
  11. } 
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

就是一个Node持有另个一Node的引用，形成以个链条。
删除元素：
Java代码
  1. E unlink(Node<E> x) {
  2. // assert x != null;
  3. final E element = x.item;
  4. final Node<E> next = x.next;
  5. final Node<E> prev = x.prev;
  7. if (prev == null) {
  8. first = next;
  9. } else {
  10. prev.next = next;
  11. x.prev = null;
  12. }
  14. if (next == null) {
  15. last = prev;
  16. } else {
  17. next.prev = prev;
  18. x.next = null;
  19. }
  21. x.item = null;
  22. size--;
  23. modCount++;
  24. return element; 
     E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

先找到元素再赋值为null，并接上前面的。
Vector:
底层用数组实现List接口的另一个类；
特点：重量级，占据更多的系统开销，线程安全；
Vector与ArrayList基本上一致，最大的差别于在一些方法上使用了synchronized关键字，使其变成线程安全。

----------------------------------------------------------------------------------

Set：
无顺序的，元素不可重复（值不相同）；
遍历：迭代；
排序：SortedSet
HashSet：
采用哈希算法来实现Set接口；
唯一性保证：重复对象equals方法返回为true；
重复对象hashCode方法返回相同的整数，不同对象hashCode尽量保证不同（提高效率）；
构造：
Java代码
  1. private transient HashMap<E,Object> map;
  2. private static final Object PRESENT = new Object();
  3. public HashSet() {
  4. map = new HashMap<>();
  5. } 
    private transient HashMap<E,Object> map;
    private static final Object PRESENT = new Object();
     public HashSet() {
        map = new HashMap<>();
    }

实际上的HashSet内部的实现为一个HashMap(下面看看HashMap的组成)。
添加元素：
Java代码
  1. public boolean add(E e) {
  2. return map.put(e, PRESENT)==null;
  3. } 
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

由源代码块可以看出HashSet添加一个元素时，添加的值为HashMap的Key值，而一个Object对象却为一个Value值。

删除元素：
Java代码
  1. public boolean remove(Object o) {
  2. return map.remove(o)==PRESENT;
  3. } 
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

那么HashSet无序不重复的属性则来自于HashMap。
TreeSet：
在元素添加的同时，进行排序。也要给出排序规则；
唯一性保证：根据排序规则，compareTo方法返回为0，就可以认定两个对象中有一个是重复对象。
结构：
Java代码
  1. private transient NavigableMap<E,Object> m;
  2. private static final Object PRESENT = new Object(); 
    private transient NavigableMap<E,Object> m;
    private static final Object PRESENT = new Object();

----------------------------------------------------------------------------------

Map：
元素是键值对：key唯一不可重复，value可重复；
遍历：先迭代遍历key的集合，再根据key得到value；
SortedMap：元素自动对key排序
HashMap:
轻量级，线程不安全，允许key或者value是null；
构造：
Java代码
  1. transient Entry[] table;
  2. public HashMap(int initialCapacity, float loadFactor) {
  3. if (initialCapacity < 0)
  4. throw new IllegalArgumentException("Illegal initial capacity: " +
  5. initialCapacity);
  6. if (initialCapacity > MAXIMUM_CAPACITY)
  7. initialCapacity = MAXIMUM_CAPACITY;
  8. if (loadFactor <= 0 || Float.isNaN(loadFactor))
  9. throw new IllegalArgumentException("Illegal load factor: " +
  10. loadFactor);
  12. // Find a power of 2 >= initialCapacity
  13. int capacity = 1;
  14. while (capacity < initialCapacity)
  15. capacity <<= 1;
  17. this.loadFactor = loadFactor;
  18. threshold = (int)(capacity * loadFactor);
  19. [color=red]table = new Entry[capacity];[/color]
  20. init();
  21. } 
    transient Entry[] table;
       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);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        [color=red]table = new Entry[capacity];[/color]
        init();
    }

从构造方法分可以看出其为一个Entry数组
Entry主要属性：
Java代码
  1. final K key;
  2. V value;
  3. Entry<K,V> next; 
     final K key;
        V value;
        Entry<K,V> next;

该源码片段可以看出Entry以及key值一旦赋值就无法更改。
添加元素：
Java代码
  1. public V put(K key, V value) {
  2. if (key == null)
  3. return putForNullKey(value);
  4. int hash = hash(key.hashCode());
  5. int i = indexFor(hash, table.length);
  6. for (Entry<K,V> e = table[i]; e != null; e = e.next) {
  7. Object k;
  8. if ([color=red]e.hash == hash && ((k = e.key) == key || key.equals(k)[/color])) {
  9. V oldValue = e.value;
  10. e.value = value;
  11. e.recordAccess(this);
  12. return oldValue;
  13. }
  14. }
  16. modCount++;
  17. addEntry(hash, key, value, i);
  18. return null; 
      public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if ([color=red]e.hash == hash && ((k = e.key) == key || key.equals(k)[/color])) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

红色部分对于重复对象的比较，使用了key的hashcode，key指向的地址，以及其值是否相等。
容量自增：
Java代码
  1. void resize(int newCapacity) {
  2. Entry[] oldTable = table;
  3. int oldCapacity = oldTable.length;
  4. if (oldCapacity == MAXIMUM_CAPACITY) {
  5. threshold = Integer.MAX_VALUE;
  6. return;
  7. }
  9. Entry[] newTable = new Entry[newCapacity];
  10. transfer(newTable);
  11. table = newTable;
  12. threshold = (int)(newCapacity * loadFactor);
  13. } 
   void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }


Hashtable：
重量级，线程安全，不允许key或者value是null；
从源码可以看出与HashMap很相识，这是Hashmap为其轻量级的实现。
大量带有实际操作性的方法都为synchronized修饰。
Properties：Hashtable的子类，key和value都是String，同样为线程安全。
Java代码
  1. public synchronized Object setProperty(String key, String value) {
  2. return put(key, value);
  3. } 
   public synchronized Object setProperty(String key, String value) {
        return put(key, value);
    }

TreeMap：
集合是指一个对象可以容纳了多个对象（不是引用），这个集合对象主要用来管理维护一系列相似的对象。
USTCZYY
关注
【Java集合】Java集合类框架相关的面试题
weixin_54707168的博客
03-22 219
【Java集合】Java集合类框架相关的面试题
Java 集合-实现原理总结
啊噶啦哇呀的博客
11-15 1040
HashMap，从字面意思可以看出一定的数据结构，是基于哈希表（散列表结构）的 Map 接口的非同步实现，允许使用 null 值和 null 键。HashMap 不保证映射的顺序，特别是它不保证该顺序恒久不变。至于为什么呢？来轻轻地看看HashMap 的数据结构：
JAVA 常用集合内部机制原理
进击的程序猿
05-20 303
对于常用的集合大家都不陌生，但是深入到内部原理可能都是一知半解，通过阅读源码理解如下。   ArrayList： ArrayList内部就是一个默认大小为10的动态对象数组容器，每当add一个新数据的时候，如果大于原来的容器大小，则会通过Arrays.copyOf把容器大小增加到原来的1.5倍，以此类推。当可以预知数据大小，可以通过initialCapacity来默认设置动态数据的大小，...
Java集合详解——内部实现方法与原则
冯宝宝
03-27 530
Java中集合框架的实现遵循的是设计与实现分离，具体的实现方式是通过接口编程实现的；接口定义集合规范，具体的实现类通过不同的方式实现操作——比如Queue可以通过循环数组和链表两种方式实现，具体内容在后边详细介绍； Collection接口 Java中集合类的基本接口是Collection接口：Collection主要规定了两个方法（其余方法在之后介绍）： public interface...
java 各集合的底层原理实现
renjingkai的博客
07-26 3594
参考链接，很详细
Java不可变类机制浅析
08-31
Java中的不可变类机制是一种设计模式，用于创建对象在创建后其状态无法改变的类。不可变类在多线程环境中特别有用，因为它们天生线程安全，无需额外的同步措施。不可变类的一些典型例子包括`Integer`、`Long`和`...
Java集合类实现整理及Concurrent并发包整理总结(CAS,AQS)
Tiger的专栏
08-05 568
目录 ​ 1.集合包 1.1 ArrayList 1.2 LinkedList 1.3 Vector 1.4 Stack 1.5 HashSet 1.6 TreeSet 1.7HashMap 1.8 TreeMap 2.并发包 2.1ConcurrentHashMap 2.2 ReentrantLock 2.3 Condition 2.4 CopyOnWriteArrayList 2.5 CopyOnWriteArraySet 2.6 ArrayBlockingQueu..
浅析ArrayList内部实现
12-31
浅析ArrayList内部实现 ArrayList是Java集合框架中的一种常用数据结构，能够存储任意多个对象，并且可以自由扩展，弥补了数组的定长的缺陷。下面我们将深入探讨ArrayList的内部实现机理。 ArrayList的内部实现机理...
浅析Java抽象类与接口的区别.zip
10-16
在Java编程语言中，抽象类和接口是两种重要的面向对象设计概念，它们都用于实现多态性，但各自具有不同的特点和应用场景。本篇文章将详细分析这两种机制的区别，以帮助开发者更好地理解和运用。 首先，抽象类是类的...
java 释放数组_java集合ArrayList中clear方法内存释放分析
weixin_36308404的博客
02-12 1453
最近在看ArrayList源码的时候看到了ArrayList的clear方法，源码如下：public void clear() {modCount++;// clear to let GC do its workfor (int i = 0; i < size; i++)elementData[i] = null;size = 0;}在看到这段代码的时候联想到内存释放的问题如下代码：List...
面试官：Redis中有序集合的内部实现方式是什么？
万猫学社
03-10 2133
面试官：Redis中基本的数据类型有哪些？ 我：Redis的基本数据类型有：字符串（string）、哈希（hash）、列表（list）、集合（set）、有序集合（zset）。 面试官：有序集合的内部实现方式是什么？ 我还沉浸在上一个问题的沾沾自喜中，顿时表情凝固了，手心开始冒出冷汗。“这个。。没有太深入了解”，我支支吾吾的说到。 面试官：回去等消息吧。 这句话说的干净利落，然后就没有然后了。失败是成功的妈妈，我不气馁，决定马上恶补一下。 有序集合的内部实现 有序集合的内部实现有两种，分别是：压缩.
【Java集合的使用以及部分底层实现】
最新发布
weixin_63309304的博客
01-15 1005
无论前方等待我们的是什么，让我们保持勇气和决心，一路向前！
java集合ArrayList中clear方法内存释放分析
热门推荐
xinguopeng的博客
09-02 2万+
最近在看ArrayList源码的时候看到了ArrayList的clear方法，源码如下： public void clear() { modCount++; // clear to let GC do its work for (int i = 0; i < size; i++) elementData[i] = nu...
java常用集合类原理
asd804171023的博客
09-09 573
以下集合讲解没有指定jdk版本默认都是jdk8 ArrayList 线程不安全。 基于一个Object[]数组实现,默认数组是个空数组,可以插入空数据，可以随机访问。如果要找到是否存在某个值，需要遍历数组匹配，时间复杂度是O(n)。由于通过存放的是动态数组，arrayList重写序列化方法readObject和writeObject，只序列化有值的数组位置。 add(E e)添加元素方法：...
ArrayList源码解析（JDK1.8）-逐行代码分析
yphust的博客
08-19 694
文章目录类图内部参数构造方法ArrayList()ArrayList(int initialCapacity)ArrayList（Collection c）常用方法解析add(E e)ensureCapacityInternalensureExplicitCapacitygrowddAll(Collection<? extends E> c)addAll(int index, Collection<? extends E> c)get(int index)E elementData(
JAVA集合框架中的常用集合及其特点、适用场景、实现原理简介
Summer_YuXia的博客
05-02 1909
JDK提供了大量优秀的集合实现供开发者使用，合格的程序员必须要能够通过功能场景和性能需求选用最合适的集合，这就要求开发者必须熟悉Java的常用集合类。本文将就Java Collections Framework中常用的集合及其特点、适用场景、实现原理进行介绍，供学习者参考。当然，要真正深入理解Java的集合实现，还是要推荐去阅读JDK的源码。 Java提供的众多集合类由两大接口衍生而来：Co
List集合底层实现
JAVA_Admin_User的博客
09-20 1万+
1.List： List实现Collection接口，它的数据结构是有序可以重复的结合，该结合的体系有索引；它有三个实现类：ArrayList、LinkList、Vector三个实现类； 三个实现类的区别： ArrayList:底层数据结构使数组结构，查询速度快，增删改慢， LinkList:底层使用链表结构，增删速度快，查询稍慢； Vector：底层是数组结构，线程同步ArrayL
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值