学习Java中的List集合

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

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

摘要

目录1.概述2.List的使用2.1List的常用方法3.List的实现类3.1ArrayList3.2Vector3.3LinkedList3.4ArrayList与Vector的

1.概述

List是一个有序集合（也被称为序列）。此接口的用户在列表中的每个元素都被插入的地方有精确的控制。用户可以通过它们的整数索引（在列表中的位置）访问元素，并在列表中搜索元素。说是List集合，其实只是习惯说法，因为它是Collection接口的一个子接口（Collection有很多的子接口，这是其中三个主要的子接口之一，另外两个后面都会说到），所以Collection接口中定义的方法在List接口中也是可以使用的，另外还根据List的特点，又引入了其他的方法。

List接口的特点：

元素是以一种线性方式进行存储的
元素存取有序，即元素的存入顺序和取出顺序一致。
元素带有索引，通过索引就可以精确的操作集合中的元素（与数组类似）
元素可以重复，通过元素的equals方法，来比较是否为重复的元素

2.List的使用

2.1List的常用方法

基本介绍：

这里说的常用方法是指除了实现Collection接口之外的。前面说到List集合中的元素是可以通过索引来操作集合中的元素的，所以List 集合里添加了一些根据索引来操作集合元素的方法。下面对这些方法进行简单

介绍：

void add(iint index, E element)：在列表中指定的位置上插入指定的元素
boolean addAll(int index, Collection c)：将指定的集合中的所有元素插入到指定位置的列表中
E get(int index)：返回此列表中指定位置的元素
List subList(int fromIndex, int toIndex)：返回List中一部分对象的集合，即返回的集合是List的子集合，并是以下标索引取值。父集合List以fromIndex开始(包含)，到toIndex结束(不包含)的部分为返回的子集合
int indexOf(Object obj)：返回此列表中指定元素的第一个出现的索引，如果此列表不包含元素，返回- 1
int lastIndexOf(Object obj)：返回此列表中指定元素的最后一个发生的索引，如果此列表不包含元素，返回- 1
E remove(int index)：移除此列表中指定位置的元素
E set(int index, E element)：用指定元素替换此列表中指定位置的元素

代码示例:

public class ListDemo {
    public static void main(String[] args) {
        // 通过List的实现类ArrayList创建List集合对象
        List<String> list = new ArrayList<String>();

        // 指定位置添加元素
        list.add(0,"jack");
        list.add(1,"rose");    
        list.add(2,"marry");        
        System.out.println(list);
        
        // 删除索引位置为2的元素 
        list.remove(2);        
        System.out.println(list);
        
        // 指定元素替换此列表中指定位置的元素
        list.set(0, "老王");
        System.out.println(list);
        
        // 获取指定位置元素(也遍历输出下)    
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //还可以使用增强for
        for (String string : list) {
            System.out.println(string);
        }      
    }
}

3.List的实现类

作为一个接口，List的实现类才是我们创建对象时候使用的（上面代码示例里面用到了ArrayList实现类）。在List接口里，有三个常用的实现类：ArrayList、Vector、LinkedList。下面从源码中分析和介绍它们。

3.1ArrayList

ArrayList底层通过数组实现，ArrayList可以随着元素的增加而动态扩容。它是一个数组队列，是Java集合框架中使用最多的一个类，但是它是线程不安全的。

特点：以数组的形式进行存储，因此随机访问速度较快，所有它适用于查询
缺点：不适用于插入和删除的操作因为每次操作都需要移动数组中的元素；线程不安全

