Java学习-详谈List集合（ArrayList、LinkedList、Vector和Stack）

最新推荐文章于 2023-06-21 10:41:51 发布
最新推荐文章于 2023-06-21 10:41:51 发布
阅读量4.1k 收藏 6
点赞数 1
分类专栏： java学习 文章标签： List集合 ArrayList LinkedList Vector Stack
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44279178/article/details/108368907
版权

1.List接口介绍

在这里插入图片描述
java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对象称为List集合。
List集合有以下特点：

  • 在List集合中允许出现重复的元素（通过元素的equals方法来比较是否为重复的元素）
  • 所有的元素是以一种线性方式进行存储的
  • 它是一个带有索引的集合，在程序中可以通过索引来访问集合中的指定元素
  • List集合的元素有序，即元素的存入顺序和取出顺序一致

2.List接口中常用的方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操 作集合的特有方法，如下：

  • public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
  • public E get(int index) :返回集合中指定位置的元素。
  • public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
  • public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
  • public boolean addAll(int index,Collection c)：将集合c所包含的所有元素都插入在List集合的Index处。
  • public int indexOf(Object o)：返回对象o在List集合中出现的位置索引。
  • public int lastIndexOf(Object o)：返回对象o在List集合中最后一次出现的位置索引。
  • public List subList(int fromIndex,int toIndex)：返回从索引fromIndex(包含)到索引toIndex(不包含)处所有集合元素组成的子集合。

3.ArrayList集合

3.1引入——对象数组

下列代码，使用学生数组，存储三个学生对象

 class Student { 
	private String name; 
	private int age; 
	public Student() { }
	public Student(String name, int age) 
	{ 
		this.name = name; 
		this.age = age;
		}
	public String getName() 
	{ 
		return name;
		}
	public void setName(String name) 
	{ 
		this.name = name; 
		}
	public int getAge() 
	{ 
		return age; 
		}
	public void setAge(int age)
	{ 
		this.age = age; 
		} 
	}
public class test
{
	public static void main(String[] args) 
	{ //创建学生数组 
		Student[] students = new Student[3]; 
		//创建学生对象 
		Student s1 = new Student("曹操",40); 
		Student s2 = new Student("刘备",35); 
		Student s3 = new Student("孙权",30); 
		//把学生对象作为元素赋值给学生数组 
		students[0] = s1; 
		students[1] = s2; 
		students[2] = s3; 
		//遍历学生数组 
		for(int x=0; x<students.length; x++)
		{ 
			Student s = students[x];
			System.out.println(s.getName()+"‐‐‐"+s.getAge()); 
		}
	}
}

我们发现上述代码中存储对象数据，选择的容器是对象数组。而数组的长度是固定的，无法适应数据变化的需求。为了解决这个问题，Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对 象数据。

3.2ArrayList的简介

  • ArrayList基于数组实现，是一个动态的数组队列。但是它和Java中的数组又不一样，它的容量可以自动增长，类似于C语言中动态申请内存，动态增长内存！
  • ArrayList继承了AbstractList，实现了RandomAccess、Cloneable和Serializable接口！
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  • 继承了AbstractList，AbstractList又继承了AbstractCollection实现了List接口，它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能！
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    /**
     * Sole constructor.  (For invocation by subclass constructors, typically
     * implicit.)
     */
    protected AbstractList() {
    }
  • 实现了RandomAccess接口，提供了随机访问功能，实际上就是通过下标序号进行快速访问。
  • 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
  • 实现了Serializable接口，支持序列化，也就意味了ArrayList能够通过序列化传输。

3.3ArrayList的使用

  • 查看类：java.util.ArrayList <E> ：该类需要 import导入使后使用。

<E> ，表示一种指定的数据类型，叫做泛型。 E ，取自Element（元素）的首字母。在出现 E 的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。比如：

ArrayList<String>，ArrayList<Student>
  • 查看构造方法：public ArrayList() 构造一个内容为空的集合。

