【Java】List接口，以及ArrayList，LinkedList，Vector的区别（源码解析）

最新推荐文章于 2020-07-25 17:30:20 发布
最新推荐文章于 2020-07-25 17:30:20 发布
阅读量151 收藏
点赞数
分类专栏： JavaSE基础 文章标签： 类集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38534524/article/details/95919785
版权

1. List接口常用方法：

注：index与数组相同，从0开始

  • 根据下标返回元素：
    E get(int index);
  • 根据下标修改元素，返回修改前的元素
    E set(int index,E element);
  • 根据下标删除元素
    E remove(int index);
    E remove(new Integer(int value));
import java.util.ArrayList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);//添加元素
        list.add(3);
        list.add(5);
        list.add(7);
        list.add(1);
        System.out.println(list);//输出数组
        System.out.println(list.size());//返回数组大小
        System.out.println(list.contains(7));//判断是否有这个元素
        System.out.println(list.get(3));//返回数组下标为3的数
        System.out.println(list.set(3,9));//将数组下标为3的数修改为9
        System.out.println(list.get(3));//再次返回数组下标为3的数，看是否修改成功
        System.out.println(list.remove(4));//删除的是索引位置的数
        System.out.println(list.remove(new Integer(5)));//删除数字5
        System.out.println(list);//打印数组
    }
}

结果：在这里插入图片描述

2. LIst集合中添加自定义类：

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

