Java类集中的ArrayList、Vector、LinkedList、以及三者的区别、fail-safe(安全失败)与fail-fast(快速失败)的区别

最新推荐文章于 2022-10-04 00:00:53 发布

zhao_miao

最新推荐文章于 2022-10-04 00:00:53 发布

阅读量534

点赞数 2

分类专栏： Java Java学习文章标签： ArrayList类以及源码分析 Vector类以及源码分析 LinkedList类以及源码分析 ArrayList、Vector、LinkedList的区别 fail-fast与fail-safe

本文链接：https://blog.csdn.net/zhao_miao/article/details/88538966

版权

Java 同时被 2 个专栏收录

70 篇文章 10 订阅

订阅专栏

Java学习

53 篇文章 3 订阅

订阅专栏

1.Collection接口

Collection接口的操作形式与链表的操作形式类似，每一次进行数据操作的时候只能够对单个对象进行处理。Collection是单个元素集合保存的最大父接口。我们很少会直接使用
Collection接口，因为Collection接口只是一个存储数据的标准，并不能区分存储类型。例如：要存放的数据需要区分重复与不重复。在实际使用中往往会考虑使用Collection接口的子接口: List(允许数据重复)、Set(不允许数据重复)。

Collection接口的定义:
在这里插入图片描述

2.List接口

在进行集合处理的时候，优先考虑List接口，在这个接口中有两个重要的扩充方法 :

public E get(int index)  //根据索引取得数据
public E set(int index,E element) //根据指定索引修改相应元素

List子接口与Collection接口相比最大的特点在于其有一个get()方法，可以根据索引取得内容。由于List本身还是接口，要想取得接口的实例化对象，就必须有子类，在List接口下有三个常用子类：ArrayList、Vector、LinkedList。
在这里插入图片描述

2.1 ArrayList类

产生版本: JDK1.2
包: import java.util.ArrayList;
定义:List<E> list = new ArrayList<>(); ArrayList<> list = new ArrayList<>();

import java.util.ArrayList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //1.添加元素
        list.add("hello");
        list.add("school");
        //添加重复元素---允许添加重复元素
        list.add("hello");
        //2.将索引为1的元素改为world
        list.set(1,"world");
        //3.输出索引为1的元素--此时应该为world
        System.out.println(list.get(1));
        //输出集合
        System.out.println(list);
        //4.输出集合长度
        System.out.println(list.size());
        //5.判断集合是否包含某个元素
        System.out.println(list.contains("h"));
        //6.删除元素 ---只删除第一个元素
        System.out.println(list.remove("hello"));
        //输出
        System.out.println(list);
        //7.清空集合
        list.clear();
        //输出集合
        System.out.println(list);
    }
}

运行结果:
world
[hello, world, hello]
3
false
true
[world, hello]

若想要使用ArrayList添加自定义类，就必须覆写equals()方法，因为集合中的contains（）、remove（）等方法需要调用equals（）来判断元素是否相等

import java.util.ArrayList;
import java.util.List;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        //1.如果obj与this的地址相等 返回true
        if(obj == this){
            return true;
        }
        //2.如果obj==null  返回false
        if(obj == null){
            return false;
        }
        //3.如果obj不是Person类的实例化对象
        if(!(obj instanceof Person)){
            return false;
        }
        //4.如果传入对象不为空,且为Person的实例化对象
        //向下转型
        Person per = (Person)obj;
        return this.name.equals(per.name) && this.age==per.age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Person per1 = new Person("张三",18);
        Person per2 = new Person("李四",20);
        List<Person> list = new ArrayList<>();
        //添加元素
        list.add(per1);
        list.add(per2);
        //判断是否包含某个元素
        System.out.println(list.contains(new Person("张三",18)));
        System.out.println(list);
    }
}

输出结果:
true
[Person{name=‘张三’, age=18}, Person{name=‘李四’, age=20}]

2.1.1ArrayList源码分析

