首页 > 资讯 > 后端开发 > Python >详解Java集合类之List篇

589

分享到

详解Java集合类之List篇

2024-04-02 19:04:59 589人浏览八月长安

Python 官方文档：入门教程 => 点击学习

摘要

目录1.集合框架体系2.Collection接口3.迭代器4.List接口5.ArrayListArrayList扩容机制ArrayList使用实例6.Vector7.LinkedL

1.集合框架体系

集合框架被设计成要满足以下几个目标。

该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。
该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。
对一个集合的扩展和适应必须是简单的。

为此，整个集合框架就围绕一组标准接口而设计。你可以直接使用这些接口的标准实现，诸如： LinkedList, HashSet, 和 TreeSet 等,除此之外你也可以通过这些接口实现自己的集合。

Collection接口的实现子类

Map接口的实现子类

体系图

从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

2.Collection接口

该接口定义：

public interface Collection<E> extends Iterable<E>

Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。

Collection 接口存储一组不唯一，无序的对象。

Collection接口的常用方法：

import java.util.ArrayList;
import java.util.List;


public class CollectionTest {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        // 添加
        list.add("dahe");
        list.add(521);
        list.add(true);
        System.out.println(list);
        // 删除
        // 删除第一个元素
        list.remove(0);
        // 删除指定的元素
        list.remove(true);
        System.out.println(list);
        // 查找
        System.out.println(list.contains(521));
        // 元素个数
        System.out.println(list.size());
        // 判空
        System.out.println(list.isEmpty());
        // 清空
        list.clear();
        // 添加多个元素（可以添加另一个实现了Collection接口的对象）
        ArrayList arrayList = new ArrayList();
        arrayList.add("tiktok直播");
        arrayList.add("tiktok广告投放");
        list.addAll(arrayList);
        System.out.println(list);
        // 查找多个元素是否都存在
        System.out.println(list.containsAll(arrayList));
        // 删除多个元素
        list.removeAll(arrayList);
        System.out.println(list);
    }
}

输出：

[dahe, 521, true]
[521]
true
1
false
[tiktok直播, tiktok广告投放]
true
[]

3.迭代器

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection api 中的接口，它扩展了 Iterator 接口。

迭代器 it 的两个基本操作是 next 、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
调用 it.remove() 将迭代器返回的元素删除。

