Java集合框架中的List和LinkedList以及Vector

最新推荐文章于 2022-05-26 11:29:53 发布

qq_2746843972

最新推荐文章于 2022-05-26 11:29:53 发布

阅读量197

点赞数 1

CC 4.0 BY-SA版权

文章标签： List LinkedLIst vector 集合框架

本文链接：https://blog.youkuaiyun.com/xupt_rl/article/details/89930719

本文介绍了List集合基础，包括其实现的接口、特性和特有功能。详细阐述了List三个子类ArrayList、Vector和LinkedList的特点，如底层数据结构、查询与增删效率、线程安全性等。还提及了并发修改异常及解决办法，以及LinkedList和Vector的成员方法与特有功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

list集合基础

实现了collection接口
list接口特性：是有序的，元素是可以重复的
允许元素为null

1.list
LIst的三个子类的特点
ArrayList

底层数据结构是数组，查询快，增删慢
线程不安全，效率高

Vector

底层数据结构是数组，查询快，增删慢
线程安全，效率低

LInkedList

底层数据结构是链表，查询慢，增删块
线程不安全，效率高

list中的元素有序，并且每一个元素都存在一个索引，元素可以重复。

list的特有功能

void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素返回的而是被替换的元素

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Mytest1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        //遍历方式一
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+",");
        }
        System.out.println();
        //遍历方式2
        Object[] array = list.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+",");
        }
        System.out.println();
        //便利方式3
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.print(o+",");
        }
        //在指定索引处添加元素
        list.add(2,7);
        //移除指定索引处的元素，返回的是移除的元素
        Object remove = list.remove(5);
        //获取指定索引处的元素
        Object o1 = list.get(4);
        //更改指定索引处的元素，返回的是被替代的元素
        Object set = list.set(3, 9);
        System.out.println();
        System.out.println(remove);
        System.out.println(o1);
        System.out.println(set);
    }
}

运行结果为：

1,2,3,4,5,
1,2,3,4,5,
1,2,3,4,5,
5
4
3

ListIterator的特有功能
ListIterator 继承自Iterator 可以使用Iterator中的方法
ListIterator的特有功能

boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历但是注意要完成反向遍历之前要先进行正向遍历这样指针才能移到最后

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Mytest4 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        System.out.println("........................");
        //反向遍历，用同一个迭代器，先正向遍历完，才能反向遍历
        while (listIterator.hasPrevious()){
            Object previous = listIterator.previous();
            System.out.println(previous);
        }
    }
}

运行结果为：

1
2
3
4
........................
4
3
2
1

2.并发修改异常(ConcurrentModificationException)
当我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合会出现并发修改异常
原因是我们的迭代依赖与集合当我们往集合中添加好了元素之后获取迭代器那么迭代器已经知道了集合的元素个数，这个时候你在遍历的时候又突然想给集合里面加一个元素（用的是集合的add方法）那迭代器不同意就报错了。
解决办法
用ListIterator迭代器遍历用迭代器自带的add方法添加元素那就不会报错了

来一个例子：有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Mytest5 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("abc");
        list.add("def");
        list.add("ghi");
        list.add("world");
//        Iterator iterator = list.iterator();
//        while (iterator.hasNext()){
//            Object obj = iterator.next();
//            String string = (String) obj;
//            if("world".equals(string)){
//                list.add("javaee");
//            }
//
//        }
//        System.out.println(list);
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Object obj = listIterator.next();
            String string = (String) obj;
            if("world".equals(string)){
                listIterator.add("javaee");
            }
        }
        System.out.println(list);
    }
}

运行结果为

[abc, def, ghi, world, javaee]

从上面的代码中可以看出采用原来的迭代方式就会产生并发修改异常，采用它本身的迭代器再带的add方法就不会报错。
数据结构之栈与队列
数据结构起始就是存储数据的格式
分类：栈，队列，数组，链表，树，哈希表

2.LinkedList

1.底层数据结构是双向链表，查询慢，增删块。
2. 线程不安全（线程非同步），效率低。
3.实现了Deque接口，因此可以像操作栈和队列一样操作它
成员方法

void addFirst (E e) 将指定元素插入到此列表的开头
void addLast (E e) 将指定元素插入到此列表的末尾
E getFirst () 返回此列表的第一个元素
get (index) 获取指定索引的元素
E getLast () 返回此列表的最后一个元素
int indexOf (Object o) 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回-1
int lastIndexOf (Object o) 返回此列表中最后出现指定元素的索引，如果此列表中不包含该元素，则返回-1
E peek () 获取但不移除此列表的第一个元素
E peekFirst () 获取但不移除此列表的第一个元素，如果此列表为空则返回null
E peekLast () 获取但不移除此列表的最后一个元素，如果此列表为空，则返回null
E pop () 从此列表所表示的堆栈处弹出一个元素
void push (E e) 将元素推入此列表所表示的堆栈
E removeFirst () 移除列表中的第一个元素，并且返回此列表第一个元素
E removeLast () 移除列表中的最后一个元素，并且返回此列表最后一个元素

import java.util.LinkedList;

public class Mytest2 {
    // LinkedList 底层数据结构是链表，查询慢，增删快，线程不安装效率高
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();

        linkedList.add(10);
        linkedList.add(20);
        linkedList.addLast(30);
        linkedList.addFirst(40);// [40, 10, 20, 30]
        linkedList.push(50);//[50，40, 10, 20, 30]
        linkedList.pop();//[40, 10, 20, 30]
        Object o = linkedList.get(2);
        linkedList.getFirst();
        linkedList.getLast();
        int i = linkedList.indexOf(20);
        linkedList.lastIndexOf(20);
        Object peek = linkedList.peek();
        Object o1 = linkedList.peekFirst();
        Object o2 = linkedList.peekLast();
        Object o3 = linkedList.removeFirst();
        Object o4 = linkedList.removeFirst();
        System.out.println(o3);
        System.out.println(o4);
        System.out.println(linkedList);
    }
}

3.vector
1.底层数据结构是数组，初始容量为10，每次增长2倍查询快，增删慢。
2.线程安全（线程同步），效率低。

特有功能

E elementAt ( int index) 返回指定索引处的文件
Enumeration elements () 返回此向量的组件的枚举
void insertElementAt (E obj,int index) 将指定对象作为此向量中的组件插入到指定的index处
E lastElement () 返回此向量的最后一个组件
E firstElement () 返回此向量的第一个组件（位于索引0处的项）
void addElement (E obj) 将指定的组件添加到此向量的末尾，将其大小增加1

import java.util.Vector;

public class Mytest3 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement(300);
        vector.addElement(200);
        vector.addElement(100);
        vector.add(1);
        vector.add(2);
        vector.insertElementAt(23,3);
        vector.lastElement();
        Object o = vector.firstElement();
        System.out.println(vector);
    }
}

vector特有的迭代方式

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

public class Mytest3 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement(300);
        vector.addElement(200);
        vector.addElement(100);
        vector.add(1);
        vector.add(2);
        vector.insertElementAt(23, 3);
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }
    }
}