基本格式：

ArrayList<String> list = new ArrayList<String>();

在JDK 7后,右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：

ArrayList<String> list = new ArrayList<>();

3.4ArrayList的方法（API）

// Collection中定义的API
boolean             add(E object)
boolean             addAll(Collection<? extends E> collection)
void                clear()
boolean             contains(Object object)
boolean             containsAll(Collection<?> collection)
boolean             equals(Object object)
int                 hashCode()
boolean             isEmpty()
Iterator<E>         iterator()
boolean             remove(Object object)
boolean             removeAll(Collection<?> collection)
boolean             retainAll(Collection<?> collection)
int                 size()
<T> T[]             toArray(T[] array)
Object[]            toArray()

// AbstractCollection中定义的API
void                add(int location, E object)
boolean             addAll(int location, Collection<? extends E> collection)
E                   get(int location)
int                 indexOf(Object object)
int                 lastIndexOf(Object object)
ListIterator<E>     listIterator(int location)
ListIterator<E>     listIterator()
E                   remove(int location)
E                   set(int location, E object)
List<E>             subList(int start, int end)

// ArrayList新增的API
Object               clone()
void                 ensureCapacity(int minimumCapacity)
void                 trimToSize()
void                 removeRange(int fromIndex, int toIndex)

对于元素的操作,基本体现在——增、删、查。常用的方法有：

  • public boolean add(E e) ：将指定的元素添加到此集合的尾部。
  • public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
  • public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
  • public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

这些都是最基本的方法，操作非常简单，代码如下:

import java.util.ArrayList;
public class test
{ 
	public static void main(String[] args) 
	{ 
		//创建集合对象 
		ArrayList<String> list = new ArrayList<String>(); 
		//添加元素 
		list.add("hello"); 
		list.add("world"); 
		list.add("java"); 
		//public E get(int index):返回指定索引处的元素 
		System.out.println("get:"+list.get(0)); 
		System.out.println("get:"+list.get(1)); 
		System.out.println("get:"+list.get(2)); 
		//public int size():返回集合中的元素的个数 
		System.out.println("size:"+list.size()); 
		//public E remove(int index):删除指定索引处的元素，返回被删除的元素 
		System.out.println("remove:"+list.remove(0)); 
		//遍历输出 
		for(int i = 0; i < list.size(); i++)
		{ 
			System.out.println(list.get(i)); 
		} 	
	}
}

运行：

get:hello
get:world
get:java
size:3
remove:hello
world
java

3.5 ArrayList如何存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似 不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：
在这里插入图片描述
例如：

import java.util.ArrayList;
public class test
{ 
	public static void main(String[] args)
	{ 
		ArrayList<Integer> list = new ArrayList<Integer>(); 
		list.add(1); 
		list.add(2); 
		list.add(3); 
		list.add(4); 
		System.out.println(list); 
	}
}

[1, 2, 3, 4]

3.6 ArrayList练习

数值添加到集合 ：生成6个1~33之间的随机整数,添加到集合,并遍历

import java.util.ArrayList;
import java.util.Random;
public class test
{ 
	public static void main(String[] args) 
	{ 
		// 创建Random 对象 
		Random random = new Random(); 
		// 创建ArrayList 对象 
		ArrayList<Integer> list = new ArrayList<>(); 
		// 添加随机数到集合 
		for (int i = 0; i < 6; i++) 
		{ 
			int r = random.nextInt(33) + 1;
			list.add(r); 
		}
		// 遍历集合输出 
		for (int i = 0; i < list.size(); i++) 
		{ 
			System.out.println(list.get(i));
		} 
	}
}

28
23
15
24
2
16

对象添加到集合： 自定义4个学生对象,添加到集合,并遍历

