Java集合（六）List概括,总结

最新推荐文章于 2024-07-20 12:43:53 发布
转载 最新推荐文章于 2024-07-20 12:43:53 发布 · 85 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/zhaoqian/blog/348863
文章标签：

#java #数据结构与算法 #python

本文深入探讨了Java中List接口的不同实现类，包括ArrayList、LinkedList、Vector和Stack的特点与使用场景。通过对这些实现类的插入、删除及随机访问操作的性能对比，揭示了它们在不同应用场景下的优劣。

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

第1部分 List概括

先回顾一下List的框架图

Java集合（八）LinkedList、ArrayList和Vector等使用场景和性能分析总结_www.fengfly.com

List 是一个接口，它继承于Collection的接口。它代表着有序的队列。
AbstractList 是一个抽象类，它继承于AbstractCollection。AbstractList实现List接口中除size()、get(int location)之外的函数。
AbstractSequentialList 是一个抽象类，它继承于AbstractList。AbstractSequentialList 实现了“链表中，根据index索引值操作链表的全部函数”。

ArrayList, LinkedList, Vector, Stack是List的4个实现类。

ArrayList 是一个数组队列，相当于动态数组。它由数组实现，随机访问效率高，随机插入、随机删除效率低。
LinkedList 是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList随机访问效率低，但随机插入、随机删除效率低。
Vector 是矢量队列，和ArrayList一样，它也是一个动态数组，由数组实现。但是ArrayList是非线程安全的，而Vector是线程安全的。

Stack 是栈，它继承于Vector。它的特性是：先进后出(FILO, First In Last Out)。  

http://my.oschina.net/zhaoqian/blog/348843 参考此篇.了解为什么不使用Vector和Stack.

第2部分 List使用场景

单线程环境下

(01) 对于需要快速插入，删除元素，应该使用LinkedList。
(02) 对于需要快速随机访问元素，应该使用ArrayList。

测试DEMO 

package org.credo.jdk.util;

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

public class ListCompareTest
{
	private static final int COUNT = 100000;

	private static LinkedList linkedList = new LinkedList();
	private static ArrayList arrayList = new ArrayList();
	private static Vector vector = new Vector();
	private static Stack stack = new Stack();

	public static void main(String[] args)
	{
		// 换行符
		System.out.println();
		// 插入
		insertByPosition(stack);
		insertByPosition(vector);
		insertByPosition(linkedList);
		insertByPosition(arrayList);

		// 换行符
		System.out.println();
		// 随机读取
		readByPosition(stack);
		readByPosition(vector);
		readByPosition(linkedList);
		readByPosition(arrayList);

		// 换行符
		System.out.println();
		// 删除
		deleteByPosition(stack);
		deleteByPosition(vector);
		deleteByPosition(linkedList);
		deleteByPosition(arrayList);
	}

	// 获取list的名称
	private static String getListName(List list)
	{
		if (list instanceof LinkedList)
		{
			return "LinkedList";
		} else if (list instanceof ArrayList)
		{
			return "ArrayList";
		} else if (list instanceof Stack)
		{
			return "Stack";
		} else if (list instanceof Vector)
		{
			return "Vector";
		} else
		{
			return "List";
		}
	}

	// 向list的指定位置插入COUNT个元素，并统计时间
	private static void insertByPosition(List list)
	{
		long startTime = System.currentTimeMillis();

		// 向list的位置0插入COUNT个数
		for (int i = 0; i < COUNT; i++)
			list.add(0, i);

		long endTime = System.currentTimeMillis();
		long interval = endTime - startTime;
		System.out.println(getListName(list) + " : insert " + COUNT + " elements into the 1st position use time："
				+ interval + " ms");
	}

	// 从list的指定位置删除COUNT个元素，并统计时间
	private static void deleteByPosition(List list)
	{
		long startTime = System.currentTimeMillis();

		// 删除list第一个位置元素
		for (int i = 0; i < COUNT; i++)
			list.remove(0);

		long endTime = System.currentTimeMillis();
		long interval = endTime - startTime;
		System.out.println(getListName(list) + " : delete " + COUNT + " elements from the 1st position use time："
				+ interval + " ms");
	}