构造方法：

   public ArrayList() {
       //elementData 为存放元素的底层数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
//存放元素的底层数组
transient Object[] elementData;
//空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

ArrayList底层实现是一个对象数组、声明一个ArrayList对象时，初始化长度为0
add方法：

 public boolean add(E e) {
        //private int size; 集合的长度 
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

//minCapacity == size+1
private void ensureCapacityInternal(int minCapacity) {
         //minCapacity = size+1;
         ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) { 
        //elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 证明还未被初始化
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
           //private static final int DEFAULT_CAPACITY = 10
           //minCapacity = size+1;
          //初始状态DEFAULT_CAPACITY > minCapacity
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

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

        // size+1 > 数组长度的话进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //新容量为旧容量的1.5倍 oldCapacity >> 1相当于除2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //第一次初始化时 oldCapacity=0 minCapacity=10
        if (newCapacity - minCapacity < 0)
            //newCapacity  = size+1;
            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);
    }

ArrayList对集合的操作是异步处理，性能较高，线程不安全，当ArrayList当数组长度不够用时，扩容策略为原来数组的1.5倍

2.2 Vector类

产生版本:JDK1.0
包:import java.util.Vector;
定义:Vector<E> vector = new Vector<>(); List<E> vector = new Vector<>();

import java.util.Vector;

public class Test {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Hello");
        vector.add("World");
        vector.add("Study");
        //1.添加重复元素
        vector.add("Hello");
        //2.将下标为1的元素改为China  即将world改为China
        vector.set(1,"China");
        //输出集合
        System.out.println(vector);
        //3.输出集合的长度-----4
        System.out.println(vector.size());
        //3.观察集合是否包含h----false
        System.out.println(vector.contains("h"));
        //4.观察集合是否包含Hello -----true
        System.out.println(vector.contains("Hello"));
        //5.删除Hello----true 删除成功只删除第一个
        System.out.println(vector.remove("Hello"));
        //输出集合
        System.out.println(vector);
    }
}

输出结果:
[Hello, China, Study, Hello]
4
false
true
true
[China, Study, Hello]

同ArrayList一样，若想要添加自定义类，就必须覆写equals()方法，集合中的contains（）、remove（）等方法需要调用equals（）来判断元素是否相等

import java.util.Vector;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        //1.如果obj与this的地址相等 返回true
        if(obj == this){
            return true;
        }
        //2.如果obj==null  返回false
        if(obj == null){
            return false;
        }
        //3.如果obj不是Person类的实例化对象
        if(!(obj instanceof Person)){
            return false;
        }
        //4.如果传入对象不为空,且为Person的实例化对象
        //向下转型
        Person per = (Person)obj;
        return this.name.equals(per.name) && this.age==per.age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Person per1 = new Person("张三",18);
        Person per2 = new Person("李四",20);
        Vector<Person> vector = new Vector<>();
        vector.add(per1);
        vector.add(per2);
        //判断是否包含某个元素
        System.out.println(vector.contains(new Person("张三",18)));
        System.out.println(vector);
    }
}

输出结果:
true
[Person{name=‘张三’, age=18}, Person{name=‘李四’, age=20}]

2.2.1 Vector源码分析

构造方法:

 public Vector() {
        this(10);
    }
public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
 //此时initialCapacity=10、capacityIncrement=0
 public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //protected Object[] elementData;
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

Vector底层实现是一个对象数组，声明一个Vector对象时，初始化对象数组的长度为10
add方法

 public synchronized boolean add(E e) {
        modCount++;
        //elementCount为数组的长度 初始化elementCount=0
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

//此时minCapacity=1  elementData.length=0
private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //新容量 = 2oldCapacity  由于capacityIncrement初始化时等于0
        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);
    }

Vector对集合的修改都采用同步处理（直接在方法上使用内建锁），性能较低，线程安全、Vector当数组长度不够用时，扩容策略变为原来数组的2倍

2.3 LinkedList类

产生版本:JDK1.2
包:java.util.LinkedList
定义:LinkedList<E> linkedList = new LinkedList<>(); List<String> linkedList = new LinkedList<>();

import java.util.LinkedList;
public class Test {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Hello");
        linkedList.add("World");
        linkedList.add("Study");
        //1.添加重复元素
        linkedList.add("Hello");
        //2.将下标为1的元素改为China  即将world改为China
        linkedList.set(1,"China");
        //输出集合
        System.out.println(linkedList);
        //3.输出集合的长度-----4
        System.out.println(linkedList.size());
        //3.观察集合是否包含h----false
        System.out.println(linkedList.contains("h"));
        //4.观察集合是否包含Hello -----true
        System.out.println(linkedList.contains("Hello"));
        //5.删除Hello----true 删除成功只删除第一个
        System.out.println(linkedList.remove("Hello"));
        //输出集合
        System.out.println(linkedList);
    }
}