import java.util.ArrayList;
class Student { 
	private String name; 
	private int age; 
	public Student() { }
	public Student(String name, int age) 
	{ 
		this.name = name; 
		this.age = age;
		}
	public String getName() 
	{ 
		return name;
		}
	public void setName(String name) 
	{ 
		this.name = name; 
		}
	public int getAge() 
	{ 
		return age; 
		}
	public void setAge(int age)
	{ 
		this.age = age; 
		} 
}
public class test
{ 
	public static void main(String[] args)
	{
		//创建集合对象 
		ArrayList<Student> list = new ArrayList<Student>(); 
		//创建学生对象 
		Student s1 = new Student("赵丽颖",18);
		Student s2 = new Student("唐嫣",20); 
		Student s3 = new Student("景甜",25); 
		Student s4 = new Student("柳岩",19); 
		//把学生对象作为元素添加到集合中
		list.add(s1); 
		list.add(s2); 
		list.add(s3); 
		list.add(s4); 
		//遍历集合
		for(int x = 0; x < list.size(); x++) 
		{ 
			Student s = list.get(x); 
			System.out.println(s.getName()+"‐‐‐"+s.getAge()); 
		} 
	}
}


赵丽颖‐‐‐18
唐嫣‐‐‐20
景甜‐‐‐25
柳岩‐‐‐19

打印集合方法： 定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}扩起集合，使用@分隔每个元素。格式参照 {元素 @元素@元素}。

import java.util.ArrayList;
public class test
{ 
	public static void main(String[] args) 
	{ 
		// 创建集合对象 
		ArrayList<String> list = new ArrayList<String>(); 
		// 添加字符串到集合中
		list.add("张三丰"); 
		list.add("宋远桥");
		list.add("张无忌"); list.add("殷梨亭"); 
		// 调用方法
		printArrayList(list);
	}
	public static void printArrayList(ArrayList<String> list)
	{
		// 拼接左括号 
		System.out.print("{"); 
		// 遍历集合 
		for (int i = 0; i < list.size(); i++) 
		{ 
			// 获取元素 
			String s = list.get(i); 
			// 拼接@符号 
			if (i != list.size() - 1) 
			{ 
				System.out.print(s + "@");
			} 
			else 
			{ 
				// 拼接右括号 
				System.out.print(s + "}");
			} 
		}
	}
}

{张三丰@宋远桥@张无忌@殷梨亭}

获取集合方法： 定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)

import java.util.ArrayList;
import java.util.Random;
public class test
{ 
	public static void main(String[] args) 
	{ 
		// 创建Random 对象 
		Random random = new Random(); 
		// 创建ArrayList 对象 
		ArrayList<Integer> list = new ArrayList<>(); 
		// 添加随机数到集合 
		for (int i = 0; i < 20; i++) 
		{ 
			int r = random.nextInt(1000) + 1; 
			list.add(r); 
		}
		// 调用偶数集合的方法 
		ArrayList<Integer> arrayList = getArrayList(list); 
		System.out.println(arrayList); 
	}
	public static ArrayList<Integer> getArrayList(ArrayList<Integer> list) 
	{ 
		// 创建小集合,来保存偶数 
		ArrayList<Integer> smallList = new ArrayList<>(); 
		// 遍历list 
		for (int i = 0; i < list.size(); i++) 
		{
			// 获取元素
			Integer num = list.get(i); 
			// 判断为偶数,添加到小集合中 
			if (num % 2 == 0)
			{ 
				smallList.add(num);
			}
		}
		// 返回小集合 
		return smallList;
	}
}

[794, 762, 328, 12, 978, 974, 734, 964, 686]

4.LinkedList集合

4.1LinkedList简介

LinkedList是基于链表实现的，从源码可以看出是一个双向链表。除了当做链表使用外，它也可以被当作堆栈、队列或双端队列进行操作。不是线程安全的，继承 AbstractSequentialList实现 List、Deque、Cloneable、Serializable接口。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
  • LinkedList继承AbstractSequentialList，AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数，这些接口都是随机访问List的。
  • LinkedList 实现 List 接口，能对它进行队列操作。
  • LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
  • LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
  • LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

