Java集合-List

一、List集合概述

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合，在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素，另外List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致

List特性：

• 有序
  • 存取有顺序
• 有下标
  • 是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引一个道理）
• 可以重复
  • 添加的元素可以重复

List实现类架构图、

二、ArrayList

1、什么是ArrayList类

java.util.ArrayList是大小可变的数组的实现，是单列集合List的实现类，存储在内的数据称为元素，此类提供一些方法来操作内部存储的元素，ArrayList中可不断添加元素，其大小也自动增长
java.util.ArrayList集合数据存储的结构是数组结构，元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是常用的集合。

2、ArrayList常用方法

代码案例：

package cn.com.example11;

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

public class ArrayListClass {

    static ArrayList arrayList;

    static {
        arrayList = new ArrayList();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
    }


    /**
     * 添加元素
     */
    public static void addHandler(){

        arrayList.add(1);
        arrayList.add(2);

        System.out.println(arrayList);

    }


    /**
     * 根据下标替换对象
     */
    public static void setHandler(){
        arrayList.set(1,"admin");

        System.out.println(arrayList);
    }

    /**
     * 截取
     */
    public static void subListHandler(){

        List list = arrayList.subList(1,3);

        System.out.println(list);
        System.out.println(arrayList);
    }

    /**
     * 集合转换数组
     */
    public static void toArrayHandler(){

        Object[] arr = arrayList.toArray();

        System.out.println(arr[0]);
        System.out.println(arrayList);

    }

    /**
     * 判断集合中是否包含指定的元素
     */
    public static void containersHandler(){

        boolean b = arrayList.contains("admin");

        System.out.println(b);
        System.out.println(arrayList);

    }

    /**
     * 根据下标获取对应的元素
     */
    public static void getHandler(){

        String value = (String)arrayList.get(1);

        System.out.println(value);
        System.out.println(arrayList);

    }

    /**
     * 获取指定的元素在集合中第一次出现的索引
     */
    public static void indexOfHandler(){

        int index = arrayList.indexOf("admin");

        System.out.println(index);
        System.out.println(arrayList);

    }

    /**
     * 判断集合是否为空
     */
    public static void isEmptyHandler(){

        boolean b = arrayList.isEmpty();

        System.out.println(b);
        System.out.println(arrayList);

    }

    /**
     * 获取集合长度
     */
    public static void sizeHandler(){

        int count = arrayList.size();

        System.out.println(count);
        System.out.println(arrayList);

    }

    /**
     * 根据下标删除元素
     */
    public static void removeHandler(){

        String value = (String) arrayList.remove(1);

        System.out.println(value);
        System.out.println(arrayList);


    }

    /**
     * 清空集合
     */
    public static void clearHandler(){

        arrayList.clear();

        System.out.println(arrayList);

    }

    public static void main(String[] args) {

        addHandler();
        setHandler();
        subListHandler();
        toArrayHandler();
        containersHandler();
        getHandler();
        indexOfHandler();
        isEmptyHandler();
        sizeHandler();
        removeHandler();
        clearHandler();


    }
}

运行结果：

3、ArrayList遍历

3.1、普通for循环

代码案例：

/**
     * 普通for循环
     */
    public static void forHandler(){

        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }

    }

3.2、增强for循环

代码案例：

/**
     * 增强for循环
     */
    public static void forEachHandler(){

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

    }

3.3、Iterator迭代器

代码案例：