输出结果:
[Hello, China, Study, Hello]
4
false
true
true
[China, Study, Hello]
同ArrayList、Vector一样，若想要添加自定义类，就必须覆写equals()方法，集合中的contains（）、remove（）等方法需要调用equals（）来判断元素是否相等

import java.util.LinkedList;
import java.util.Vector;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        //1.如果obj与this的地址相等 返回true
        if(obj == this){
            return true;
        }
        //2.如果obj==null  返回false
        if(obj == null){
            return false;
        }
        //3.如果obj不是Person类的实例化对象
        if(!(obj instanceof Person)){
            return false;
        }
        //4.如果传入对象不为空,且为Person的实例化对象
        //向下转型
        Person per = (Person)obj;
        return this.name.equals(per.name) && this.age==per.age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Person per1 = new Person("张三",18);
        Person per2 = new Person("李四",20);
        LinkedList<Person> linkedList = new LinkedList<>();
        linkedList.add(per1);
        linkedList.add(per2);
        //判断是否包含某个元素
        System.out.println(linkedList.contains(new Person("张三",18)));
        System.out.println(linkedList);
    }
}

输出结果:
true
[Person{name=‘张三’, age=18}, Person{name=‘李四’, age=20}]

2.3.1 LinkedList源码分析

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

LinkedList底层基于双向链表
add方法：

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

LinkedList对集合采用异步处理、性能较高、不安全

2.4 对比ArrayList、Vector、LinkedList

ArrayList、Vector、LinkedList均是List的子类
ArrayList是JDK1.2 产生的底层基于数组、异步操作、性能较高、线程不安全
Vector是JDK1.0产生的底层也是基于数组、同步操作(方法上使用了synchronized同步锁)、性能较低、线程安全
LinkedList是JDK1.2产生的、底层基于双向链表、异步操作、性能较高、线程不安全
ArrayList采用懒加载策略初始化时大小为0 Vector初始化长度为10
扩容操作时ArrayList扩大为原来的1.5倍、Vector扩容为原来的2倍
LinkedList适合指定位置插入、删除操作，不适合查找；ArrayList、Vector适合查找，不适合指定位置的插入、删除操作。

2.5 fail-fast(快速失败)与fail-safe(安全失败)

fail-fast(快速失败)：
java.util.concurrentModifacationException------并发修改异常
如何产生:
在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。
原理：
迭代器在遍历时使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值 modCount++。每当迭代器使用next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
这里异常的抛出条件是检测到 modCount！=expectedmodCount 这个条件。如果集合发生变化时修改modCount值刚好又设置为了expectedmodCount值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的bug

public class Test{
    public static void main(String[] args) {
        List<String> list =
                //modCount = 0；
                new ArrayList<>();
        //modCount = 1；
        list.add("h");
        //modCount = 2；
        list.add("e");
        //modCount = 3；
        list.add("l");
        //modCount = 4；
        list.add("l");
        //modCount = 5；
        list.add("o");
        //取得迭代器时：expectedModCount = modCount = 5
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            /**
             *  final void checkForComodification() {
             *             if (modCount != expectedModCount)
             *                 throw new ConcurrentModificationException();
             *         }
             */
            String str = iterator.next();
            if(str.equals("h")){
                //modCount = 6；
                list.remove("h");
                continue;
            }
            System.out.println(str);
        }
    }
}

在这里插入图片描述
为何要抛出此异常:
尽量保证在多线程场景下数据不会产生脏读,即若有线程并发修改集合结构时，向同时在遍历此集合的线程发出一个异常，通知其集合数据已经修改
哪些类会抛出此异常：
java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改
fail-safe(安全失败)：
采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。，由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。但是虽然其避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即就是迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。

java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

zhao_miao

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java类集中的ArrayList、Vector、LinkedList、以及三者的区别、fail-safe(安全失败)与fail-fast(快速失败)的区别

文章目录1.Collection接口2.List接口2.1 ArrayList子类1.Collection接口Collection接口的操作形式与链表的操作形式类似，每一次进行数据操作的时候只能够对单个对象进行处理。Collection是单个集合保存的最大父接口。但是在实际开发中我们很少会直接使用Collection接口，往往会考虑使用Collection接口的子接口:List(允许数据重复)...
复制链接

扫一扫