在这里插入图片描述

4.2LinkedList的常用方法

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法：

  • public void addLast(E e) :将指定元素添加到此列表的结尾。
  • public E getFirst() :返回此列表的第一个元素。
  • public E getLast() :返回此列表的最后一个元素。
  • public E removeFirst() :移除并返回此列表的第一个元素。
  • public E removeLast() :移除并返回此列表的最后一个元素。
  • public E pop() :从此列表所表示的堆栈处弹出一个元素。
  • public void push(E e) :将元素推入此列表所表示的堆栈。
  • public boolean isEmpty() ：如果列表不包含元素，则返回true。
import java.util.LinkedList;
public class test
{ 
	public static void main(String[] args) { 
		LinkedList<String> link = new LinkedList<String>(); 
		//添加元素 
		link.addFirst("abc1"); 
		link.addFirst("abc2"); 
		link.addFirst("abc3"); 
		System.out.println(link); 
		// 获取元素 
		System.out.println(link.getFirst()); 
		System.out.println(link.getLast()); 
		// 删除元素 
		System.out.println(link.removeFirst()); 
		System.out.println(link.removeLast()); 
		while (!link.isEmpty()) 
		{ 
			//判断集合是否为空 
			System.out.println(link.pop()); 
			//弹出集合中的栈顶元素 }
			System.out.println(link); 
		}
	}
}

[abc3, abc2, abc1]
abc3
abc1
abc3
abc1
abc2
[]

5.Vector集合

5.1Vector（向量类）的介绍

Vector 类可以实现可增长的对象数组。
java.util.vector提供了向量类(Vector) 以实现类似动态数组的功能。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。Vector 是同步的，可用于多线程。
对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况，可以考虑使用向量类

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  • Vector 继承了AbstractList，实现了List接口；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
  • Vector实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
  • Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
  • Vector 实现Serializable接口，支持序列化。

5.2Vector的使用

向量类提供了三种构造方法：

public vector() 
public vector(int initialcapacity,int capacityIncrement) 
public vector(int initialcapacity)

使用第一种方法系统会自动对向量进行管理，若使用后两种方法，则系统将根据参数，initialcapacity设定向量对象的容量（即向量对象可存储数据的大小），当真正存放的数据个数超过容量时。系统会扩充向量对象存储容量。
参数capacityincrement给定了每次扩充的扩充值。当capacityincrement为0的时候，则每次扩充一倍，利用这个功能可以优化存储。

Vector类中提供了各种方法：
插入功能：

  • public final synchronized void addElement(Object obj) ：将obj插入向量的尾部。obj可以是任何类型的对象。对同一个向量对象，亦可以在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数组转换成相应的对象。

例如：要插入整数1时，不要直接调用v1.addElement(1),正确的方法为：

Vector v1 = new Vector(); 
Integer integer1 = new Integer(1); 
v1.addElement(integer1);
  • public final synchronized void setElementAt(Object obj,int index) ：将index处的对象设置成obj，原来的对象将被覆盖。
  • public final synchronized void insertElementAt(Object obj,int index) ：在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。

查询搜索功能：

  • public final int indexOf(Object obj) ：从向量头开始搜索obj,返回所遇到的第一个obj对应的下标，若不存在此obj,返回-1.
  • public final synchronized int indexOf(Object obj,int index) ：从index所表示的下标处开始搜索obj.
  • public final int lastindexOf(Object obj) ：从向量尾部开始逆向搜索obj.
  • public final synchornized int lastIndex(Object obj,int index) ：从index所表示的下标处由尾至头逆向搜索obj.
  • public final synchornized firstElement() ：获取向量对象中的首个obj
  • public final synchornized Object lastElement() ：获取向量对象的最后一个obj