下面看下ArrayList的源码：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandoMaccess, Cloneable, java.io.Serializable{
    
    private static final int DEFAULT_CAPACITY = 10;
   
    private static final Object[] EMPTY_ELEMENTDATA = {};
  
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//初始化为空数组
    }


    public boolean add(E e) {
        //查看当前数组是否够多存一个元素
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        //存入新元素到[size]位置，然后size自增1
        elementData[size++] = e;
        return true;
    }
   
   private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

   private static int calculateCapacity(Object[] elementData, int minCapacity) {
           //如果当前数组还是空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //那么minCapacity取DEFAULT_CAPACITY与minCapacity的最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //查看是否需要扩容
        return minCapacity;
      }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//修改次数加1

        // 如果需要的最小容量比当前数组的长度大，即当前数组不够存，就扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//当前数组容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新数组容量是旧数组容量的1.5倍
        //看旧数组的1.5倍是否够
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //看旧数组的1.5倍是否超过最大数组限制
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        
        //复制一个新数组
        elementData = Arrays.copyOf(elementData, newCapacity);
      }
      public boolean remove(Object o) {
        //先找到o在当前ArrayList的数组中的下标
        //分o是否为空两种情况讨论
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {//null值用==比较
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {//非null值用equals比较
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
    private void fastRemove(int index) {
        modCount++;//修改次数加1
        //需要移动的元素个数
        int numMoved = size - index - 1;
        
        //如果需要移动元素，就用System.arraycopy移动元素
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        
        //将elementData[size-1]位置置空，让GC回收空间，元素个数减少
        elementData[--size] = null; // clear to let GC do its work
    }
    public E remove(int index) {
        rangeCheck(index);//检验index是否合法

        modCount++;//修改次数加1
        
        //取出[index]位置的元素，[index]位置的元素就是要被删除的元素，用于最后返回被删除的元素
        E oldValue = elementData(index);
        
        //需要移动的元素个数
        int numMoved = size - index - 1;
        
        //如果需要移动元素，就用System.arraycopy移动元素
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //将elementData[size-1]位置置空，让GC回收空间，元素个数减少
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }
    public E set(int index, E element) {
        rangeCheck(index);//检验index是否合法

        //取出[index]位置的元素，[index]位置的元素就是要被替换的元素，用于最后返回被替换的元素
        E oldValue = elementData(index);
        //用element替换[index]位置的元素
        elementData[index] = element;
        return oldValue;
    }
    public E get(int index) {
        rangeCheck(index);//检验index是否合法

        return elementData(index);//返回[index]位置的元素
    }
     public int indexOf(Object o) {
        //分为o是否为空两种情况
        if (o == null) {
            //从前往后找
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    public int lastIndexOf(Object o) {
         //分为o是否为空两种情况
        if (o == null) {
            //从后往前找
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

从上面的源码中我们可以看到：

ArrayList 在初始化的时候如果我们没有指定长度的话，它会有一个默认长度10，每次扩容的时候为增加1.5倍
然后是ArrayList 的一些常见的方法的源码介绍

3.2Vector

Vector的底层也是通过数组实现，方法与ArrayList基本一致,。但是Vector是线程安全的. 这是因为其加上了 synchronized 关键字, 用来保证线程安全。

优点: 以数组的形式进行存储，因此随机访问速度较快，所有它适用于查询；线程安全
缺点: 不适用于插入和删除的操作因为每次操作都需要移动数组中的元素

下面看下Vector的源码：

  
    public Vector() {
        this(10); //指定初始容量initialCapacity为10
    }
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);//指定capacityIncrement增量为0
    }
    public Vector(int initialCapacity, int capacityIncrement增量为0) {
        super();
        //判断了形参初始容量initialCapacity的合法性
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //创建了一个Object[]类型的数组
        this.elementData = new Object[initialCapacity];//默认是10
        //增量，默认是0，如果是0，后面就按照2倍增加，如果不是0，后面就按照你指定的增量进行增量
        this.capacityIncrement = capacityIncrement;
    }
    //synchronized意味着线程安全的   
    public synchronized boolean add(E e) {
        modCount++;
        //看是否需要扩容
        ensureCapacityHelper(elementCount + 1);
        //把新的元素存入[elementCount]，存入后，elementCount元素的个数增1
        elementData[elementCount++] = e;
        return true;
    }

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        //看是否超过了当前数组的容量
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//扩容
    }
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//获取目前数组的长度
        //如果capacityIncrement增量是0，新容量 = oldCapacity的2倍
        //如果capacityIncrement增量是不是0，新容量 = oldCapacity + capacityIncrement增量;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        
        //如果按照上面计算的新容量还不够，就按照你指定的需要的最小容量来扩容minCapacity
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        
        //如果新容量超过了最大数组限制，那么单独处理
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        
        //把旧数组中的数据复制到新数组中，新数组的长度为newCapacity
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
     public boolean remove(Object o) {
        return removeElement(o);
    }
    public synchronized boolean removeElement(Object obj) {
        modCount++;
        //查找obj在当前Vector中的下标
        int i = indexOf(obj);
        //如果i>=0，说明存在，删除[i]位置的元素
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }
    public synchronized int indexOf(Object o, int index) {
        if (o == null) {//要查找的元素是null值
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)//如果是null值，用==null判断
                    return i;
        } else {//要查找的元素是非null值
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))//如果是非null值，用equals判断
                    return i;
        }
        return -1;
    }
    public synchronized void removeElementAt(int index) {
        modCount++;
        //判断下标的合法性
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        
        //j是要移动的元素的个数
        int j = elementCount - index - 1;
        //如果需要移动元素，就调用System.arraycopy进行移动
        if (j > 0) {
            //把index+1位置以及后面的元素往前移动
            //index+1的位置的元素移动到index位置，依次类推
            //一共移动j个
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        //元素的总个数减少
        elementCount--;
        //将elementData[elementCount]这个位置置空，用来添加新元素，位置的元素等着被GC回收
        elementData[elementCount] = null; 
    }

从上面的源码中我们可以看到：

Vector在初始化的时候如果我们没有指定长度的话，它会有一个默认长度10，每次扩容的时候为增加2倍
然后是Vector的一些常见的方法的源码介绍

3.3LinkedList

LinkedList底层的数据存储结构是链表结构，而且还是一个双向链表，可以实现双向操作。此外，LinkedList还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用，如peek 、push、pop等方法。

优点: 以链表形式进行存储，因此随机访问速度查询慢，增删快。
缺点: 线程不安全

下面看一下源码：

int size = 0;
node<E> first;//记录第一个结点的位置
Node<E> last;//记录最后一个结点的位置

    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;
        }
    }
      public boolean add(E e) {
        linkLast(e);//默认把新元素链接到链表尾部
        return true;
    }
    void linkLast(E e) {
        final Node<E> l = last;//用l 记录原来的最后一个结点
        
        //创建新结点
        final Node<E> newNode = new Node<>(l, e, null);
        //现在的新结点是最后一个结点了
        last = newNode;
        
        //如果l==null，说明原来的链表是空的
        if (l == null)
            //那么新结点同时也是第一个结点
            first = newNode;
        else
            //否则把新结点链接到原来的最后一个结点的next中
            l.next = newNode;
        //元素个数增加
        size++;
        //修改次数增加
        modCount++;
    }
     public boolean remove(Object o) {
        //分o是否为空两种情况
        if (o == null) {
            //找到o对应的结点x
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);//删除x结点
                    return true;
                }
            }
        } else {
            //找到o对应的结点x
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);//删除x结点
                    return true;
                }
            }
        }
        return false;
    }
    E unlink(Node<E> x) {//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 {//被删除结点不是第一个结点
            //被删除结点的上一个结点的next指向被删除结点的下一个结点
            prev.next = next;
            //断开被删除结点与上一个结点的链接
            x.prev = null;//使得GC回收
        }

        //如果被删除结点的后面没有结点，说明被删除结点是最后一个结点
        if (next == null) {
            //那么被删除结点的上一个结点变为最后一个结点
            last = prev;
        } else {//被删除结点不是最后一个结点
            //被删除结点的下一个结点的prev执行被删除结点的上一个结点
            next.prev = prev;
            //断开被删除结点与下一个结点的连接
            x.next = null;//使得GC回收
        }
        //把被删除结点的数据也置空，使得GC回收
        x.item = null;
        //元素个数减少
        size--;
        //修改次数增加
        modCount++;
        //返回被删除结点的数据
        return element;
    }