class Person{
    private String name;
    private Integer age;
    
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ListTest {
    public static void main(String[] args) {
        List<Person> people = new LinkedList<>();
        Person per1 = new Person("ll",20);
        Person per2 = new Person("hh",30);
        Person per3 = new Person("fwb",1);
        people.add(per1);
        people.add(per2);
        people.add(per3);
        System.out.println(people.contains(new Person("ll",20)));
        System.out.println(people.remove(new Person("zs",20)));
    }
}

这样添加的结果是输出了两个false，因为他需要覆写equals方法以获得比较元素的支持:

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

class Person{
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /*
    这是原方法中所调用的equals方法，只是比较地址是否相同
    public boolean equals(Object obj) {
        return (this == obj);
    }
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        //instanceof用来判断是否是这类的对象  
        if (!(obj instanceof Person))
            return false;
        //向下转型取出属性值比较
        Person per = (Person)obj;
        return this.age.equals(per.age) && this.name.equals(per.name);
    }
}
public class ListTest {
    public static void main(String[] args) {
        List<Person> people = new LinkedList<>();
        Person per1 = new Person("aaa",20);
        Person per2 = new Person("bbb",30);
        Person per3 = new Person("ccc",1);
        people.add(per1);
        people.add(per2);
        people.add(per3);
        //Object obj = new Person("aaa",20);
        //父类 父类引用 = new 子类();这是向上转型
        System.out.println(people.contains(new Person("aaa",20)));
        System.out.println(people.remove(new Person("张三",20)));
    }
}

此时的输出结果是true与false是我们想要的结果。

3. List接口中ArrayList，LinkedList，Vector的区别

1. ArrayList: JKD1.2
  1. 数组实现
    1.1 初始化策略：Lazy-Load(懒加载策略)：只有当对象第一次被使用（add）时，内部的数组才会初始化为长度为10的数组。
    1.2 扩容策略：每次扩容为原先数组的1.5倍
  2. 线程不安全
    源码：
private int size;
private static final int DEFAULT_CAPACITY = 10;
1.
public boolean add(E e) {
   	ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

2.
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//二者取最大值
    }

    ensureExplicitCapacity(minCapacity);
}

3.
private void ensureExplicitCapacity(int minCapacity) {
   modCount++;

   // overflow-conscious code
   if (minCapacity - elementData.length > 0)
       grow(minCapacity);
}

4.
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
2. Vector: JDK1.0
  1. 数组实现
    1.1 初始化策略：当产生Vector对象时，内部数组就初始化为大小为10的数组（不管用不用）
    1.2 扩容：每次扩容为原先数组的2倍。
  2. 线程安全性：使用synchronized同步方法来确保线程安全性。
    但是因为使用了synchronized同步方法所以效率会很低（读写互斥）（锁的是当前整个Vector对象，操作任意一个方法，其他线程全部阻塞了，无法实现多个线程同时读这个Vector对象）
  3. 特殊点：JDK内置的Stack继承Vector。Java中自定义的栈是它的子类。
  4. Vector独有枚举输出。
    源码：
1.
public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

2.
public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

3.
private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

4.
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
3.LinkedList: JDK1.2
  1. 基于双向链表的动态数组（所以不存在初始化，扩容问题）
  2. 线程不安全
  3. 特殊：JDK Queue（队列）的一个实现子类
    在这里插入图片描述在这里插入图片描述.
4.ArrayList与LinkedList的选择：

ArrayList 适合查找（取得）和更改
LinkedList 适合增加（插入）删除

我顶得了
关注
专栏目录
List中接口中的ArrayList和LinkedList
qq_41889292的博客
04-02 1141
List1.  List接口是Collection的子接口，可以将元素维护在特定的序列中；List在Collection基础上添加了大量的方法，使得可以再List中间插入和移除元素，并却List允许有重复元素出现，元素存入的顺序和取出的顺序一致。2.List支持对元素的增，删，改，查；（1）添加：       add（index，element）：指定索引位置插入元素。       addAll（...
Java中Collection 接口、List接口、ArrayList/LinkedList/Vector的异同、set接口、HashSet/LinkedHashSetTreeSet
weixin_44514198的博客
04-13 475
1. Java集合概述 1.1 Java集合作用： Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的 关联数组。 1.2 Java 集合可分为 Collection 和 Map 两种体系 Collection接口：单列数据，定义了存取一组对象的方法的集合 List：元素有序、可重复的集合 Set：元素无序、不可重复的集合 Map接口：双列数据，保存具有映射关系“key-v...
ArrayLIst、Vector、LinkedList关系与区别
我是扣肉呀~
08-16 180
相同点： 1.ArrayLIst、Vector、LinkedList都属于List接口常用子类； 2.ArrayLIst、Vector是基于数组实现，LinkedList基于链表实现； 不同点： 1.ArrayList采用懒加载策略，扩容为原先数组的1.5倍，采用异步处理，线程不安全，性能较高； 2.Vector当产生对象时就初始化...
ArrayList, Vector, LinkedList关系与区别
王白白的博客
11-20 133
ArrayList, Vector, LinkedList关系与区别 a: ArrayList, Vector, LinkedList都属于List接口常用的子类，其中ArrayList，Vector基于数组实现，LinkedList基于链表实现； b: ArrayList采用懒加载策略，扩容为原先数组的1.5倍，采用异步处理，线程不安全，性能较高。在频繁查找以及尾部的插入与删除场景下使用...
ArrayList.LinkedList.Vector三者之间的区别与联系
word_joke的博客
04-04 565
现在得去说说这三者之间的区别与联系了：这三者都是实现了List接口，都拥有List接口里面定义的方法，并且同时拥有Collection接口的方法；        ArrayList:采用的是数组的方式进行存储数据的，查询和修改速度快，但是增加和删除速度慢；线程是不同步        LinkedList:采用的是链表的方式进行存储数据的，查询和修改速度慢，但是增加和删除速度快        Vec...
List中两个子类ArrayList和LinkedList的区别
jjjjja10028的博客
07-18 588
在程序开发中，少不了用到集合的时候；如果目标是一个优秀的程序员，就不能使用一个ArrayList走遍天下，应该在不同的场景下使用不同的集合。本文章主要介绍List集合中的子类ArrayList和LinkedList的区别，以及它们该如何选用。 先让我们看一下Collection中常用的集合，它有两个常用的子类，一个是List，另一个是Set。 List中常用的就是ArrayList（最常用） LinkedList(次之)。 和Set集合相比，List集合拥有特有的方法，以及元素存储有序。相比于Se.
ArrayList LinkedList Vector区别
08-22
ArrayList、LinkedList、Vector 是 Java 中常用的数据结构实现类，它们都实现了 List 接口，但它们在存储方式、性能、线程安全性等方面有着不同特点。 首先，ArrayList 和 Vector 都是采用数组方式存储数据的，这种...
ArrayList LinkedList Vector性能测试
05-03
在Java编程语言中，ArrayList、LinkedList和Vector是三种常见的动态数组实现，它们都在java.util包中，用于存储和管理对象的集合。这三个类都实现了List接口，提供了多种操作方法，但它们在内部实现和性能特性上有所...
Java中Vector与ArrayList的区别详解
09-05
Java中的ArrayList和Vector都是列表（List）接口的实现类，它们在功能上相似，但在细节上存在一些重要的差异。这两个类都是基于数组实现的，但它们的性能特点、线程安全性和扩容策略有所不同。 1. **扩容策略**： ...
java8源码-csn-list:ArrayList、LinkedList、Vector、Stack源码分析
06-04
List相关实现类的源码解析（JDK1.8） 2018.9.22- List的架构图 ArrayList 继承关系： ArrayList -> AbstractList 实现 List接口 ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态...
ArrayList,LinkedList,vector区别
u010277958的博客
05-29 761
ArrayList,LinkedList,Vector这三个类都实现了java.util.List接口，但它们有各自不同的特性，主要如下： 1.同步性 ArrayList,LinkedList都是线程不同步的，而Vector是线程同步的。所以如果不要求线程安全的话，可以使用ArrayList或LinkedList，可以节省为同步而耗费的开销。但在多线程的情况下，有时候就不得不使用Vecto...
Java中List接口的三个常用子类ArrayList、LinkedList、Vector
zxjzxj1234的专栏
06-19 248
List接口在Collection的基础上添加了大量的方法，使得可以在List中插入和移除元素。 1、三个子类基本特点 ArrayList：底层实现是数组。查询快，插入、删除慢；线程不安全、效率高。 LinkedList：底层实现是链表。查询慢，插入、删除快；线程不安全、效率高。LinkedList包含的操作多于ArrayList。 Vector：底层实现也是数组，在遇到线程共享资源时，使...
List集合源码解析（ArrayList、Vector篇）
BodyCoding
06-18 240
前言         讲List之前，先复习一下基础。首先List是一个接口，并且继承了Collection接口，Collection接口继承了Iterable接口。Collection接口的主要方法有： boolean add(Object o)添加对象到集合 boolean remove(Object o)删除指定...
ArrayList、Vector和LinkedList的区别及使用场景
ty6693的博客
03-15 6529
一、前言 ArrayList、Vector和LinkedList都是实现了List接口（允许数据重复）的容器类，它们都能对元素做增删改查的操作。 二、具体介绍 ArrayList ArrayList是基于数组实现的，采用懒加载策略（第一次add时才初始化内部数组，默认初始化大小为10）。它允许对元素的快速随机访问以及在链表尾部进行插入或删除元素操作。但是当随机插入元素时，如果此时数组大小已经...
集合-------总
mqingo的博客
09-18 261
一.数据结构之数组和链表 A:数组     * 查询快修改也快     * 增删慢 B:链表     * 查询慢,修改也慢     * 增删快 二.List的三个子类的特点 A:List的三个子类的特点         ArrayList:             底层数据结构是数组，查询快，增删慢。             线程不安全，效率高。         Vector:      ...
ArrayList、LinkedList、Vector的区别和实现原理
热门推荐
kuangsonghan的博客
04-09 1万+
ArrayList、LinkedList、Vector是集合中经常拿来比较和面试的一个问题，我这里简要概括一下他们的区别和实现原理。存储结构ArrayList和Vector是按照顺序将元素存储（从下表为0开始），删除元素时，删除操作完成后，需要使部分元素移位，默认的初始容量都是10.ArrayList和Vector是基于数组实现的，LinkedList是基于双向链表实现的（含有头结点）。线程安全性...
ArrayList和LinkedList、Vector的区别
长不大的大灰狼
07-25 7547
1 ArrayList和LinkedList的区别： （1）相同点： LinkedeList和ArrayList都实现了List接口。 ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。 （2）不同点： ArrayList底层的实现数组，而LinkedList是双向链表。 ArrayList进行随机访问所消耗的时间是固定的，因此随机访问时效率比较高。 LinkedList是不支持快速的随机访问的，但是在插入删除时效率比较高。 2 ArrayLi.
集合框架中List接口下的三个子类ArrayList、Vector、LinkedList的区别(源码分析)
baidu_39334407的博客
04-20 455
1、首先先看一下类集中Collection接口之下的实现子类继承关系 2、首先，他们的使用效果是一样的，没区别，如下所示： 使用ArrayList子类： 使用Vector子类(用的少) 使用LinkedList子类 3、下面详细说明一下List接口下的三个子类ArrayList、Vector、LinkedList之间的区别： 3.1、ArrayList与Vector之间的区别 1.出现版本：...
Java深究之Vector、ArrayList、LinkedList的区别
doc_wei
08-23 418
在java开发中除了上文经常用的对字符串的操作外，还有使用居多的当属集合了。在基础的java学习时，相信很多同学都学习了List、Set、Map这些，他们之间的区别和基本的使用方法也是很了解了，本文是详细的去分析List中Vector、ArrayList、LinkedList之间的区别和底层实现原理以及使用场景 首先说下这三者的区别： 1.基本区别：三个类都实现了List接口，都是有序集合，数...
Java OOP复习：List接口与ArrayList, LinkedList, Vector详解
"Java OOP课程总复习，重点关注List接口及其子类ArrayList、LinkedList和Vector。此外，简述了对象的面向对象特性以及HashMap的基本操作。" 在Java面向对象编程（OOP）中，List接口是集合框架的重要组成部分，它是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我顶得了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值