List集合源码解析

于 2023-01-26 17:49:58 发布
阅读量123 收藏
点赞数 1
分类专栏： Java 相关 文章标签： list java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45432729/article/details/128764228
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

本篇文章主要讲解List集合的基本使用，初步了解一些像栈、队列等的数据结构，List集合的实现子类ArrayList、LinkedList相关源码的解析，如果本文对您有帮助，请不要吝啬您的鼓励哦，你的鼓励是我继续创作的动力。

1.List集合概述和特点

  • List集合概述
    有序集合，这里的有序指的是存取的数据。
    用户可以精确控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素。
    与set集合不同，列表通常允许重复的元素
  • List集合的特点
    存取有序
    可以重复
    有索引
  • List集合的基本使用

相关文章请阅读集合基础

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("历史上繁华的朝代");
    list.add("唐朝");
    list.add("明朝");
    list.add("清朝");
    list.add("汉朝");
    list.add("秦朝");

    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
    System.out.println("---------------------");
    for (String s : list) {
        System.out.println(s);
    }
}

1.2 List集合中特有的方法【应用】

  • 方法介绍
方法名描述
void add(int index,E element)在此集合中指定位置插入指定元素
E remove(int index)删除指定索引处的元素，返回被删除的元素
E set(int index,E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索引处的元素
  • 代码演示
 public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("历史上繁华的朝代");
        list.add("唐朝");
        list.add("明朝");
        list.add("清朝");
        list.add("汉朝");
        list.add("秦朝");
        //执行时需单个执行，方能得出以下相应结果
//        method1(list);
//        method2(list);
//        method3(list);
//        method4(list);
    }

/**
 * 演示获取集合中元素的方法
 * @param list
 */
private static void method4(List<String> list) {
    String s = list.get(0);
    System.out.println(s);//历史上繁华的朝代
}

/**
 * 演示set方法
 * @param list
 */
private static void method3(List<String> list) {
    String set = list.set(0, "历史上繁华的朝代>>>");
    System.out.println(set);//历史上繁华的朝代
    System.out.println(list);//[历史上繁华的朝代>>>, 唐朝, 明朝, 清朝, 汉朝, 秦朝]
}

/**
 * List集合中有两个删除方法
 * ① 删除指定元素值，返回一个Boolean值
 * ② 删除指定索引，返回被删除的元素
 * @param list
 */
private static void method2(List<String> list) {
    String removeRet = list.remove(0);
    //返回被删除的元素
    System.out.println(removeRet);//历史上繁华的朝代
    System.out.println(list);//[唐朝, 明朝, 清朝, 汉朝, 秦朝]

    list.add("秦朝");
    // 删除找到的第一个元素，返回值为是否删除成功
    boolean remove = list.remove("秦朝");
    System.out.println(remove);//true
    System.out.println(list);//[唐朝, 明朝, 清朝, 汉朝]
}

/**
 * 演示List集合添加元素
 * @param list
 */
private static void method1(List<String> list) {
    // 原来位置的元素会后移
    list.add(0,"秦朝");
    System.out.println(list);//[秦朝, 历史上繁华的朝代, 唐朝, 明朝, 清朝, 汉朝, 秦朝]
}

2.数据结构初步了解

2.1 常见数据结构

  • 栈结构
    先进后出，借助手枪弹夹来理解
    栈结构
  • 队列结构
    先进先出（借助排队来理解）
    数据从后端进入队列模型的过程称为：入队列
    数据从前端离开队列模型的过程称为：出队列
    在这里插入图片描述
  • 数组
    查询数据时通过地址值和索引定位，查询任意数据耗时相同，查询速度快。
    删除数据时，要将原始的数据删除，同时后面的数据前移，删除效率低。
    数组增删
  • 链表
    通过前一个节点记录后一个节点的地址值。
    插入元素：
    ①数据B对应的笑一个数据地址指向数据C
    ②数组A对应的下一个数据地址执行数据B
    删除元素：
    ①数据B对应的下一个数据地址指向数据D
    ②删除数据C
    对于数组来说，链表是一种增删效率非常高的模型，但是查询效率低！
    查询第N个元素的时候，必须从头（head）开始查询！
    链表增删

双向链表：要查询第几个元素的话，就会判断离头近还是离尾近，那个近就从哪里开始查询。
双向链表

2.1 List集合的实现类ArrayList

  • ArrayList：底层数据结构是数组，查询快，增删慢
  • 源码解析
    List list = new ArrayList<>();
transient Object[] elementData;//ArrayList在底层创建的数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 空参数的构造方法创建的是一个长度为0的数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

源代码示例：

protected transient int modCount = 0;
private int size;

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}

private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

private Object[] grow() {
    return grow(size + 1);
}

private Object[] grow(int minCapacity) {
    return elementData = Arrays.copyOf(elementData,
                                       newCapacity(minCapacity));
}