其他功能:

  • public final int size()： 此方法用于获取向量元素的个数。它们返回值是向量中实际存在的元素个数，而非向量容量。可以调用方法capacity()来获取容量值。
  • public final synchronized void setSize(int newsize)： 此方法用来定义向量的大小，若向量对象现有成员个数已经超过了newsize的值，则超过部分的多余元素会丢失。

程序中定义Enumeration类的一个对象Enumeration是java.util中的一个接口类

  • public final synchronized Enumeration elements()： 此方法将向量对象对应到一个枚举类型。java.util包中的其他类中也都有这类方法，以便于用户获取对应的枚举类型。

在Enumeration中封装了有关枚举数据集合的方法。

  • 方法 hasMoreElement() 来判断集合中是否还有其他元素。
  • 方法 nextElement() 来获取下一个元素

以下代码就是用hasMoreElement（）和 nextElement（）遍历Vector查询搜索功能：

import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class TestVector {
    public void test01() {
        Vector<String> hs = new Vector<String>();
        hs.add("aa");
        hs.add("bb");
        hs.add("aa");
        hs.add("cc");
        hs.add("aa");
        hs.add("dd");
        printSet2(hs);
    }
    public void printSet(List hs) {
        Iterator iterator = hs.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
    public void printSet2(Vector<String> hs) {
        Enumeration<String> elements = hs.elements();
        while (elements.hasMoreElements()) {
            System.out.println(elements.nextElement());
        }
    }
    public static void main(String[] args) {
        new TestVector().test01();
    }
}

aa
bb
aa
cc
aa
dd

6.Stack

6.1Stack介绍

Stack 类表示后进先出（LIFO）的对象堆栈。继承自Vector，它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。
因为它继承自Vector,那么它的实现原理是以数组实现堆栈的。
如果要以链表方式实现堆栈可以使用LinkedList！
在这里插入图片描述

java.lang.Object
  继承者 java.util.AbstractCollection<E>
      继承者 java.util.AbstractList<E>
          继承者 java.util.Vector<E>
              继承者 java.util.Stack<E>
所有已实现的接口：
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

并且从类 java.util.Vector 继承的字段

capacityIncrement, elementCount, elementData

从类 java.util.AbstractList 继承的字段

modCount

6.2Stack的方法和使用

Stack只有下面四个方法！由于Stack继承了Vector ，它也有Vector的API方法

  • push( num) ：入栈
  • pop() ：栈顶元素出栈
  • empty() ：判定栈是否为空
  • peek() ：获取栈顶元素
  • search(num) ：判端元素num是否在栈中，如果在返回1，不在返回-1

（注意pop()和peek()的区别。pop()会弹出栈顶元素并返回栈顶的值，peek()只是获取栈顶的值，但是并不会把元素从栈顶弹出来）

import java.util.Stack;
public class test
{ 
	public static void main(String[] args) { 
		Stack<Integer> stack = new Stack<>();
		stack.push(2);
		System.out.println(stack.search(2));  //2在栈中，返回1
		System.out.println(stack.search(0));  //0不在栈中，返回-1
		
		System.out.println(stack.empty());   //栈不为空，返回false
		System.out.println(stack.peek());   //读取栈顶元素，返回2
		System.out.println(stack.empty());   //栈不为空，返回false
		
		System.out.println(stack.pop());   //弹出栈顶元素，并返回栈顶元素2
		System.out.println(stack.empty());   //栈空，返回true		
		}
}


1
-1
false
2
false
2
true

7.List集合总结

7.1总结概述

1、List继承了Collection，是有序的列表。
2、实现类有ArrayList、LinkedList、Vector、Stack等

  • ArrayList是基于数组实现的，是一个数组队列。可以动态的增加容量！
  • LinkedList是基于链表实现的，是一个双向循环列表。可以被当做堆栈使用！
  • Vector是基于数组实现的，是一个矢量队列，是线程安全的！
  • Stack是基于数组实现的，是栈，它继承与Vector，特性是FILO（先进后出）！

7.2使用场景

在实际的应用中如果使用到队列，栈，链表，首先可以想到使用List。不同的场景下面使用不同的工具，效率才能更高！

  1. 当集合中对插入元素数据的速度要求不高，但是要求快速访问元素数据，则使用ArrayList！
  2. 当集合中对访问元素数据速度不做要求不高，但是对插入和删除元素数据速度要求高的情况，则使用LinkedList！
  3. 当集合中有多线程对集合元素进行操作时候，则使用Vector！但是现在BVector现在一般不再使用，如需在多线程下使用，可以用CopyOnWriteArrayList，在java.util.concurrent包下。
  4. 当集合中有需求是希望后保存的数据先读取出来，则使用Stack！

7.3性能测试

/*
 * 性能测试，通过插入、随机读取和删除对ArrayList、LinkedList、Vector和Stack进行测试！
 * 结论：看LinkedList
 *  插入10万个元素，LinkedList所花时间最短：17 ms。
 *  删除10万个元素，LinkedList所花时间最短： 9 ms。
 *  遍历10万个元素，LinkedList所花时间最长：10255 ms；而ArrayList、Stack和Vector则相差不多，都只用了几秒。
 *  (1) 对于需要快速插入，删除元素，应该使用LinkedList。
 *  (2) 对于需要快速随机访问元素，应该使用ArrayList。
 * 
 */
public class ListTest {

    private static final int COUNT = 100000; //十万

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

    public static void main(String[] args) {
        System.out.println("....开始测试插入元素..........");

        // 插入元素测试
        insertData(arrayList,"ArrayList") ;
        insertData(linkedList,"LinkedList") ;
        insertData(vector,"Vector") ;
        insertData(stack,"Stack") ;

        System.out.println("....开始测试读取元素..........");

        // 随机读取元素测试
        readAccessData(arrayList,"ArrayList") ;
        readAccessData(linkedList,"LinkedList") ;
        readAccessData(vector,"Vector") ;
        readAccessData(stack,"Stack") ;

        System.out.println("....开始测试删除元素..........");

        // 随机读取元素测试
        deleteData(arrayList,"ArrayList") ;
        deleteData(linkedList,"LinkedList") ;
        deleteData(vector,"Vector") ;
        deleteData(stack,"Stack") ;



    }


    /**
     * 指定的List 的子类中插入元素，并统计插入的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void insertData(List<Object> list,String name) {
        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(name + " : 插入 "+COUNT+"元素， 使用的时间是 " + interval+" ms");
    }

    /**
     * 指定的List 的子类中删除元素，并统计删除的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void deleteData(List<Object> list,String name) {
        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(name + " : 删除 "+COUNT+"元素， 使用的时间是 " + interval+" ms");
    }

    /**
     * 指定的List 的子类中读取元素，并统计读取的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void readAccessData(List<Object> list,String name) {
        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(name + " : 随机读取 "+COUNT+"元素， 使用的时间是 " + interval+" ms");
    }
}

....开始测试插入元素..........
ArrayList : 插入 100000元素， 使用的时间是 970 ms
LinkedList : 插入 100000元素， 使用的时间是 17 ms
Vector : 插入 100000元素， 使用的时间是 968 ms
Stack : 插入 100000元素， 使用的时间是 888 ms
....开始测试读取元素..........
ArrayList : 随机读取 100000元素， 使用的时间是 6 ms
LinkedList : 随机读取 100000元素， 使用的时间是 10255 ms
Vector : 随机读取 100000元素， 使用的时间是 8 ms
Stack : 随机读取 100000元素， 使用的时间是 4 ms
....开始测试删除元素..........
ArrayList : 删除 100000元素， 使用的时间是 1460 ms
LinkedList : 删除 100000元素， 使用的时间是 9 ms
Vector : 删除 100000元素， 使用的时间是 1472 ms
Stack : 删除 100000元素， 使用的时间是 894 ms

欢迎阅读Java集合的相关博客：
Java学习-Collection集合和Iterator迭代器
Java学习-详谈泛型
Java学习-详谈Map集合（HashMap、LinkedHashMap、TreeMap）
Java学习-Collections工具类和Java常见的几种比较器
Java学习-详谈Set集合（HashSet、TreeSet、LinkedHashSet）

欢迎持续关注！
我的CSDN主页
个人博客站：jQueryZK Blog

jQueryZK
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python之数据流（stream）
chenchen5152的博客
01-14 1万+
本文参考Python官方文档针对官方文档示例进行解析，解析不完整只为了便于理解；流是用于处理网络连接的高级async/await-ready原语。流允许发送和接收数据，而不需要使用回调或低级协议和传输。
Java语言：Java集合之List集合（主要讲ArrayList）
日出印象
09-06 246
目录 集合概述 集合框架结构 List集合 List概述 ArrayList 例题体会 集合概述 集合顾名思义就是聚集某一类的事物。 在Java中，集合是工具类，可以存储任意数量具有共同属性的对象。 这里你就要有疑问了，既然是这样，那数组不早就已经实现了这个功能了吗？ 既然要使用集合的概念，必然有原因。 数组的长度是固定的，如果一类对象的数量是变化的呢？数组就不能胜任这个工作了，只能用到集合 应用场景如下图所示 集合框架结构 集合框架主要分为两个大的接口（我也不太
python实现stream流式传输，边生成，边返回给客户端
m0_71295326的博客
06-21 2690
这里要再开一个线程，才不会阻塞主进程传输数据。# chunk_size每次返回块的大小。
1.2 一维数组的定义、赋值和初始化
you can you up up up的博客
09-21 6361
当数组中每个元素都只带有一个下标时，这种数组就是“一维数组”。一维数组（one-dimensional array）实质上是一组相同类型数据的线性集合，是数组中最简单的一种数组。 数组是引用数据类型，引用数据类型在使用之前一定要做两件事情：声明和初始化。所以本文将重点介绍一维数组的创建、初始化和使用。 创建一维数组 为了在程序中使用一个数组，必须声明一个引用该数组的变量，并指明整个变量可以引用的数组类型。声明一维数组的语法格式为： type[] arrayName; // 数据类型[] 数组名; 或
python3 流式计算
u013595395的博客
09-24 1494
class Stream: def __init__(self, list=[]): if list: self.list = list def filter(self, lam): self.list = list(filter(lam, self.list)) return self def map(self,lam): self.list = list(map(lam, self.li.
流式计算来袭，使用Python和PySpark处理流式数据
weixin_39915649的博客
06-09 644
学习如何用Python和Pyspark创建本地、低延迟的流式数据。
学习笔记 | Java的List（ArrayList、LinkedList）、Set、Map集合
大虎牙的博客
06-01 169
Java集合 01 List：动态数组(元素个数未知) package example; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ListDemo { public static void main(String[] args) { List<String> list = new ArrayList<>(); // 判断
java8源码-csn-list:ArrayList、LinkedList、Vector、Stack源码分析
06-04
java8 源码 List相关实现类的源码解析（JDK1.8） 2018.9.22- List的架构图 ArrayList 继承关系： ArrayList -> AbstractList 实现 List接口 ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的...
java基础--list（ArrayList、LinkedList、匿名类）.docx
08-07
【Java基础——List接口详解（ArrayList、LinkedList、匿名类）】 在Java编程中，List接口是集合框架的重要组成部分，提供了有序存储元素的功能。ArrayList和LinkedList是List接口的两种主要实现，它们各有优缺点，...
python-stream:更优雅的流式数据处理方式
05-18
python-stream 说明 数据流式框架, 可用作数据清洗, 数据预处理, 数据迁移等应用场景 更优雅的流式数据处理方式 安装 pip install git+https://github.com/sandabuliu/python-stream.git or git clone https://github.com/sandabuliu/python-stream.git cd python-agent python setup.py install QuickStart Examples Word Count from pystream.executor.source import Memory from pystream.executor.executor import Map, Iterator, ReducebyKey data = Memory([ 'W
Python-streamlinkCLI一个命令行工具从各种网站中提取流至你选择的视频播放器中
08-10
streamlink-CLI 一个命令行工具从各种网站中提取流至你选择的视频播放器中
java集合 collection-list-LinkedList详解
08-31
Java集合框架是Java编程语言中的一个重要组成部分，它提供了一种高效、灵活的方式来存储和操作数据。在Java集合框架中，`List`接口是`Collection`接口的一个子接口，它代表了有序的元素列表，其中元素可以重复，并且...
java 集合之实现类ArrayList和LinkedList的方法
08-29
Java 集合框架中，ArrayList 和 LinkedList 是两种常用的实现类，分别实现了 List 接口。下面我们将详细介绍这两种实现类的方法。 ArrayList ArrayList 是一个基于数组实现的 List 接口实现类，它的底层是使用数组...
python 流式计算框架_Flink流式计算系统
weixin_39933356的博客
12-11 882
本文将以这些概念为基础，逐一介绍 Flink 的发展背景、核心概念、时间推理与正确性工具、安装部署、客户端操作、编程API等内容，让开发人员对 Flink 有较为全面的认识并拥有一些基础操作与编程能力。一、发展背景1.1 数据处理架构在流处理器出现之前，数据处理架构主要由批处理器组成，其是对无限数据的有限切分，具有吞吐量大、数据较为准确的特点。然而我们知道，批处理器在时间切分点附近仍然...
像Labview一样，使用C#构建测量数据流式处理框架
weixin_34128534的博客
08-21 1141
1. C# DataFlow介绍 介绍部分参考博客：TPL DataFlow初探（一）侵权请联系删除 官方解释： TPL（任务并行库） 数据流库向具有高吞吐量和低滞后时间的占用大量 CPU 和 I/O 操作的应用程序的并行化和消息传递提供了基础。 它还能显式控制缓存数据的方式以及在系统中移动的方式。传统编程模型通常需要使用回调和同步对象（...
DBMS 的个人理解
weixin_30691871的博客
08-06 280
再看自己数据库时，感觉还是有点迷茫：数据库到底是怎们工作的呢？虽然之前把代码都弄了一遍，可是效果还是不太理想。 数据库到底是怎么连到用户的程序上的呢？它的内部到底是怎么运行的呢？我研究了一段时间，获得了一点小小的收获，现在跟大家分享，并请大家给予指点。（最主要的是指点） 用户是怎么调用数据库的呢？ ...
python 流式计算框架_流式计算的三种框架：Storm、Spark和Flink
weixin_39545017的博客
12-05 840
我们知道，大数据的计算模式主要分为批量计算(batch computing)、流式计算(stream computing)、交互计算(interactive computing)、图计算(graph computing)等。其中，流式计算和批量计算是两种主要的大数据计算模式，分别适用于不同的大数据应用场景。目前主流的流式计算框架有Storm、Spark Streaming、Flink三种，其基本原...
python8_Python8--函数
weixin_34493203的博客
02-20 490
1.什么是函数我们在写程序的时候会多次使用重复的代码，函数就可以简化这种重复。我们在函数里写重复的内容， 然后等需要使用的时候直接调用就可以Python函数定义的通常格式为：def 函数名(参数列表):#函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明函数体#return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None2. 定义函数先进入...
java ArrayList LinkedList vector区别
最新发布
07-23
Java中的ArrayList、LinkedList和Vector是三种常见的集合类，它们都实现了List接口，但在实现和使用上有一些区别。 1. 实现方式： - ArrayList是基于数组实现的动态数组，可以动态调整数组的大小。 - LinkedList是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值