	// 根据position，不断从list中读取元素，并统计时间
	private static void readByPosition(List list)
	{
		long startTime = System.currentTimeMillis();

		// 读取list元素
		for (int i = 0; i < COUNT; i++)
			list.get(i);

		long endTime = System.currentTimeMillis();
		long interval = endTime - startTime;
		System.out.println(getListName(list) + " : read " + COUNT + " elements by position use time：" + interval
				+ " ms");
	}
}


输出: 

Stack : insert 100000 elements into the 1st position use time：987 ms
Vector : insert 100000 elements into the 1st position use time：940 ms
LinkedList : insert 100000 elements into the 1st position use time：13 ms
ArrayList : insert 100000 elements into the 1st position use time：947 ms

Stack : read 100000 elements by position use time：6 ms
Vector : read 100000 elements by position use time：5 ms
LinkedList : read 100000 elements by position use time：5655 ms
ArrayList : read 100000 elements by position use time：2 ms

Stack : delete 100000 elements from the 1st position use time：1625 ms
Vector : delete 100000 elements from the 1st position use time：959 ms
LinkedList : delete 100000 elements from the 1st position use time：5 ms
ArrayList : delete 100000 elements from the 1st position use time：1356 ms


从上可以发现,insert操作和delete操作,LinkedList是完胜的.而基于数组的arrayList,vector,stack都是在read上完胜.


第3部分 LinkedList和ArrayList性能差异分析

下面我们看看为什么LinkedList中插入元素很快，而ArrayList中插入元素很慢！

LinkedList.java中向指定位置插入元素的代码如下： 

// 在index前添加节点，且节点的值为element  
public void add(int index, E element) {  
    addBefore(element, (index==size ? header : entry(index)));  
}  
 
// 获取双向链表中指定位置的节点  
private Entry<E> entry(int index) {  
    if (index < 0 || index >= size)  
        throw new IndexOutOfBoundsException("Index: "+index+  
                                            ", Size: "+size);  
    Entry<E> e = header;  
    // 获取index处的节点。  
    // 若index < 双向链表长度的1/2,则从前向后查找;  
    // 否则，从后向前查找。  
    if (index < (size >> 1)) {  
        for (int i = 0; i <= index; i++)  
            e = e.next;  
    } else {  
        for (int i = size; i > index; i--)  
            e = e.previous;  
    }  
    return e;  
}  
 
// 将节点(节点数据是e)添加到entry节点之前。  
private Entry<E> addBefore(E e, Entry<E> entry) {  
    // 新建节点newEntry，将newEntry插入到节点e之前；并且设置newEntry的数据是e  
    Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);  
    // 插入newEntry到链表中  
    newEntry.previous.next = newEntry;  
    newEntry.next.previous = newEntry;  
    size++;  
    modCount++;  
    return newEntry;  
}



从中，我们可以看出：通过add(int index, E element)向LinkedList插入元素时。先是在双向链表中找到要插入节点的位置index；找到之后，再插入一个新节点。
双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。

接着，我们看看ArrayList.java中向指定位置插入元素的代码。如下： 

// 将e添加到ArrayList的指定位置  
public void add(int index, E element) {  
    if (index > size || index < 0)  
        throw new IndexOutOfBoundsException(  
        "Index: "+index+", Size: "+size);  
 
    ensureCapacity(size+1);  // Increments modCount!!  
    System.arraycopy(elementData, index, elementData, index + 1,  
         size - index);  
    elementData[index] = element;  
    size++;  
}



ensureCapacity(size+1) 的作用是“确认ArrayList的容量，若容量不够，则增加容量。”
真正耗时的操作是 System.arraycopy(elementData, index, elementData, index + 1, size - index);

Sun JDK包的java/lang/System.java中的arraycopy()声明如下

public   static   native   void  arraycopy(Object src,  int  srcPos, Object dest,  int  destPos,  int  length);


arraycopy()是个JNI函数，它是在JVM中实现的。sunJDK中看不到源码，不过可以在OpenJDK包中看到的源码。网上有对arraycopy()的分析说明，请参考：System.arraycopy源码分析 
实际上，我们只需要了解： System.arraycopy(elementData, index, elementData, index + 1, size - index); 会移动index之后所有元素即可。这就意味着，ArrayList的add(int index, E element)函数，会引起index之后所有元素的改变！


