ArravList，LinkedList，Vector的相同点与区别

ArrayList，LinkedList，Vector的特性

• ArrayList：动态数组，使用的时候，只需要操作即可，内部已经实现扩容机制。

  • 线程不安全
  • 有顺序，会按照添加进去的顺序排好
  • 基于数组实现，随机访问速度快，插入和删除较慢一点
  • 可以插入null元素，且可以重复

• Vector和前面说的ArrayList很是类似，这里说的也是1.8版本，它是一个队列，但是本质上底层也是数组实现的。同样继承AbstractList，实现了List,RandomAcess,Cloneable, java.io.Serializable接口。具有以下特点：

  • 提供随机访问的功能：实现RandomAcess接口，这个接口主要是为List提供快速访问的功能，也就是通过元素的索引，可以快速访问到。
  • 可克隆：实现了Cloneable接口
  • 是一个支持新增，删除，修改，查询，遍历等功能。
  • 可序列化和反序列化
  • 容量不够，可以触发自动扩容
  • *最大的特点是：线程安全的，相当于线程安全的ArrayList。

• LinkedList：链表结构，继承了AbstractSequentialList，实现了List,Queue,Cloneable,Serializable，既可以当成列表使用，也可以当成队列，堆栈使用。主要特点有：

  • 线程不安全，不同步，如果需要同步需要使用List list = Collections.synchronizedList(new LinkedList());
  • 实现List接口，可以对它进行队列操作
  • 实现Queue接口，可以当成堆栈或者双向队列使用
  • 实现Cloneable接口，可以被克隆，浅拷贝
  • 实现Serializable，可以被序列化和反序列化

ArrayList，LinkedList，Vector的相同点与区别

​ Java提供了许多集合类来处理和操作数据，其中ArrayList、LinkedList和Vector是常见的几种。这些集合类具有相似的功能，但在实现和性能方面存在一些区别。本文将详细介绍ArrayList、LinkedList和Vector的相同点和区别，并提供相应的源代码示例。

相同点：

1. 都实现了List接口：ArrayList、LinkedList和Vector都实现了Java的List接口，因此它们都支持有序的元素集合，并且允许元素重复。
2. 支持动态添加和删除元素：这三个集合类都提供了添加、删除和修改元素的方法，可以根据需要动态地调整集合的大小。
3. 支持迭代：所有这些集合类都可以使用迭代器（Iterator）来遍历集合中的元素。
4. 可以存储任意类型的对象：ArrayList、LinkedList和Vector都可以存储任意类型的对象，包括基本类型的包装类。

区别：

1. 底层实现方式：ArrayList和Vector底层都使用数组实现，而LinkedList使用双向链表实现。这导致它们在插入和删除元素时的性能表现有所不同。ArrayList和Vector在随机访问时性能较好，而LinkedList在插入和删除元素时性能更佳。
2. 线程安全性：Vector是线程安全的，它的所有方法都经过同步处理，可以在多线程环境下使用。而ArrayList和LinkedList则不是线程安全的，如果在多线程环境下使用它们，需要自行处理线程同步问题。
3. 扩容方式：当集合需要扩容时，ArrayList默认增加当前容量的一半，而Vector默认增加当前容量的一倍。这也是为什么在大量数据操作时，Vector的性能可能会比ArrayList略差的原因之一。

ArrayList，LinkedList，Vector的基础使用

1、ArrayList的基础使用
ArrayList是Java中的一个动态数组类，可以存储任意类型的数据，并且长度可以动态改变。下面是一个使用代码来深度讲解ArrayList集合的示例：

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建一个ArrayList对象
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // 获取元素
        String firstElement = list.get(0);
        System.out.println("第一个元素是：" + firstElement);

        // 修改元素
        list.set(2, "JavaScript");
        System.out.println("修改后的元素列表：" + list);

        // 删除元素
        list.remove(1);
        System.out.println("删除后的元素列表：" + list);

        // 判断是否包含指定元素
        boolean containsPython = list.contains("Python");
        System.out.println("列表是否包含Python：" + containsPython);

        // 获取元素的索引
        int index = list.indexOf("Java");
        System.out.println("Java的索引为：" + index);

        // 获取列表的长度
        int size = list.size();
        System.out.println("列表的长度为：" + size);

        // 遍历列表
        for (int i = 0; i < list.size(); i++) {
            String element = list.get(i);
            System.out.println("第" + (i + 1) + "个元素是：" + element);
        }
    }
}

上面的代码演示了ArrayList集合的一些常用操作：

1. 创建ArrayList对象：通过new ArrayList<>()来创建一个ArrayList对象，可以在<>中指定存储的元素类型。

2. 添加元素：使用add()方法来将元素添加到ArrayList中，可以添加任意类型的元素。

3. 获取元素：使用get()方法来获取指定索引位置的元素。

4. 修改元素：使用set()方法来修改指定索引位置的元素。

5. 删除元素：使用remove()方法来删除指定索引位置的元素。

6. 判断是否包含指定元素：使用contains()方法来判断ArrayList是否包含指定元素。

7. 获取元素的索引：使用indexOf()方法来获取指定元素在ArrayList中的索引。

8. 获取列表的长度：使用size()方法来获取ArrayList的长度。

9. 遍历列表：使用for循环来遍历ArrayList中的元素。

上面的代码只是演示了ArrayList的一些基本操作，还有很多其他的方法可以操作ArrayList集合。使用ArrayList可以方便地对一组数据进行存储和操作，是Java中常用的集合类之一。

2、LinkedList的基础使用
LinkedList是Java中提供的一个双向链表实现的数据结构，它实现了List接口，能够存储任意类型的元素。和ArrayList相比，LinkedList在插入、删除元素时具有快速的性能，但是在访问和查找元素时相对较慢。