代码DEMO示例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorTest {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",52.7));
        col.add(new Book("小李飞刀","古龙",10.2));
        col.add(new Book("红楼梦","曹雪芹",34.6));
        System.out.println(col);
        // 使用迭代器
        Iterator iterator = col.iterator();
        while (iterator.hasNext()) {
            // 返回下一个元素，类型是Object
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
}

class Book {
    private String name;
    private String author;
    private Double price;

    public Book(String name, String author, Double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

输出：

[Book{name='三国演义', author='罗贯中', price=52.7}, Book{name='小李飞刀', author='古龙', price=10.2}, Book{name='红楼梦', author='曹雪芹', price=34.6}]
Book{name='三国演义', author='罗贯中', price=52.7}
Book{name='小李飞刀', author='古龙', price=10.2}
Book{name='红楼梦', author='曹雪芹', price=34.6}

我们还可以使用增强型for循环来遍历集合：（底层依然是迭代器，可以理解为简化版的迭代器遍历）

for (Object o : col) {
    System.out.println(o);
}

4.List接口

List接口是Collection接口的子接口

List集合中元素有序（添加顺序和取出顺序一致），元素可以重复

List中的每个元素都有其顺序的索引

常用方法代码示例：



import java.util.ArrayList;
import java.util.List;


public class ListTest {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        List list1 = new ArrayList();
        list1.add("ceshi");
        list1.add("tangseng");
        // 添加元素
        list.add("dahe");
        list.add("tom");
        list.add("dahe"); // 可以重复
        // 指定位置插入元素
        list.add(1,"qian");
        // 加入多个元素，传入一个Collection对象
        list.addAll(1,list1);
        System.out.println(list);
        // 取出指定索引的元素
        System.out.println(list.get(0));
        // 查找元素第一次出现的位置
        System.out.println(list.indexOf("dahe"));
        // 查找元素最后一次出现的位置
        System.out.println(list.lastIndexOf("dahe"));
        // 删除元素
        list.remove(1);
        System.out.println(list);
        // 元素替换
        list.set(1,"marry");
        System.out.println(list);
        // 返回子集合，0到1的元素集合
        List returnList = list.subList(0,2);
        System.out.println(returnList);
    }
}

输出：

[dahe, ceshi, tangseng, qian, tom, dahe]
dahe
0
5
[dahe, tangseng, qian, tom, dahe]
[dahe, marry, qian, tom, dahe]
[dahe, marry]

5.ArrayList

ArrayList是由数组来进行数据存储的，为线程不安全，效率较高多线程场景建议使用vector

例如ArrayList add方法的源码：（并没有synchronized进行修饰）

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

ArrayList扩容机制

使用无参构造器

当我们使用ArrayList的无参构造器的时候，进入源码分析：

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

这里的elementData是ArrayList存放数据的数组，可以看出当我们调用无参构造的时候，数组初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，那这一长串代表什么呢？

继续步入

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
1
该值为空，那么我们可以得出结论，当调用ArrayList的无参构造时，存储数组的默认空间大小为0，也就是空

同时，我们追入elementData数组，可以发现他是Object数组，这也就解释了为什么ArrayList可以加入任意类型的元素，因为Object是万物之父！

transient Object[] elementData; // non-private to simplify nested class access

添加数据之前的准备

接下来，当我们使用add方法，比如操作下面这行代码：

arrayList.add(521);

首先，ArrayList会对521进行装箱操作：

@IntrinsicCandidate
 public static Integer valueOf(int i) {
     if (i >= IntegerCache.low && i <= IntegerCache.high)
         return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
 }

继续步入，进入如下代码：

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

我们来仔细看一下这段代码，首先：

modCount++;

在所有的集合实现类中（Collection与Map中），都会有一个 modCount 的变量出现，它的作用就是记录当前集合被修改的次数。此处将修改次数 + 1，防止多线程操作异常

随后，进入真正添加数据的add重载方法：

add(e, elementData, size);

开始添加数据

在真正添加数据的部分，代码如下：

可以看到，首先需要判断elementData数组的容量是否充足，如果容量已经满了的话，就执行grow方法进行扩容，否则就加入数据，size + 1

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

那他是怎么进行扩容的呢？

我们进入grow方法看一下：

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

继续步入到grow的重载方法：

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity, 
                oldCapacity >> 1           );
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

获取老的容量

如果一次也没有扩容过，则扩容大小为DEFAULT_CAPACITY和minCapacity较大的一个，DEFAULT_CAPACITY被定义为10，而我们此时的minCapacity为1，所以第一次扩容的大小为10

如果老的容量大于0或者elementData数组不是初始化状态的数组（也就是已经第一次扩容过）

那么通过位运算进行扩容到原容量的1.5倍

注意：idea在debug默认情况下显示的数据是简化的，如果需要看完整的数据，需要进行设置

使用指定大小的构造器

原理操作和上面类似，只不过它初始的容量为指定的容量，需要扩容时扩容为原容量的1.5倍

ArrayList使用实例

ArrayList arrayList = new ArrayList();
arrayList.add(521);
arrayList.add(null);
arrayList.add("武松");
arrayList.add(null);
System.out.println(arrayList);

输出：

[521, null, 武松, null]

6.Vector

vector底层同样是一个对象数组

protected Object[] elementData;

和ArrayList不同的是，它是线程同步的，也就是线程安全的

Vector和ArrayList的区别：

7.LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

链表可分为单向链表和双向链表。

一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

Java LinkedList（链表）类似于 ArrayList，是一种常用的数据容器。

与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

LinkedList的底层是一个双向链表

增加元素源码分析

在LinkedList链表中，存在几个必知的概念 --> First：链表头节点；Last：链表尾节点；next：该节点下一个节点地址；prev：该节点前一个节点地址

LinkedList linkedList = new LinkedList();
// 增
linkedList.add(521);
linkedList.add(1314);
System.out.println(linkedList);

首先：调用LinkedList的无参构造，这里什么也没有捏

public LinkedList() {
}

随后，和ArrayList和Vector一样，进行装箱操作

开始添加操作：

public boolean add(E e) {
    linkLast(e);
    return true;
}

为了方便理解，我们需要知道一下node的构造器内容：

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

继续步入：

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++;
}