private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity <= 0) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return minCapacity;
    }
    return (newCapacity - MAX_ARRAY_SIZE <= 0)
        ? newCapacity
        : hugeCapacity(minCapacity);
}
  • 图解（往空集合中添加第一个元素时）
    ArrayList添加元素源代码解析

3. List集合的实现类

3.1 List集合子类的特点

  • ArrayList集合
    底层是数据结构实现，查询快、增删慢。
  • LinkedList集合
    底层是链表结构实现，查询慢，增删快。

3.2 LinkedList集合的初步使用

  • 代码演示
public static void main(String[] args) {
    LinkedList<String> list = new LinkedList<>();
    list.add("历史上繁华的朝代");
    list.add("唐朝");
    list.add("明朝");
    list.add("清朝");
    list.add("汉朝");
    list.add("秦朝");
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    System.out.println("===========");
    Iterator it = list.iterator();
    while (it.hasNext()) {
        Object s = it.next();
        System.out.println(s);
    }
    System.out.println("===========");
    for (String s : list) {
        System.out.println(s);
    }
}

3.3 LinkedList集合的特有功能

  • 特有方法
方法名说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素
  • 代码演示
/**
 * LinkedList集合中删除首尾元素
 * @param list
 */
private static void method4(LinkedList<String> list) {
    String s = list.removeFirst();
    String s1 = list.removeLast();
    System.out.println(s);//历史上繁华的朝代
    System.out.println(s1);//秦朝
    System.out.println(list);//[唐朝, 明朝, 清朝, 汉朝]
}

/**
 * 演示LinkedList集合中获取首尾元素值的方法
 * @param list
 */
private static void method3(LinkedList<String> list) {
    String first = list.getFirst();
    String last = list.getLast();
    System.out.println(first + "----" + last);//历史上繁华的朝代----秦朝
}

/**
 * 演示LinkedList集合中在尾添加元素
 * @param list
 */
private static void method2(LinkedList<String> list) {
    list.addLast("秦朝1");
    System.out.println(list);//[历史上繁华的朝代, 唐朝, 明朝, 清朝, 汉朝, 秦朝, 秦朝1]
}

/**
 * 演示LinkedList集合中a在头添加元素
 * @param list
 */
private static void method1(LinkedList<String> list) {
    list.addFirst("历史上繁华的朝代1");
    System.out.println(list);//[历史上繁华的朝代1, 历史上繁华的朝代, 唐朝, 明朝, 清朝, 汉朝, 秦朝]
}

3.4 LinkedList源代码解析

  • 源代码示例
//添加方法
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++;
}
//获取源代码
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

Node<E> node(int index) {
    // assert isElementIndex(index);

    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;
    }
}
  • 图解
    LinkedList集合添加元素
    LinkedList集合查询元素

总结

希望本文对大家有所帮助，建议读者在学习时打开自己编程工具多多练习哦！大家一起学习一起进步！