下面是LinkedList的基础使用：

1. 创建LinkedList对象
   可以使用无参构造函数创建一个空的LinkedList对象：

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

也可以使用带有Collection参数的构造函数，将一个集合中的元素加入到LinkedList中：

List<String> list = Arrays.asList("a", "b", "c");
LinkedList<String> linkedList = new LinkedList<>(list);

2. 添加元素
   可以使用add方法往LinkedList的尾部添加一个元素：

linkedList.add("d");

也可以使用addFirst或addLast方法在LinkedList的头部或尾部添加一个元素：

linkedList.addFirst("z");
linkedList.addLast("y");

3. 获取元素
   可以使用get方法根据索引获取LinkedList中的某个元素：

String element = linkedList.get(0);

也可以使用getFirst或getLast方法获取LinkedList的头部或尾部元素：

String firstElement = linkedList.getFirst();
String lastElement = linkedList.getLast();

4. 删除元素
   可以使用remove方法根据索引删除LinkedList中的某个元素：

linkedList.remove(0);

也可以使用removeFirst或removeLast方法删除LinkedList的头部或尾部元素：

linkedList.removeFirst();
linkedList.removeLast();

5. 修改元素
   可以使用set方法根据索引修改LinkedList中的某个元素：

linkedList.set(0, "new value");

6. 遍历元素
   可以使用for循环遍历LinkedList中的元素：

for (String element : linkedList) {
    System.out.println(element);
}

也可以使用迭代器遍历LinkedList中的元素：

Iterator<String> iterator = linkedList.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

这些是LinkedList的基础使用方法，通过这些方法可以对LinkedList进行增删改查等操作。

注意：LinkedList不是线程安全的，如果在多线程环境下使用LinkedList，需要进行适当的同步处理。

3、Vector的基础使用
Vector集合是Java中用于存储一组对象的动态数组，它可以自动调整容量以适应存储的元素数量的变化。以下是使用代码深度讲解Vector集合的一些常见操作：

1. 导入Vector类：

import java.util.Vector;

2. 创建Vector集合：

Vector<String> vector = new Vector<String>();

3. 添加元素到Vector集合：

vector.add("元素1");
vector.add("元素2");
vector.add("元素3");

4. 获取Vector集合的大小：

int size = vector.size();
System.out.println("Vector集合的大小: " + size);

5. 获取Vector集合中的元素：

String element = vector.get(0);
System.out.println("Vector集合中的第一个元素: " + element);

6. 删除Vector集合中的元素：

vector.remove(0);

7. 判断Vector集合是否为空：

boolean isEmpty = vector.isEmpty();
System.out.println("Vector集合是否为空: " + isEmpty);

8. 遍历Vector集合：

for(String element : vector){
    System.out.println(element);
}

9. 清空Vector集合：

vector.clear();

以上是Vector集合的基本操作，可以根据需求进行相应的调用和修改。需要注意的是，Vector集合是线程安全的，因此在多线程环境下使用Vector集合可以确保数据的一致性。

迭代器

LinkedList源码中一共定义了三个迭代器：

• Itr:实现了Iterator接口，是AbstractList.Itr的优化版本。
• ListItr:继承了Itr,实现了ListIterator，是AbstractList.ListItr优化版本。
• ArrayListSpliterator:继承于Spliterator,Java 8 新增的迭代器，基于索引，二分的，懒加载器。

Vector和ArrayList基本差不多，都是定义了三个迭代器：

• Itr:实现接口Iterator，有简单的功能：判断是否有下一个元素，获取下一个元素，删除，遍历剩下的元素
• ListItr:继承Itr，实现ListIterator，在Itr的基础上有了更加丰富的功能。
• VectorSpliterator:可以分割的迭代器，主要是为了分割以适应并行处理。和ArrayList里面的ArrayListSpliterator类似。

LinkedList里面定义了三种迭代器，都是以内部类的方式实现，分别是：

• ListItr：列表的经典迭代器
• DescendingIterator：倒序迭代器
• LLSpliterator：可分割迭代器

ArrayList，LinkedList，Vector使用iterator迭代器代码演示

1. ArrayList集合的迭代器演示代码：

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

public class ArrayListIteratorDemo {
    public static void main(String[] args) {
        // 创建ArrayList集合
        ArrayList<String> arrayList = new ArrayList<String>();

        // 添加元素到ArrayList集合
        arrayList.add("元素1");
        arrayList.add("元素2");
        arrayList.add("元素3");

        // 使用迭代器遍历ArrayList集合
        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

运行结果：

2. LinkedList集合的迭代器演示代码：

import java.util.LinkedList;
import java.util.Iterator;

public class LinkedListIteratorDemo {
    public static void main(String[] args) {
        // 创建LinkedList集合
        LinkedList<String> linkedList = new LinkedList<String>();

        // 添加元素到LinkedList集合
        linkedList.add("元素1");
        linkedList.add("元素2");
        linkedList.add("元素3");

        // 使用迭代器遍历LinkedList集合
        Iterator<String> iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

运行结果：

3. Vector集合的迭代器演示代码：

import java.util.Vector;
import java.util.Iterator;

public class VectorIteratorDemo {
    public static void main(String[] args) {
        // 创建Vector集合
        Vector<String> vector = new Vector<String>();

        // 添加元素到Vector集合
        vector.add("元素1");
        vector.add("元素2");
        vector.add("元素3");

        // 使用迭代器遍历Vector集合
        Iterator<String> iterator = vector.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

运行结果：

以上示例代码展示了如何使用迭代器遍历ArrayList、LinkedList和Vector集合。通过调用集合的iterator()方法获取迭代器对象，然后使用hasNext()和next()方法来遍历集合中的元素。