/**
     * Iterator迭代器
     */
    public static void iteratorHandler(){

        Iterator iterator = arrayList.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

4、ArrayList数据结构

ArrayList数据结构：数组结构

ArrayList查询数据快，可根据下标查询，但是增删速度慢，一旦在某个位置插入数据，后面所有数据都必须往后移动

三、LinkedList

java.util.LinkedList集合数据存储的结构是链表结构，方便元素添加、删除的集合。

LinkedList是一个双向链表

1、LinkedList常用方法

代码案例：

package cn.com.example11;

import java.util.LinkedList;

public class LinkedListClass {

    public static LinkedList<Integer> linkedList;

    static {
        linkedList = new LinkedList<>();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        linkedList.add(4);
    }

    /**
     * 将指定元素插入集合的开头
     */
    public static void addFirstHandler(){

        linkedList.addFirst(0);

        System.out.println(linkedList); // [0, 1, 2, 3, 4]

    }

    /**
     * 将指定元素插入集合的结尾
     */
    public static void addLastHandler(){

        linkedList.addLast(5);

        System.out.println(linkedList); // [0, 1, 2, 3, 4, 5]

    }

    /**
     * 返回集合第一个元素
     */
    public static void getFirstHandler(){

        Integer value = linkedList.getFirst();

        System.out.println(value); // 0

    }

    /**
     * 返回集合最后一个元素
     */
    public static void getLastHandler(){

        Integer value = linkedList.getLast();

        System.out.println(value); // 5

    }

    /**
     * 移除并返回集合的第一个元素
     */
    public static void removeFirstHandler(){

        Integer value = linkedList.removeFirst();

        System.out.println(linkedList); // [1, 2, 3, 4, 5]
        System.out.println(value); // 0

    }

    /**
     * 移除并返回集合的最后一个元素
     */
    public static void removeLastHandler(){

        Integer value = linkedList.removeLast();

        System.out.println(linkedList); // [1, 2, 3, 4]
        System.out.println(value); // 5

    }

    /**
     * 从集合所表示的堆栈中弹出一个元素
     */
    public static void popHandler(){

        Integer value = linkedList.pop();

        System.out.println(linkedList); // [2, 3, 4]

        System.out.println(value); // 2


    }

    /**
     * 将元素推入集合所表示的堆栈中
     */
    public static void pushHandler(){

        linkedList.push(6);

        System.out.println(linkedList); // [6, 2, 3, 4]

    }

    /**
     * 判断集合是否为空
     */
    public static void isEmptyHandler(){

        boolean b = linkedList.isEmpty();

        System.out.println(b); // false

    }


    public static void main(String[] args) {

        addFirstHandler();
        addLastHandler();
        getFirstHandler();
        getLastHandler();
        removeFirstHandler();
        removeLastHandler();
        popHandler();
        pushHandler();
        isEmptyHandler();
    }

}

2、LinkedList遍历

2.1、增强for循环

代码案例：

/**
     * 增强for循环
     */
    public static void forEachHandler(){

        for (Integer integer : linkedList) {
            System.out.println(integer);
        }

    }

2.2、Iterator迭代器

代码案例：

/**
     * Iterator遍历
     */
    public static void iteratorHandler(){

        Iterator<Integer> iterator = linkedList.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

3、LinkedList数据结构

LinkedList数据结构：双向链表

四、ArrayList和LinkedList区别

1、ArrayList和LinkedList结构不同

ArrayList和LinkedList都是集合类，但是他们有两种不同的实现方式，ArrayList底层维护的是一个动态数组，LinkedList底层维护的是一个双向链表

ArrayList数据结构

LinkedList数据结构

2、效率不同

2.1、添加效率

ArrayList和LinkedList分别插入1000万条数据测试
ArrayList插入1000万条数据耗时420毫秒
LinkedList插入1000万条数据耗时8900毫秒

ArrayList插入1000万条数据：

public static void addArrayList(){

        long start = System.currentTimeMillis();

        ArrayList<Integer> arrayList = new ArrayList<>();

        for (int i = 1; i <= 10000000 ; i++) {
            arrayList.add(i);
        }


        long end = System.currentTimeMillis();

        System.out.println("耗时：" + (end - start));
    }

LinkedList插入1000万条数据：

public static void addLinkedList(){

        long start = System.currentTimeMillis();

        LinkedList<Integer> linkedList = new LinkedList<>();

        for (int i = 1; i <= 10000000 ; i++) {
            linkedList.add(i);
        }


        long end = System.currentTimeMillis();

        System.out.println("耗时：" + (end - start));

    }

很明显普通的插入数据，ArrayList比LinkedList要快很多，可为什么普遍说法都是LinkedList添加删除快，这里是有前提条件，LinkedList在两种情况下插入数据比ArrayList快

a、往集合中间插入数据时ArrayList比LinkedList慢

ArrayList往集合中间插入数据要做两个事：把之前的数据挪开赋值到新的数组位置，然后把需要插入的数据插入到数组对应的位置。

LinkedList只要修改对应位置数据prev和next对象的指向就可以了。

b、ArrayList正好扩容的时候添加数据要比LinkedList慢

因为ArrayList维护的是一个数组，所以当容量到达阀值时就会进行扩容，然后会重新分配数据的位置，当数组扩容的时候速度也要比LinkedList慢。

2.2、删除数据

ArrayList要比LinkedList慢，原理和往集合中间插入数据是一样的，ArrayList每次删除数据都要对数组重组。

2.3、查询数据

ArrayList比LinkedList快。
原理是ArrayList是数组有下标标记数据位置，查询时直接返回对应数组下标数据即可。

LinkedList是链表，没有对数据进行位置标记，每次获取固定位置的数据都需要循环遍历链表和linkedList.get(10)，就需要循环10次找到对应的节点返回。

五、Vector

Vector类可以实现可增长的对象数组，和ArrayList差不多
VectorJDK1.0出现的，从JDK1.2开始对该类进行改进，可以实现List接口，但是Vector是同步的，单线程，那么速度比较慢，所以被ArrayList替代

文章来源地址https://www.toymoban.com/news/detail-549906.html

到了这里，关于Java集合-List的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！