这里是关键，接下来我们来分析一下上面的这段代码：

首先，将last的值赋给l，新建一个Node节点，将last指向新建的Node节点，随后进行分支判断，将first也指向新建的Node节点

最后，链表大小 + 1 ，修改次数 + 1

经过了上面的修改，现在的first和last都指向新建的节点，该节点的next和prev都为null

以上是链表中只有一个元素的情况，那么再次向链表添加元素呢？我们再来浅浅看一下

第二次添加节点，l被置为上一个节点的地址，随后会被添加到新节点的prev属性中：

还需要更新一下last的值为新添加进来的节点的地址：

随后，将上一个节点的next值置为当前新加的节点地址：

最后，更新size和modCount即可！

删除元素源码分析

// 删除最后一个节点
linkedList.remove();

进行源码分析，步入：

public E remove() {
    return removeFirst();
}

继续步入：

public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

Java的设计者在这里获取了链表头节点的地址，以备后续进行删除，随后检查了一个头节点为空的异常，在unlinkFirst方法，将会真正执行删除的操作！

继续步入：

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

开头，获取头节点的值，以备在后续返回：

final E element = f.item;

先获取一下头节点后面的节点的地址，保存下来，然后将头节点的数据和next置空，请求GC进行回收：

final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC

头节点更新为原头节点的下一个节点，并作节点个数判断：

first = next;
if (next == null)
    last = null;
else
    next.prev = null;

最后，更新size和modCount，返回element

LinkedList使用Demo

import java.util.LinkedList;


public class LinkedListTest {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        // 增
        linkedList.add(521);
        linkedList.add(1314);
        System.out.println(linkedList);
        // 删除头节点
        linkedList.remove();
        System.out.println(linkedList);
        // 修改
        linkedList.set(0,999);
        System.out.println(linkedList);
        // 查找
        System.out.println(linkedList.get(0));
    }
}

输出：

[521, 1314]
[1314]
[999]
999

8.ArrayList和LinkedList的选择

以下情况使用 ArrayList :

频繁访问列表中的某一个元素。
只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

你需要通过循环迭代来访问列表中的某些元素。
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

在实际开发中，ArrayList用的最多，因为大部分的业务是查询业务！

另外，ArrayList和LinkedList都是线程不安全的，推荐在单线程场景下使用

到此这篇关于详解Java集合类之List篇的文章就介绍到这了,更多相关Java集合类List内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 详解Java集合类之List篇

本文链接: https://www.lsjlt.com/news/165012.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

详解Java集合类之List篇

目录1.集合框架体系2.Collection接口3.迭代器4.List接口5.ArrayListArrayList扩容机制ArrayList使用实例6.Vector7.LinkedL...

99+

2022-11-13
详解Java集合类之Map篇

目录1.Map接口介绍2.Map接口分析3.Map接口方法4.Map遍历方式1.Map接口介绍 Map用于保存具有映射关系的数据：Key - Value 对于Set，底层其实依然是一...

99+

2022-11-13
详解Java集合类之HashSet篇

目录1.Set接口方法2.HashSet3.HashSet的扩容机制 - 初次添加数据4.HashSet的扩容机制 - 继续添加数据5.HashSet的扩容机制 - 添加重复元素1....

99+

2022-11-13
详解Java集合类之HashTable,Properties篇

目录1.基本介绍2.HashTable底层3.HashTable扩容机制4.HashMap和HashTable的对比5.Properties6.集合选型规则1.基本介绍 HashTa...

99+

2022-11-13
进阶JAVA篇-深入了解 List 系列集合