从上面的源码中我们可以看到：

LinkedList是基于链表的，所以没有扩容方法，默认加入元素是尾部自动扩容
然后是LinkedList的一些常见的方法的源码介绍

3.4ArrayList与Vector的区别

它们的底层结构都是数组，我们称为动态数组。

ArrayList是新版的动态数组，线程不安全，效率高，Vector是旧版的动态数组，线程安全，效率低。
动态数组的扩容机制不同，ArrayList扩容为原来的1.5倍，Vector扩容增加为原来的2倍。
数组的初始化容量，如果在构建ArrayList与Vector的集合对象时，没有显式指定初始化容量，那么Vector的内部数组的初始容量默认为10，而ArrayList在jdk1.6及之前的版本也是10，而JDK1.7之后的版本ArrayList初始化为长度为0的空数组，之后在添加第一个元素时，再创建长度为10的数组。

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

您可能感兴趣的文档:

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

--结束END--

本文标题: 学习Java中的List集合

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

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

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

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

下载Word文档

去做题

猜你喜欢

学习Java中的List集合

目录1.概述2.List的使用2.1List的常用方法3.List的实现类3.1ArrayList3.2Vector3.3LinkedList3.4ArrayList与Vector的...

99+

2024-04-02
Java集合-List

一、List集合概述 java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合，在List集合中允许出现重复的...

99+

2023-09-07

java list 数据结构算法开发语言
Python学习：集合