通过上面的分析，我们就能理解为什么LinkedList中插入元素很快，而ArrayList中插入元素很慢。
“删除元素”与“插入元素”的原理类似，这里就不再过多说明。

接下来，我们看看 “为什么LinkedList中随机访问很慢，而ArrayList中随机访问很快”。

先看看LinkedList随机访问的代码 

// 返回LinkedList指定位置的元素  
public E get(int index) {  
    return entry(index).element;  
}  
 
// 获取双向链表中指定位置的节点  
private Entry<E> entry(int index) {  
    if (index < 0 || index >= size)  
        throw new IndexOutOfBoundsException("Index: "+index+  
                                            ", Size: "+size);  
    Entry<E> e = header;  
    // 获取index处的节点。  
    // 若index < 双向链表长度的1/2,则从前先后查找;  
    // 否则，从后向前查找。  
    if (index < (size >> 1)) {  
        for (int i = 0; i <= index; i++)  
            e = e.next;  
    } else {  
        for (int i = size; i > index; i--)  
            e = e.previous;  
    }  
    return e;  
}




从中，我们可以看出：通过get(int index)获取LinkedList第index个元素时。先是在双向链表中找到要index位置的元素；找到之后再返回。
双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。

下面看看ArrayList随机访问的代码 

// 获取index位置的元素值  
public E get(int index) {  
    RangeCheck(index);  
 
    return (E) elementData[index];  
}  
 
private void RangeCheck(int index) {  
    if (index >= size)  
        throw new IndexOutOfBoundsException(  
        "Index: "+index+", Size: "+size);  
}



从中，我们可以看出：通过 get(int index) 获取ArrayList第index个元素时。直接返回数组中index位置的元素，而不需要像LinkedList一样进行查找。



转载于:https://my.oschina.net/zhaoqian/blog/348863