目录 1.0 List 类的说明 1.1 List 类的常用方法 1.2 List 集合的遍历方式 2.0 ArrayList 集合的底层原理 2.1 从 Ar...

99+

2023-10-24

java 开发语言
Java集合类之TreeSet的用法详解

目录上节回顾TreeSet集合概述和特点构造方法方法摘要Demo自然排序Comparable的使用比较器排序Comparator的使用上节回顾 LinkedHashSet集合概述及特...

99+

2022-11-13
Java集合框架之List ArrayList LinkedList使用详解刨析

目录1. List1.1 List 的常见方法1.2 代码示例2. ArrayList2.1 介绍2.2 ArrayList 的构造方法2.3 ArrayList 底层数组的大小3....

99+

2022-11-12
【Java 基础篇】Java List 详解

文章目录导言一、List 概述二、ArrayList三、LinkedList四、Vector总结导言在Java的集合框架中，List接口是一个有序、可重复的集合，它扩展了Coll...

99+

2023-09-11

java list 数据结构
Java集合类之Map集合的特点及使用详解

目录1、Map集合概述和使用1.1 Map集合概述1.2 Map集合常用方法1.3 Map集合的遍历1、Map集合概述和使用 1.1 Map集合概述 java.util接口 Map&...

99+

2022-11-13
java集合类源码分析之Set详解

Set集合与List一样，都是继承自Collection接口，常用的实现类有HashSet和TreeSet。值得注意的是，HashSet是通过HashMap来实现的而TreeSet是通过TreeMap来实现的，所以HashSet和TreeS...

99+

2023-05-31

java 集合类源码 set
Java List接口的集合使用详解

目录ArrayList集合LinkedList类LinkedList与ArrayList的区别：总结List接口继承collection接口，此接口可以对列表中的每个元素精确的控制，...

99+

2022-11-12
java系列之list集合分组

文章目录前言一、list是什么？二、list集合分组总结前言在Java编程中，List集合是一种常用的数据结构，用于存储一组元素。有时候，我们需要对List集合中的元素进行分组操作...

99+

2023-09-09

java list
Java集合之Map接口与实现类详解

目录初识Map:Map接口没有从Collection接口继承，Map接口用于维护“键-值”对数据，这个“键-值”对就是Map中的元素，...

99+

2022-12-08

Java 集合 Map接口 Java Map接口 Java实现Map接口
Java中List集合的常用方法详解

目录1、void add(intindex, Eelement)2、boolean addAll(intindex, Collection< extends...

99+

2022-11-13
Java集合框架之Map详解

目录1、Map的实现2、HashMap 和 Hashtable 的区别3、介绍下对象的 hashCode()和equals()，使用场景4、HashMap和TreeMap应该怎么选择...

99+

2022-11-13
Java基础之集合Set详解

目录一、概述二、Set的常用方法三、Set的遍历3.1增强for循环3.2 迭代器遍历一、概述 Set是Java中的集合类，提供了一种无顺序，不重复的集合。常用的子类包括HashSe...

99+

2022-11-12
Java集合的Collection接口和List接口详解

目录1集合的概念2 集合的父类Collection接口2.1常用方法2.2遍历 3 List接口3.1List接口常用方法3.2遍历4 集合中元素的去重总结1集合的概念把...

99+

2022-11-13
java中List集合子类特点浅析

List集合常用子类：ArrayList，LinkedList 1.ArrayList:底层数据结构是数组，查询快，增删慢 2.LinkedList：底层数据结构是链表，查询慢，增删...

99+

2022-11-13
Java 详解Collection集合之ArrayList和HashSet

目录CollectionListArrayListSetHashSetArrayList和HashSet的区别泛型 Collection Collection接口被List接口和Se...

99+

2022-11-13
Java 详解Map集合之HashMap和TreeMap

目录HashMap创建HashMap添加元素访问元素删除元素TreeMap创建TreeMap添加元素访问元素删除元素HashMap、TreeMap区别 Map接口储存一组成对的键-值...

99+

2022-11-13