集合 Set 集合的创建集合的创建只有一种方式集合中的元素必须是不可变的数据类型集合是无序的，可以通过 for 循环来遍历或者迭代器进行筛选 s=set('xiaoming') s1=['alex','mike','alex'...

99+

2023-01-30

Python
java集合中list的示例分析

这篇文章主要为大家展示了“java集合中list的示例分析”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“java集合中list的示例分析”这篇文章吧。1、List接口该接口定义的元素是有序的且可...

99+

2023-05-30

java list
Java中list集合stream流去重

Java中list集合stream流去重 1. List单个字段去重 list.stream().distinct().collect(Collectors.toList()); 2. List对象...

99+

2023-09-15

java jvm servlet
Java List对象集合转Json & Json转List对象集合

使用了阿里巴巴的 fastjson 首先引入依赖 com.alibaba fastjson 2.0.32 示例如下 import com.alibaba.fastjson.JSONObject;import com.ex...

99+

2023-09-08

java json
从零开始学习 Java：简单易懂的入门指南之Collection集合及list集合（二十一）

Collection集合及list集合 1.Collection集合1.1数组和集合的区别1.2集合类体系结构1.3Collection 集合概述和使用1.4Collection集合的遍历1....

99+

2023-09-06

学习 java list 数据结构 spring boot 算法链表
Java List 集合取交集、并集、差集、补集 Java集合取交集、Java集合并集

Java List 集合取交集、并集、差集、补集 Java集合取交集、Java集合并集一、概述 1、在日常开发中：经常会遇到对2个集合的操作，例如：2个集合之间取相同的元素（交集），2个集...

99+

2023-08-31

Java List集合交集 Java List集合并集 Java List集合交集差集 List 集合交易并集 List集合补集差集
java中list集合的特点有哪些

Java中的List集合有以下特点：1. 有序性：List中的元素按照添加的顺序进行存储，并且可以根据索引位置来访问元素。2. 可重...

99+

2023-09-22

java list
【Java基础】Java中List集合的常用方法

在Java编程中，List集合是最常用的一种数据结构之一。它具有动态扩容、元素添加、删除和查询等基础操作，可以存储各种类型的对象，并且支持泛型。在本文中，我将介绍Java List集合的常用方法，并通过实例演示这些方法的使用。一、Lis...

99+

2023-09-04

java 数据结构 list jvm
java List集合去除null

方法一：使用迭代器进行遍历和删除 List list = new ArrayList();list.add("A");list.add(null);list.add("B");list.add(null);list.add("C");Ite...

99+

2023-09-01

java list windows
java 获取两个List集合的交集

获取两个List集合的交集可以使用Java中的retainAll方法来获取两个List的交集：假设有两个List类型的集合list1和list2，代码如下： List list1 = new ArrayList();list1.add(...

99+

2023-08-17

java list 开发语言
Java 集合框架之List 的使用(附小游戏练习)

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

99+

2024-04-02
Java中逆序遍历List集合的实现

目录1 问题2 方法3 结语1 问题手写一个程序，完成List集合对象的逆序遍历 2 方法创建List接口的多态对象向创建好list集合添加元素使用hasPreviou...

99+

2023-01-28

Java 逆序遍历List Java 逆序遍历
Python学习之集合set

目录集合 (set)一、合集的一些常用命令1、set 定义合集2、add 添加元素3、clear 清空4、pop 随机删除一个元素5、remove 指定删除6、discard 指定...

99+

2024-04-02
python3学习之set集合

关键字set是集合，数据特点是：无序，去重#创建se = {"sdfs","ljk"} ;大括号中不是键值对se = set((1,2,3,4,8))se = set() ;空集合#操作se.add #单个添加 ...

99+

2023-01-31

set
Java中List集合的常用方法详解

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

99+

2024-04-02
python之集合（set）学习

集合是一个无序的不重复元素序列，使用大括号（{}）、set()函数创建集合，注意：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。　　集合是无序的、不重复的、没有索引的 1 a = {'hello','ni...

99+

2023-01-30

python set
java 中如何实现 List 集合去重

目录1.自定义去重2.利用 Set 集合去重3.使用 Stream 去重总结前言： List 去重指的是将 List 中的重复元素删除掉的过程。此题目考察的是对 List 迭代器、S...

99+

2024-04-02
Java中List集合数据修改方式

目录Java中List集合数据修改先说写这篇文章的原因这里是我循环赋值的语句Java中List集合的介绍1.Java集合介绍2.List介绍3.List常用方法4.ArrayList...

99+

2023-02-07

Java List集合 List集合数据修改 Java List