集合源码解析——Collection接口

最新推荐文章于 2022-12-12 09:07:40 发布
最新推荐文章于 2022-12-12 09:07:40 发布
阅读量108 收藏
点赞数
分类专栏： 数据结构与算法 java核心 文章标签： java 数据结构 链表 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z958479/article/details/109298340
版权

Collection接口

在这里插入图片描述

List接口
ArrayList

Array本质就是数组，在内部对数组进行动态扩容

	/**
     * Default initial capacity.
     * 数组默认长度
     */
    private static final int DEFAULT_CAPACITY = 10;
    
    /**
     * Shared empty array instance used for empty instances.
     * 空数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     * 默认的空数组
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     * 内部存储数据元素的 数组对象
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     * 
     * @serial 集合中元素的个数
     */
    private int size;
初始化

无参构造

public ArrayList() {
   this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
   //this.elementData={};
}

有参构造

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
        	//创建指定长度的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
            //this.elementData={};
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
add方法

第一次添加

public boolean add(E e) {
	//确定容量 动态扩容
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   //将要添加的元素 添加到数组0的位置，size=1
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
   ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
 	//如果无参构造 elementData={} 
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    	// 10 ,1 return 10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //有参构造，返回指定的长度
    return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++; //操作次数 自增

    // minCapacity=10 - 0=10
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {//10
	// overflow-conscious code
    int oldCapacity = elementData.length;//0
    // 0+0=0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //0-10= -10
    if (newCapacity - minCapacity < 0)
    	//newCapacity =10
        newCapacity = minCapacity;
    // 10 - (Integer.MAX_VALUE - 8)
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 创建一个长度为10的数组，将原来数组的值copy进去
    elementData = Arrays.copyOf(elementData, newCapacity);
}

第2次添加

public boolean add(E e) {
	//确定容量 动态扩容
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   //将要添加的元素 添加到数组1的位置，size=2
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {//2
   ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //返回 2
    return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {//2
    modCount++; //操作次数 自增

    // minCapacity= 2 - 10
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

第11次添加

public boolean add(E e) {
	//确定容量 动态扩容
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   //将要添加的元素 添加到数组10的位置，size=11
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {//11
   ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {//11
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //返回 11
    return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {//11
    modCount++; //操作次数 自增

    // minCapacity= 11 - 10
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {//11
	// overflow-conscious code
    int oldCapacity = elementData.length;//10
    // 10 +5 =15  1010 >> 1 = 101 = 5
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //15 - 11 = 4, 跳过，跳过
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 创建一个长度为15的数组，将原来数组的值copy进去
    elementData = Arrays.copyOf(elementData, newCapacity);
}
get方法
  public E get(int index) {
  	//检查下标是否合法
   rangeCheck(index);
	//通过下标获取数组元素
   return elementData(index);
}
private void rangeCheck(int index) {
  if (index >= size)
      throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
set方法
public E set(int index, E element) {
	//检查下标是否合法
   rangeCheck(index);
	//获取下标原来的值
   E oldValue = elementData(index);
   //新值赋值到下标位置
   elementData[index] = element;
   //返回原来的值
   return oldValue;
}
reomve方法
public E remove(int index) {
	//检查下标是否合法
   rangeCheck(index);

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

	//计算移动次数
   int numMoved = size - index - 1;
   //次数大于0
   if (numMoved > 0)
   		//原数组，开始下标，目标数组，开始下标，长度
   		//把index+1后面的numMoved个元素复制到index的位置
       System.arraycopy(elementData, index+1, elementData, index,
                        numMoved);
   //空出的位置设置为null
   elementData[--size] = null; // clear to let GC do its work
	//返回删除的值
   return oldValue;
}
LinkedList

LinkedList是通过双向链表实现的，具有双向链表的优缺点。顺序访问效率很高，随机访问效率比较低。它包含一个重要的私有内部静态类：Node。

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;
    }
}
push方法
public void push(E e) {
	addFirst(e);
}
public void addFirst(E e) {
  linkFirst(e);
}
private void linkFirst(E e) {
   	final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}
add方法
public boolean add(E e) {
  linkLast(e);
    return true;
}
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++;
}
get方法
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
private void checkElementIndex(int index) {
  if (!isElementIndex(index))
      throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
Node<E> node(int index) {
    //assert isElementIndex(index);
	//index < size的一半，在前半部分
    if (index < (size >> 1)) {
        Node<E> x = first;
        //从头循环
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        //从尾部循环
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}
set方法
public E set(int index, E element) {
	//检查下标是否合法
    checkElementIndex(index);
    //根据下标获取对应的对象
    Node<E> x = node(index);
    //记录原来的值
    E oldVal = x.item;
    //设置新的值
    x.item = element;
    //返回原来的值
    return oldVal;
}
Vector

和ArrayList类似，以动态数组的方式存储数据。Vector线程安全。每一个操作方法都加synchronized。灵活度低。
保证数据安全可以使用Collections工具类中的synchronizedxxx()方法实现。

Set接口
HashSet

底层数据结构时哈希表（哈希表不保证set的迭代顺序，特别是不保证数据永久不变），HashSet本质是一个没有重复元素的集合，允许null值。是通过HashMap实现的。HashSet中维护了一个HashMap类型的成员变量。

private transient HashMap<E,Object> map;
初始化
public HashSet() {
  map = new HashMap<>();
}
add方法
 public boolean add(E e) {
    return map.put(e, PRESENT)==null;
 }

本质是将数据保存到HashMap中，key 就是保存的内容，value是内部定义的一个Object对象。

TreeSet

基于TreeMap的NavigableSet实现。使用元素的自然顺序对元素进行排序，或者根据创建TreeSet时指定的Compartor进行排序

初始化
 public TreeSet() {
    this(new TreeMap<E,Object>());
  }
add方法
public boolean add(E e) {
    return m.put(e, PRESENT)==null;
 }

本质是将数据保存到TreeMap中，key 就是保存的内容，value是内部定义的一个Object对象。

集合中的FailFast机制

java集合类为了应对并发访问，在集合迭代过程中，内部结构发生变化的一种防护措施，这种错误检查机制，为这种可能发生的错误，通过抛出java.util.ConcurrentModifycationException处理。

//迭代前，把修改次数赋值给变量expectedModCount
int expectedModCount = modCount;
public E next() {
    checkForComodification();
    int i = cursor;
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;
    return (E) elementData[lastRet = i];
}
final void checkForComodification() {
	//如果迭代过程中两个变量值不相等，说明集合被修改
	if (modCount != expectedModCount)
       throw new ConcurrentModificationException();
}
桀..
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础学习笔记-集合、Collection、List、ArrayList
知梦的博客
11-04 304
集合概述 集合是一个大小可变的容器，容器中的每个数据称为一个元素 集合特点：类型可以不确定，大小不固定；集合有很多，不同的集合特点和使用场景不同 数组：类型和长度一旦定义出来就都固定 作用： 在开发中，很多时候元素的个数是不确定的 而且经常要进行元素的增删该查操作，集合都是非常合适的，开发中集合用的更多 存储结构 数据结构指的是数据以什么方式组织在一起，不同的数据结构，增删查的性能是不一样的 数据存储的常用结构有：栈、队列、数组、链表和红黑树 队列（queue）：先进先出，后进后出。(
collectionJava源码-auto:Java的源代码生成器集合
05-19
《CollectionJava源码解析——深度探索Java的自动代码生成器》 在Java开发过程中，代码生成器是一个重要的工具，它可以极大地提高开发效率，减少重复工作。"collectionJava源码-auto"项目就是一个专注于Java源码...
Java的集合嵌套用法
weixin_44691025的博客
05-31 3080
集合的嵌套用法 对于集合的嵌套用法，我们可以简单的化为三类，list嵌套list，list嵌套map，map嵌套map。 对于集合嵌套的赋值，我们采用由里向外赋值，对于取值相反，取值时由外向里。 1.list嵌套map 我们举map中有list的形式，即map的key为引用类型，value为list，可以写成 Map<String ,List<Person>> map =new HashMap<>(); 前面说了我们赋值时由里向外，什么是由里向外呐，就是先对里边
Collection集合,List集合,数据类型和ArrayList集合
weixin_43100458的博客
10-18 335
Collection集合,List集合,数据类型和ArrayList集合1.1 集合的概述1.2 Collection集合1.2.1 创建Collection集合对象并添加元素1.2.2 Collection集合的成员方法1.2.3 Collection集合的遍历2.1 List集合的特点2.2 List集合的特有成员方法 1.1 集合的概述 集合是一个容器,是用来存储和获取数据的. 1.2 Collection集合 1.2.1 创建Collection集合对象并添加元素 Collection:是单
Collection-List-ArrayList
weixin_53310322的博客
01-20 606
Collection-List-ArrayList1.List接口概念2.ArrayList2.1类结构2.2方法解析2.2.1构造函数2.2.1.1 public ArrayList(int initialCapacity)2.2.1.2 public ArrayList()2.2.1.3 public ArrayList(Collection<? extends E> c)2.2.2 一些常用的构造方法2.2.2.1 add（E e）2.2.2.2 add(int index, E elem
Collection、List、ArrayList、LinkedList的简单学习
weixin_58694902的博客
08-02 116
}Person person1 = new Person("张三", 23);Person person2 = new Person("李四", 23);Person person3 = new Person("王五", 23);Person person4 = new Person("周六", 23);​}}​。
java——ArrayList-源码解析.docx
05-09
ArrayList 是 Java 中常用的集合类，它是 List 接口的一个实现，基于数组进行操作。ArrayList 的设计使得元素可以动态地添加和删除，同时提供了对数组大小的灵活调整。它实现了 ICollection 和 IList 接口，提供了...
Backbone标准例子——通讯录
04-18
4. **集合（Collection）**：通讯录作为一个整体，可以被看作是一个集合，包含多个联系人模型。集合提供了操作一组模型的方法，如添加、删除、排序等。 5. **视图事件**：Backbone.js的事件绑定机制允许视图监听并...
积分java源码-scala-collection-laws:为整个集合库部分自动生成测试
06-06
积分java源码scala-collection-laws ====================== 部分自动生成 Scala 集合库的测试。 目标是拥有一组准全面的集合测试，以捕获任何集合中基本功能的回归。 这些测试被表达为一系列“法则”：单行（主要）...
Java-集合嵌套
最新发布
m0_60708885的博客
12-12 389
Java-集合嵌套
C#中Collection，List和ArrayList的区别
大奔的专栏
05-18 6026
本文比较了Collection, List和ArrayList三个类，讨论了其使用场景
Collection,List,ArrayList,LinkedList集合
cl66666666的博客
11-18 153
Collection集合 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 lJDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现 Collection集合对象 (ArrayList,LinkedList或对象) package com.itxuexi.it14.Collection01; import java.util.ArrayList; import java.util.Collection; public class Collecti
java集合数组（collection ,List，ArrayList,LinkedList）
gun_wqy的博客
03-17 756
集合数组 ArrayList<> 特点：提供了一个储存空间可变的数组 对于ArrayList来说，有一个尖括号代表泛型。 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型，String类，int类，或者自定义类 //person类自己定义的 ArrayList<Person> array = new ArrayList<Person>(); 导包：java.util.ArrayList 构造方法： （1） public ArrayList()//创建一个空的集合
java Collection与ArrayList
qq_41167962的博客
04-01 5063
一、集合的定义: 1、集合，或者叫容器，是一个包含多个元素的对象； 2、集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。 3、集合类型主要有3种：set(集）、list(列表）和map(映射) 二、ArrayList介绍： 1、创建对象 ：ArrayList al = new ArrayList(); 2...
基于Windows下的Redis使用方法
ZHAIKE的博客
10-20 220
Redis的使用学习redis的安装redis的基本数据类型 redis的安装 下载地址：https://github.com/tporadowski/redis/releases redis的基本数据类型
Collection集合分析之ArrayList
weixin_45362971的博客
06-05 131
ArrayList 基础自AbstractList 实现了List，RandomAccess，Cloneable，Serializable接口 四常量 private static final int DEFAULT_CAPACITY = 10; private static final Object[] EMPTY_ELEMENTDATA = {}; private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA
Java 基础篇学习 集合框架List与Set
瑾年的博客
11-12 172
List与SetListList简介ArrayList 初始化源码简要分析LinkedList 初始化源码简要分析List接口中的常用方法SetSet简介 List List简介     |-- Collection接口：单列集合，用了存储一个一个的对象         |— List接口：存储有序的、可重复的数据，–>“动态数组”，替换原有数组             |------ArrayList 作为List接口的主要实现类;线程不安全，效率高;底层使用的是 Object[] elementD
Collection集合--遍历List集合的五种方法
makeliwei1的博客
07-28 1630
一、总结 遍历List集合的方法 方法描述 方法一 由迭代器Iterator进行遍历 方法二 由集合定义时的泛型遍历for(T t:list) 方法三 根据索引遍历for(int i = 0;i &lt; list.size();i++) 方法四 由Java8新特性Lam表达表达：forEah(item-&gt;{}) 方法...
Java中的List集合，ArrayList与LinkList的优缺点等比较
代码届的小白的博客
11-15 891
使用List： 在集合类中，List是最基础的一种集合：它是一种有序列表。 List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始。 List的删除和添加操作，都非常的不方便，因为需要移动的元素太多了，比较费时间！ ArrayList： 因此，在实际应用中，需要增删元素的有序列表，我们使用最多的是ArrayList。实际上，ArrayList在内部使用了数组来存储所有元素。例如，一个ArrayList拥有5个元素，实
Java集合框架深度解析：Collection与Map接口详解
"该文档详细介绍了Java集合框架，涵盖了Collection和Map接口、List和Set接口的实现类，以及Map接口的子接口如HashMap、LinkedHashMap、TreeMap和Properties等。" 在Java编程中，集合框架是一个至关重要的部分，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值