程序员小琳
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
List源码解析
weixin_37337210的博客
09-28 344
开始看一下集合Collection，List是Collection的一个子接口，主要是看一下其下的几个类。 1、AbstractList 2、ArrayList 3、Collections.synchronizedList 4、Vector 5、LinkedList 6、CopyOnWriteArrayList 一、AbstractList 这是一个抽象类，其是实现List接口基础类，像ArrayList、LinkedList和Vector都是继承此抽象类的。 1》如果要实现一个不可变的列
List 源码解析
Super_Anna的博客
08-22 579
ListArrayList和LinkedList都继承自abstractList 都是线程不安全的。 abstractList 提供checkForComodification方法（next，add，remove方法中都有调用此方法），在单线程中，遍历的时候删除List（for循环和增强for循环都不是正确做法，迭代器遍历才是正确的，博客后面有例子声明）。当两个线程有冲突时，（当一个线程使用迭代器遍
List 源码分析
sermonlizhi的博客
12-26 1747
在Java中，List接口的继承结构图大概如图所示，其中最上层的Iterable接口和Collection接口是所有Java集合类都需要实现的接口，Iterable接口提供了iterator()方法，可以返回一个Iterator对象，而Iterator也是一个接口，所有实现了Iterable接口的集合类都需要重写iterator()方法，并且在集合类内部还需要实现Iterator接口的next()等方法用于迭代。 这篇文章就从源码的层面来看看这些常用的List接口的实现类 一、ArrayList 顾名思义
List源码解读
weixin_43374578的博客
03-21 943
一、ArrayList - 可以添加多个null元素 - 底层用数组来实现 - 非线程安全，但是效率高 1. 扩容机制 1. 底层维护了一个Object类型的数组 elementData transient Object[] elementData; # 表示该属性不会被序列化 2. 当创建新的ArrayList时， 如果使用的无参构造器， 则elementData初始容量为0 第一次添加，则扩容为10， 如果需要再次扩容，则扩容elementData 为1.5倍 #0--10--1
STL源码解析
10-10
STL源码解析是对这些内部实现的深入探讨，帮助程序员理解其工作原理，提升编程技能。STL主要包括四个主要组件：容器、迭代器、算法和函数对象。 **容器** STL容器是一些类模板，它们存储和管理对象集合。常见的容器...
java集合源码-collectionAnalysis:java集合源码解析
05-19
在"java集合源码-analysis:java集合源码解析"这个项目中，我们主要探讨的是对Java集合框架的源码进行深入理解。下面将详细阐述Java集合框架的基本概念、重要类和接口，以及其源码分析的重要性。 Java集合框架主要...
Java中ArrayList类的源码解析
08-31
Java中ArrayList类的源码解析 ArrayList是Java中最常用的集合类之一，它实现了List接口，继承自AbstractList抽象类。在ArrayList中，我们可以看到它的源码实现了Iterable接口、List接口和Collection接口。下面我们...
Java源码解析ArrayList及ConcurrentModificationException
08-26
bject[initialCapacity]; } else if (initialCapacity == 0) {...同时，需要注意在并发环境下使用ArrayList可能会遇到`ConcurrentModificationException`，应当避免在遍历过程中修改集合，或者选择线程安全的数据结构。
java——ArrayList-源码解析.docx
05-09
ArrayList 是 Java 中常用的集合类，它是 List 接口的一个实现，基于数组进行操作。ArrayList 的设计使得元素可以动态地添加和删除，同时提供了对数组大小的灵活调整。它实现了 ICollection 和 IList 接口，提供了...
List接口源码解析
水滴石穿
07-15 900
所在包package java.util;继承Collection接口public interface List<E> extends Collection<E> { // 内部代码下面讲解 }集合元素大小int size();是否为空boolean isEmpty();是否包含元素oboolean contains(Object o);转化为数组Object[] toArray();更新数组a<T
List集合源码解析（LinkedList篇）
BodyCoding
06-19 120
前言 上一篇文章讲了ArrayList和Vector，这两者是基于数组，还是比较好理解的，LinkedList是基于链表实现的，所以适合有数据结构基础的同学阅读~ 本文所有代码都是基于JDK8的 LinkedList 从结构上，我们还看到了LinkedList实现了Deque接口，因此，我们可以操作LinkedList像操作队列和栈一样，LinkedList的底层是链表，先来看一下节点的定义： ...
List源码浅析(java)
最新发布
weixin_60257072的博客
10-17 458
-----------------------以下是摘自List源码作者介绍有序集合（也称为序列）。此界面的用户可以精确控制每个元素在列表中的插入位置。用户可以通过整数索引（列表中的位置）访问元素，并在列表中搜索元素。与集合不同，列表通常允许重复元素。更正式地说，列表通常允许元素对e1和e2如此e1.equals(e2) ，并且如果它们完全允许 ​​null 元素，它们通常允许多个 null 元素。
关于List源码的分析
MagicianThirteen
03-06 285
List是c#中的一个最常见的可伸缩数组组件，不用手动去分配数组大小 初始容量是0 优点：使用索引方式提取数组很快，通用性高 缺点：扩容时会很糟糕，每次针对数组进行new操作都会造成内存垃圾，给gc带来巨大负担。效率不高 常用接口分析 （1）Add接口 给定对象添加到列表的末尾，列表的大小+1 容量不够，将会增加到当前容量的两倍 4，8，16，32，64，128 溢出（大约2gb）之前，会允许列表增长到最大容量 （2）Remove接口 删除给定索引处的元素，列表大小减1 返回此列表范围内给定值首次出现的索引
list源码剖析
弥川的博客
05-01 202
list源码剖析 文章目录list源码剖析定义模板参数成员函数特殊函数元素访问迭代器容量修改器操作非成员函数参考资料 定义 定义：支持常数时间从容器任何位置插入和移除元素的容器。不支持快速随机访问。通常实现为双向链表。 template< class T, class Allocator = std::allocator<T> > class list; 模板参数 T - 必须满足可拷贝赋值 (CopyAssignable) 和可拷贝构造 (CopyConstructi
深入了解List（源码分析）
发散式学习的菜鸟的博客
09-11 365
Java单列集合（Collection）未特殊标注处源码均为JDK1.8源码 List ArrayList（线程不安全） 特点：增删慢，查询快，底层结构为数组 新建ArrayList对象时，默认容量为10(若未添加数据，容量为0)。ArrayList类源码如下： 112. /** 113. * Default initial capacity. 114. */ 115. private static final int DEFAULT_CAPACITY = 10; 当Arr
Java集合深度解析：List与Set接口实战
"Java集合体系List-Set" 在Java编程中，集合体系是处理对象存储和操作的核心部分。本文深入探讨了Java集合体系中的List和Set接口，以及它们的实现类，如ArrayList、LinkedList、HashSet和TreeSet。这些知识点对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值