java栈的清空_java清空堆栈中的某个元素
weixin_39727005的博客
02-13 2065
并不是彻底把它从数组中拿掉，而是把存储的总数减少，本人写得可以比这个好，在拿掉某个元素时，顺便也让它从数组中消失，将那个元素所在的位置的值设置为null即可.public class Stack {private Object[] elements=new Object[10];private int size = 0;public void push(Object e){ensureCapaci...
java自写代码--顺序栈、链栈的基本操作
yyldeh的博客
04-13 1091
【最近有点忙、、给忘了，这周一定开启下一篇章】 一、顺序栈的基本操作 1.代码 包含栈的初始化、判断栈是否为空、入栈、出栈、栈清空以及销毁栈 //顺序栈的相关实现 public class stack { public int base[] ; public int top;//栈顶指针 public int stacksize; public stack() { this(10); } public stack(int stacksize) {//将栈初始化
java清空栈_java - 如何使用Intent.FLAG_ACTIVITY_CLEAR_TOP清除活动堆栈？
weixin_42347465的博客
02-16 971
java - 如何使用Intent.FLAG_ACTIVITY_CLEAR_TOP清除活动堆栈？我已经阅读了几篇关于使用它的帖子，但必须遗漏一些因为它不适合我。 我的活动A在清单中有launchmode =“singleTop”。 它启动活动B，启动模式=“singleInstance”。 活动B打开浏览器并接收和意图返回，这就是为什么它是singleInstance。 我试图覆盖后退按钮，以便...
java清空堆栈中的某个元素
小苟的专栏
11-14 4218
并不是彻底把它从数组中拿掉，而是把存储的总数减少，本人写得可以比这个好，在拿掉某个元素时，顺便也让它从数组中消失，将那个元素所在的位置的值设置为null即可. public class Stack { private Object[] elements=new Object[10]; private int size = 0; public void push(Ob
java集合面试题 全概括
最新发布
09-29
本文将对Java集合框架中的主要接口和常见实现类进行全面概括，帮助读者更好地理解和掌握这些集合的使用场景和特点。 首先，我们来区分List、Set和Map这三大核心接口的不同之处。List接口的集合特点是有序且可以包含...
java集合之List篇——ArrayList补充和Vector、LinkedList的底层源码
2202_75483664的博客
07-19 1240
上一篇介绍了基本的集合（list，Set，Map），还有对于ArrayList的源码解析。这一篇主要讲其他集合的底层源码。目录前言一、ArrayList底层源码讲解的补充（很简单）二、Vector底层源码三、LinkedList的底层源码1.概述2.要用到的常量和变量3.分步源码详解四、总结LinkedList的底层就是数据结构中的双向链表，没有容量之说，每一个 节点用一个Node类对象（静态内部类充当LinkedList类的成员属性）来存储，内容如下：item：存入集合的一个数据。
Java之集合——详细概括和ArrayList的底层源码解析
2202_75483664的博客
07-19 1080
目录一、集合的家族谱1.List2. Set3.Map4.Collection接口的方法（List、Set实现类通用）5.Map接口实现方法（Map实现类通用）二、ArrayList底层原码的详解1.前菜 2.底层原码解析示例代码(1)概况​编辑 (2)源码用到的常量和变量(3)分步源码详解A. ArrayList list = new ArrayList<>();B.第一层for循环 list.add(0);C.剩下九层循环list.add(i);
jdk1.8 List集合Stream流式处理
Yuhei001的博客
07-20 1361
Java 8 引入了一个新的抽象层——Stream API，它允许你以声明性方式处理数据集合（包括数组、集合等）。Stream API 提供了一种高效且易于表达的方式来处理数据集合，包括过滤、排序、映射和归约等操作。这种处理方式极大地提高了代码的可读性和可维护性，同时也提升了处理大量数据的性能。Stream（流）是 Java 8 引入的一个关键抽象概念，它代表了一个来自数据源的元素队列并支持聚合操作。
Java并发情况下集合的线程安全性
m0_54202121的博客
04-23 766
文章目录ConcurrentModificationException并发修改异常5.1List集合的线程不安全①，使用Vector解决②，使用Collections类的synchronizedList方法③ 使用CopyOnWriteArrayList<>(重点)5.2 HashSet集合的线程不安全5.3HashMap集合的多线程不安全 ConcurrentModificationException并发修改异常 当我们对集合进行迭代(遍历)的时候，同时（并发）对集合进行修改，就会产生并发修改
java数据结构（Stack）
weixin_48691584的博客
04-01 1489
栈(Stack)是一种有序特殊的线性表，只能在表的一端(称为栈顶，top，总是指向栈顶元素)执行插入和删除操作，最后插入的元素将第一个被删除，因此栈也称为后进先出或先进后出的线性表。
java中栈Stack类操作
weixin_33975951的博客
05-01 371
/** * Stack类 * 栈：桶型或箱型数据类型，后进先出，相对堆Heap为二叉树类型，可以快速定位并操作 * Stack<E>，支持泛型 * public class Stack<E> extends Vector<E> * Stack的方法调用的Vector的方法，被synchroniz...
为什么ArrayList查询效率高，删除效率慢
热门推荐
m1234ilu的博客
10-18 1万+
ArrayLIst查询效率高：ArrayLIst是连续存放元素的，找到第一个元素的首地址，再加上每个元素的占据的字节大小就能定位到对应的元素。 LinkedList插入删除效率高。因为执行插入删除操作时，只需要操作引用即可，元素不需要移动元素，他们分布在内存的不同地方，通过引用来互相关联起来。而ArrayLIst需要移动元素，故效率低。...
java清除堆_关于java：清除堆栈活动并完成
weixin_29716207的博客
02-25 630
本问题已经有最佳答案，请猛点这里访问。例如，我有活动A，B，C，D通话BIntent intent = new Intent(A,B.class);startActivity(intent);然后，B呼叫CIntent intent = new Intent(B,C.class);startActivity(intent);之后，C呼叫DIntent intent = new Intent(C,D...
Java API大集合: 掌握Java编程的关键资源
2. **Java集合框架**：Java集合框架（Java Collections Framework）是一个提供了一套性能优化过的接口和类的系统，用于操作和管理对象集合。这个框架包括了List、Set、Queue等接口以及ArrayList、LinkedList、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值