Java集合之List集合

已于 2023-06-16 15:53:39 修改
阅读量9.3k 收藏 171
点赞数 35
分类专栏： Java 文章标签： java list 数据结构
于 2023-06-14 11:43:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TestXzing/article/details/131197073
版权

List详解

一、 List概述

1.1概念

List是一种常用的集合类型，它可以存储任意类型的对象，也可以结合泛型来存储具体的类型对象，本质上就是一个容器。

1.2体系

List中主要有ArrayList、LinkedList两个实现类
在这里插入图片描述

1.3 通用方法

ArrayList和LinkedList通用方法

方法名说明
public boolean add(要添加的元素)将指定的元素追加到此集合的末尾
public boolean remove(要删除的元素)删除指定元素,返回值表示是否删除成功
public E remove(int index)删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)修改指定索引处的元素，返回被修改的元素
public E get(int index)返回指定索引处的元素
public int size()返回集合中的元素的个数
boolean contains(Object o)如果此列表包含指定的元素，则返回 true
boolean addAll(int index, Collection<? extends E> c)将指定集合中的所有元素插入到此列表中，从指定的位置开始
void clear()列表中删除所有元素

这里以ArrayList举例
代码测试：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 创建集合
		List list = new ArrayList<>();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// public boolean remove(Object o)：删除指定的元素，返回删除是否成功
		 System.out.println(list.remove("world"));//true
		 System.out.println(list.remove("javaee"));//false

		// public E remove(int index)：删除指定索引处的元素，返回被删除的元素
		 System.out.println(list.remove(1));//world

		// IndexOutOfBoundsException
		 System.out.println(list.remove(3));

		// public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
		 System.out.println(list.set(1,"javaee"));//world

		// IndexOutOfBoundsException
		 System.out.println(list.set(3,"javaee"));

		// public E get(int index)：返回指定索引处的元素
		 System.out.println(list.get(0));//hello
		 System.out.println(list.get(1));//world
		 System.out.println(list.get(2));//java
		// IndexOutOfBoundsException
		 System.out.println(list.get(3));

		// public int size()：返回集合中的元素的个数
		 System.out.println(list.size());//3
		
		// 输出集合
		 System.out.println("list:" + list);//list:[hello, world, java]

		// boolean contains(Object o) 如果此列表包含指定的元素，则返回 true
		 System.out.println(list.contains("world"));//true
		 
		// boolean addAll(int index, Collection c) 
		//将指定集合中的所有元素插入到此列表中，从指定的位置开始
		List list2 = new ArrayList<>();
		//addall前list2
		System.out.println(list2);// []
		System.out.println(list2.addAll(0, list));// true
		//addall后list2
		System.out.println(list2);// [hello, world, java]
	}

二、List的特点

（1）有序性：List中的元素是按照添加顺序进行存放的。因为有序，所以有下标，下标从0开始

（2）可重复性： List中可以存储重复的元素

三、遍历方式

3.1 foreach

       List list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        for (Object object : list) {
			System.out.println(object);
		}

3.2 for循环

根据下标遍历

       //创建集合
       List list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
       for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}

3.3迭代器

        //创建集合
       List list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
        	System.out.println(iterator.next());
		}

四、ArrayList

4.1ArrayList概述

4.1.1概念

ArrayList是Java中的一个类，实现了List接口，底层使用数组来存储元素。与数组相比，它具有更灵活的大小和动态的增加和删除元素。

4.1.2数据结构

ArrayList的数据结构本质上就是数组。区别在于，数组是一种静态的数据结构，需要在创建数组时就指定它的长度，并且创建后长度无法改变。而ArrayList是一种动态的数据结构，它可以自动进行扩容。

ArrayList的底层数据结构：
在这里插入图片描述

4.2ArrayList的特点

除了具备List有序性、可重复性特点外，ArrayList还具备以下的特点：

4.2.1自动扩容

当向ArrayList中加入的元素超过了其默认的长度时（由于ArrayList是数组的封装类，在创建ArrayList时不用给定长度，其默认长度为10），它会自动扩容以增加存储容量

4.2.2随机访问

随机访问是指可以直接访问元素，而不需要从头部或者尾部遍历整个列表。由于ArrayList底层是用数组实现的，因此可以通过索引来快速访问元素。

4.2.3 慢速插入/删除：

相比于链表（如LinkedList），ArrayList在中间插入或删除元素较慢，因为需要移动元素。

4.2.4高效的遍历

由于ArrayList底层采用了数组来存储元素，所以对于ArrayList的遍历操作比较高效。

4.3常用方法

方法名说明
trimToSize()将内部存储的数组大小调整为列表中元素的实际数量。
ensureCapacity(int minCapacity)设置内部存储的数组大小，以容纳指定数量的元素。
toArray(T[] a)将列表中的元素转换为指定类型的数组

代码测试：

package com.xqx.list;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class demo4 {
public static void main(String[] args) throws Exception {
	//创建一个容量为100的集合
	ArrayList list = new ArrayList(100);
	//新增数据前容量
	elementDataLength(list); //当前List集合容量为：100
	for (int i = 0; i < 101; i++) {
		list.add(i);//增加101个元素
	}
	//新增数据后容量大小
	elementDataLength(list); //当前List集合容量为：150
	list.trimToSize();
	//调用trimToSize()方法后容量大小，能够避免资源浪费
	elementDataLength(list); //当前List集合容量为：101
	
	//创建一个容量为4的集合
	ArrayList list2 = new ArrayList(4);
	elementDataLength(list2);//当前List集合容量为：4
	list2.add(1);
	list2.add(2);
	list2.add(3);
	list2.add(4);
	list2.add(5);
	//超过4个元素自动扩容 4*1.5=6
	elementDataLength(list2);//当前List集合容量为：6
	
	//手动扩容，减少扩容次数，影响性能
	list2.ensureCapacity(100);
	
	elementDataLength(list2);//当前List集合容量为：100
	Integer[] arr = new Integer[list2.size()];//注意，传入的数组长度应该至少等于ArrayList的元素个数，否则将会抛出空指针异常。
	for (Integer integer : arr) {
		System.out.println(integer);//null null null null null
	}
	list2.toArray(arr);
	
	for (Integer integer : arr) {
		System.out.println(integer);// 1 2 3 4 5
	}

}

/**
 * 定义一个名为 "elementDataLength" 的方法，该方法用于使用反射获取 ArrayList 中存储元素的底层数组的长度并输出
 * 
 */
public static void elementDataLength(List list) throws Exception {
	// 使用反射获取 ArrayList 对象的成员变量 elementData
	Field ed = list.getClass().getDeclaredField("elementData");
	ed.setAccessible(true); // 设置允许访问私有变量
	Object[] o = (Object[]) ed.get(list); // 获取 ArrayList 中存储元素的底层数组对象的引用
	// 输出 ArrayList 的容量信息，即底层数组的长度
	System.out.println("当前List集合容量为：" + o.length);
}
}

4.4 增长因子论证

我们说ArrayList的底层数据结构是数组，而数组的长度是固定的，但ArrayList长度却是可变的。这里就能产生两个问题：

1、数组和ArrayList的性质都不一样，你怎么能说ArrayList的底层数据结构是数组？

2、即使你已经证明了ArrayList的底层数据结构是数组，那为什么数组的长度是固定的，但ArrayList长度却是可变的？

4.4.1证明ArrayList的底层数据结构是数组

证明第一个问题其实很简单，我们查看源代码即可：

（1）：
在这里插入图片描述

（2）：

在这里插入图片描述

（3）：

在这里插入图片描述
我们一步步往上查看，可以看到有一个名为 elementData 的字段： transient Object[] elementData;

这个字段是用于存储 ArrayList 中所有元素的数组。

通过这些代码实现，我们可以看到 ArrayList 的内部实现确实是基于数组实现的。

4.4.2证明ArrayList的容量可变

证明第二个问题，跟我们ArrayList的一个特点密切相关，没错，聪明的你已经猜出来了,就是自动扩容：

在ArrayList中，每当添加一个元素时，都需要先检查当前数组容量是否足够，如果容量不足，则需要进行扩容操作。而ArrayList的扩容机制是：将原数组的长度乘以一个增长因子，通常是1.5，生成一个新的大数组，然后将原数组中的元素复制到新数组中来，这样就完成了扩容操作。

代码证明：

	public static void main(String[] args) throws Exception {

		List list = new ArrayList();
		for (int i = 0; i < 100; i++) {
			System.out.print(i + "==");
			list.add(i);
			elementDataLength(list); // 调用 elementDataLength 方法输出当前容量
		}
	}

	/**
	 * 定义一个名为 "elementDataLength" 的方法，该方法用于使用反射获取 ArrayList 中存储元素的底层数组的长度并输出
	 * 
	 */
	public static void elementDataLength(List list) throws Exception {
		// 使用反射获取 ArrayList 对象的成员变量 elementData
		Field ed = list.getClass().getDeclaredField("elementData");
		ed.setAccessible(true); // 设置允许访问私有变量
		Object[] o = (Object[]) ed.get(list); // 获取 ArrayList 中存储元素的底层数组对象的引用
		// 输出 ArrayList 的容量信息，即底层数组的长度
		System.out.println("当前List集合容量为：" + o.length);
	}
//输出的内容：
0==当前List集合容量为：10
1==当前List集合容量为：10
2==当前List集合容量为：10
3==当前List集合容量为：10
4==当前List集合容量为：10
5==当前List集合容量为：10
6==当前List集合容量为：10
7==当前List集合容量为：10
8==当前List集合容量为：10
9==当前List集合容量为：10
10==当前List集合容量为：15
11==当前List集合容量为：15
12==当前List集合容量为：15
13==当前List集合容量为：15
14==当前List集合容量为：15
15==当前List集合容量为：22
16==当前List集合容量为：22
17==当前List集合容量为：22
18==当前List集合容量为：22
19==当前List集合容量为：22
20==当前List集合容量为：22
21==当前List集合容量为：22
22==当前List集合容量为：33
23==当前List集合容量为：33
24==当前List集合容量为：33
25==当前List集合容量为：33
26==当前List集合容量为：33
27==当前List集合容量为：33
28==当前List集合容量为：33
29==当前List集合容量为：33
30==当前List集合容量为：33
31==当前List集合容量为：33
32==当前List集合容量为：33
33==当前List集合容量为：49
34==当前List集合容量为：49
35==当前List集合容量为：49
36==当前List集合容量为：49
37==当前List集合容量为：49
38==当前List集合容量为：49
39==当前List集合容量为：49
40==当前List集合容量为：49
41==当前List集合容量为：49
42==当前List集合容量为：49
43==当前List集合容量为：49
44==当前List集合容量为：49
45==当前List集合容量为：49
46==当前List集合容量为：49
47==当前List集合容量为：49
48==当前List集合容量为：49
49==当前List集合容量为：73
50==当前List集合容量为：73
51==当前List集合容量为：73
52==当前List集合容量为：73
53==当前List集合容量为：73
54==当前List集合容量为：73
55==当前List集合容量为：73
56==当前List集合容量为：73
57==当前List集合容量为：73
58==当前List集合容量为：73
59==当前List集合容量为：73
60==当前List集合容量为：73
61==当前List集合容量为：73
62==当前List集合容量为：73
63==当前List集合容量为：73
64==当前List集合容量为：73
65==当前List集合容量为：73
66==当前List集合容量为：73
67==当前List集合容量为：73
68==当前List集合容量为：73
69==当前List集合容量为：73
70==当前List集合容量为：73
71==当前List集合容量为：73
72==当前List集合容量为：73
73==当前List集合容量为：109
74==当前List集合容量为：109
75==当前List集合容量为：109
76==当前List集合容量为：109
77==当前List集合容量为：109
78==当前List集合容量为：109
79==当前List集合容量为：109
80==当前List集合容量为：109
81==当前List集合容量为：109
82==当前List集合容量为：109
83==当前List集合容量为：109
84==当前List集合容量为：109
85==当前List集合容量为：109
86==当前List集合容量为：109
87==当前List集合容量为：109
88==当前List集合容量为：109
89==当前List集合容量为：109
90==当前List集合容量为：109
91==当前List集合容量为：109
92==当前List集合容量为：109
93==当前List集合容量为：109
94==当前List集合容量为：109
95==当前List集合容量为：109
96==当前List集合容量为：109
97==当前List集合容量为：109
98==当前List集合容量为：109
99==当前List集合容量为：109

我们可以看到内部容量不足时，ArrayList会将原数组长度乘以1.5进行扩容。

注意，由于 ArrayList 底层使用的是数组，因此一旦创建了 ArrayList，它的大小就是固定的。而当元素添加到 ArrayList 中时，如果底层数组已满，则需要创建一个更大的数组，并将原有元素复制到新数组中，这会带来一定的性能损耗。

因此，在实际开发中，建议在创建 ArrayList 时设置一个合适的初始化容量，避免在运行时频繁进行扩容操作，同时也可避免浪费过多空间资源。

拿以上例子稍作修改，将ArrayList容量改为50：

	public static void main(String[] args) throws Exception {

		List list = new ArrayList(50);
		for (int i = 0; i < 100; i++) {
			System.out.print(i + "==");
			list.add(i);
			elementDataLength(list); // 调用 elementDataLength 方法输出当前容量
		}
	}

	/**
	 * 定义一个名为 "elementDataLength" 的方法，该方法用于使用反射获取 ArrayList 中存储元素的底层数组的长度并输出
	 * 
	 */
	public static void elementDataLength(List list) throws Exception {
		// 使用反射获取 ArrayList 对象的成员变量 elementData
		Field ed = list.getClass().getDeclaredField("elementData");
		ed.setAccessible(true); // 设置允许访问私有变量
		Object[] o = (Object[]) ed.get(list); // 获取 ArrayList 中存储元素的底层数组对象的引用
		// 输出 ArrayList 的容量信息，即底层数组的长度
		System.out.println("当前List集合容量为：" + o.length);
	}
//输出的内容：
0==当前List集合容量为：50
1==当前List集合容量为：50
2==当前List集合容量为：50
3==当前List集合容量为：50
4==当前List集合容量为：50
5==当前List集合容量为：50
6==当前List集合容量为：50
7==当前List集合容量为：50
8==当前List集合容量为：50
9==当前List集合容量为：50
10==当前List集合容量为：50
11==当前List集合容量为：50
12==当前List集合容量为：50
13==当前List集合容量为：50
14==当前List集合容量为：50
15==当前List集合容量为：50
16==当前List集合容量为：50
17==当前List集合容量为：50
18==当前List集合容量为：50
19==当前List集合容量为：50
20==当前List集合容量为：50
21==当前List集合容量为：50
22==当前List集合容量为：50
23==当前List集合容量为：50
24==当前List集合容量为：50
25==当前List集合容量为：50
26==当前List集合容量为：50
27==当前List集合容量为：50
28==当前List集合容量为：50
29==当前List集合容量为：50
30==当前List集合容量为：50
31==当前List集合容量为：50
32==当前List集合容量为：50
33==当前List集合容量为：50
34==当前List集合容量为：50
35==当前List集合容量为：50
36==当前List集合容量为：50
37==当前List集合容量为：50
38==当前List集合容量为：50
39==当前List集合容量为：50
40==当前List集合容量为：50
41==当前List集合容量为：50
42==当前List集合容量为：50
43==当前List集合容量为：50
44==当前List集合容量为：50
45==当前List集合容量为：50
46==当前List集合容量为：50
47==当前List集合容量为：50
48==当前List集合容量为：50
49==当前List集合容量为：50
50==当前List集合容量为：75
51==当前List集合容量为：75
52==当前List集合容量为：75
53==当前List集合容量为：75
54==当前List集合容量为：75
55==当前List集合容量为：75
56==当前List集合容量为：75
57==当前List集合容量为：75
58==当前List集合容量为：75
59==当前List集合容量为：75
60==当前List集合容量为：75
61==当前List集合容量为：75
62==当前List集合容量为：75
63==当前List集合容量为：75
64==当前List集合容量为：75
65==当前List集合容量为：75
66==当前List集合容量为：75
67==当前List集合容量为：75
68==当前List集合容量为：75
69==当前List集合容量为：75
70==当前List集合容量为：75
71==当前List集合容量为：75
72==当前List集合容量为：75
73==当前List集合容量为：75
74==当前List集合容量为：75
75==当前List集合容量为：112
76==当前List集合容量为：112
77==当前List集合容量为：112
78==当前List集合容量为：112
79==当前List集合容量为：112
80==当前List集合容量为：112
81==当前List集合容量为：112
82==当前List集合容量为：112
83==当前List集合容量为：112
84==当前List集合容量为：112
85==当前List集合容量为：112
86==当前List集合容量为：112
87==当前List集合容量为：112
88==当前List集合容量为：112
89==当前List集合容量为：112
90==当前List集合容量为：112
91==当前List集合容量为：112
92==当前List集合容量为：112
93==当前List集合容量为：112
94==当前List集合容量为：112
95==当前List集合容量为：112
96==当前List集合容量为：112
97==当前List集合容量为：112
98==当前List集合容量为：112
99==当前List集合容量为：112

我们可以看到这次只扩容了两次，从50-75、从75-112，这大大减少了性能损耗，所以在创建 ArrayList 时设置一个合适的初始化容量是非常重要的。

4.5 ArrayList去重

4.5.1字符串去重

使用contains方法

	   public static void main(String[] args) {
	        List list = new ArrayList();
	        list.add("a");
	        list.add("b");
	        list.add("c");
	        System.out.println("目前集合容器中的元素："+list);//目前集合容器中的元素：[a, b, c]
	        if (!list.contains("b")){//如果不包含“b”
	            list.add("b");//才增加
	        }
	        System.out.println("目前集合容器中的元素："+list);//目前集合容器中的元素：[a, b, c]
	    }
}

4.5.2对象去重

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Student("zs",16));
        list.add(new Student("ls",17));
        list.add(new Student("ww",18));
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69]
        if (!list.contains(new Student("ls",17))){//不包含才新增
            list.add(new Student("ls",17));
        }
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69, com.xqx.demo.Student@42a57993]

        if (list.contains(new Student("ls",17))){//包含才移除
            list.remove(new Student("ls",17));
        }
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69, com.xqx.demo.Student@42a57993]

    }
}
class Student{
    private String name;
    private int age;

    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;
    }
为什么 student(‘ls’,17) 并没有新增与移除？

由于在 Java 中，比较对象是否相等是基于对象的地址进行的，而不是基于对象的属性值进行的。而实例化后，会新开一个地址。所以即使两个student的属性值相等，但实例化后地址不同，那么这两个对象就也不是相等的。

解决方案

重写equals方法即可

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Student("zs",16));
        list.add(new Student("ls",17));
        list.add(new Student("ww",18));
        System.out.println("目前集合容器中的元素："+list);
  //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69]
        if (!list.contains(new Student("ls",17))){//不包含才新增
            list.add(new Student("ls",17));
        }
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69]

        if (list.contains(new Student("ls",17))){//包含才移除
            list.remove(new Student("ls",17));
        }
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@3d4eac69]

    }
}
class Student{
    private String name;
    private int age;

    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;
    }
        @Override
    public boolean equals(Object o) {
        System.out.println("调用了equals方法。。。");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && name.equals(student.name);
    }

在重写的equals方法中，我们定义了只有姓名和年龄都相同时，才认为两个学生相等。因此，当通过新建一个Student对象来判断是否存在于ArrayList中时，即使该对象的内存地址不同，只要该对象的姓名和年龄与列表中某个元素的姓名和年龄相等，就会被视为存在于ArrayList中，从而避免了重复添加元素。而在删除元素时，由于通过该对象的equals方法判断该对象是否在ArrayList中存在，因此也可以正常进行删除。

总结

Java中的引用类型在判断相等性时，是根据对象在内存中的地址进行比较的。如果不重写equals方法，那么，由于ArrayList中存储的是对象的引用，所以相当于比较的是每个对象在内存中的地址是否相同，只有两个对象的地址相同时才会被视为相等。而我们通常认为，只有两个对象的属性值相同时才能被视为相等。因此，我们需要根据对象的实际比较规则重写equals方法。

五、LinkedList

5.1 LinkedList概述

5.1.1概念

LinkedList也是Java中的一个常用的集合类，实现了List接口，底层使用的是双向链表数据结构。

与ArrayList不同，LinkedList在内部存储元素时，不是使用连续的内存空间，而是使用一个链表来存储元素。

5.1.2数据结构

LinkedList底层采用的是双向链表（doubly linked list） 数据结构。链表中的每个节点（结点）都由两个部分组成，一部分是存储数据元素的值域，另一部分是指向前一个节点和后一个节点的指针（引用）。对于双向链表来说，除了一个指向前一个节点的指针外，还有一个指向后一个节点的指针

在这里插入图片描述

5.2LinkedList的特点

5.2.1随机访问性能较差：

LinkedList的随机访问性能较差，因为在链表中要从头开始遍历链表，直到找到目标元素。所以如果在代码中需要频繁进行随机访问元素的操作，LinkedList可能不是一个最佳的选择。

5.2.2添加/删除操作快：

由于LinkedList底层使用双向链表，因此它的添加和删除操作非常快，因为只需要更改指针的指向即可，不需要像ArrayList一样重新分配数组空间，而且LinkedList还支持在指定位置插入和删除元素。

5.2.3需要额外空间：

链表中每个节点都需要额外存储到前一个和后一个节点的指针，因此比数组等其他数据结构需要更多的内存空间。

5.2.4适用于队列和双端队列：

LinkedList还可以支持队列和双端队列的功能，如在链表头部或尾部添加或删除元素，实现队列和双端队列的常见操作。

  • 双端队列（Deque，即Double Ended Queue的缩写）是一种允许在队列的两端进行插入和删除操作的数据结构。双端队列可以从队列的头部和尾部添加和移除元素。

5.3常用方法

方法名说明
addFirst(E element)将元素添加到列表的开头
getFirst()：返回列表的第一个元素。
getLast()：返回列表的最后一个元素。
removeFirst()：删除并返回列表的第一个元素。
removeLast()：删除并返回列表的最后一个元素。

5.4堆栈和队列

5.4.1堆栈

堆栈（Stack）是一种具有后进先出特性的数据结构。在堆栈结构中，新的元素总是被添加到栈顶（也就是最新元素），而只有在栈顶的元素才可以被移除。

堆栈最典型的例子是计算器的运算操作，先输入的操作数最后被计算，而最后输入的操作数最先被计算。对于堆栈结构，我们可以在程序中使用push（添加）和pop（移除）方法来实现后进先出的存储和读取数据。

在这里插入图片描述

5.4.2队列

队列（Queue）是一种具有先进先出特性的数据结构。在队列结构中，新的元素总是从队列的末尾添加到队列中，然后从队列的开头进行访问或删除。

队列最典型的例子是排队。排队的人总是按先来后到的顺序排队，当前面的人离开队列之后，后面的人才能够进入。对于队列结构，我们可以使用offer()方法将新的元素添加到队尾，使用poll()方法从队列开头移除元素。
在这里插入图片描述

5.5常见面试题：用LinkedList完成一个堆栈容器

package com.xqx.demo;

import java.util.LinkedList;

public class demo3 {
    public static void main(String[] args) {
    	//创建集合
        LinkedList ll = new LinkedList();
        //添加元素
        ll.add("lisi");
        ll.add("zs");
        ll.add("ww");
        //实例化堆栈
        DuiZhan DuiZhan = new DuiZhan(ll);
        System.out.println(DuiZhan.pop());
        System.out.println(DuiZhan.pop());
        System.out.println(DuiZhan.pop());
    }
 
}
class DuiZhan{
    LinkedList ll = null;
    public DuiZhan(LinkedList ll){// 堆栈的构造函数，接受一个 LinkedList 对象作为参数，用于存储堆栈元素
        this.ll = ll;
    }
    //压栈
    public void add(String a){
        ll.add(a);
    }

    //弹栈
    public String pop(){
        return (String) ll.removeLast(); 从链表末尾移除一个元素并返回其值
    }
}

在这里插入图片描述

考察核心：

  • 考察LinkedList的api方法
  • 考察堆栈/队列的数据结构特点

六、ArrayList和LinkedList的比较

  • 由于ArrayList的数据结构为数组，所以查询修改快，新增删除慢；而LinkedList的数据结构为链表结构，所以查询修改慢，新增删除快
  • ArrayList是基于数组实现的动态数组，在内存中有连续的空间，可以通过下标访问元素，由于数组需要提前分配一定大小的空间，因此当元素数量增多之后，可能会导致数组空间不足需要重新分配数组，这种情况下可能会出现内存空间浪费；相比之下，LinkedList是基于链表实现的，每个元素都有一个引用指向下一个元素，不需要提前分配空间，因此能够更加灵活地插入和删除元素。然而，链表在内存中是不连续的，每个元素的引用占用额外的内存空间。由于链表中每个元素都需要有一个指向下一个元素的引用，因此在存储同样数量的元素时，LinkedList通常会占用比ArrayList更大的内存空间。

好啦，今天的分享就到此为止！希望你看完本篇文章有所收获，祝你变得更强！！!

许潜行
关注
  • 35
    点赞
  • 踩
  • 171
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Java List集合
m0_62143653的博客
02-12 5423
Java List集合
java list集合合并_JAVA List合并集合
weixin_33236595的博客
02-19 3114
import java.util.ArrayList;import java.util.List;public class test {public static void main(String[] args) throws Exception {/*测试合并两个类型相同的list*/List list1 = new ArrayList();List list2 = new ArrayList(...
【Java基础】Java中List集合的常用方法
yubao0723的专栏
04-22 1万+
本文介绍了Java List集合的常用方法，包括创建和初始化List对象、添加、删除、修改和查询List中的元素以及遍历List集合
Java集合之List(超详细)
最新发布
epitomizelu的专栏
06-06 1424
for-each循环：简洁易读，最适合日常使用。Iterator：提供了更多的控制权，比如在遍历时移除元素，但在大多数情况下不如for-each方便。Stream API：功能强大，支持复杂的集合处理和并行处理，适合进行复杂的聚合操作和过滤操作。
java集合之List集合
zhaojie181711的博客
06-02 1万+
关于集合以前也总结过一点，一直忘记摘录一下集合的继承关系图。核心收集接口封装了不同类型的集合，如下图所示。这些接口允许集合被独立地操纵它们表示的细节。核心收集接口是Java集合框架的基础。正如您在下图中所看到的，核心收集接口形成了一个层次结构。如图所示：...
java集合超详解
热门推荐
feiyan的博客
08-03 45万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
Java集合之List超详细讲解
Kevin.wang
07-06 9520
文章目录一.List集合1主要方法2.ArrayList集合2.1代码演示3.ArrayList如何存入自定义的数据？4.LinkedList集合5.ArrayList与LinkedList 一.List集合 List集合为列表类型，以线性方式存储对象。List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。用户可以通过使用索引来访问List集合中的元素。 1主要方法 方法 说明 ...
Java集合中List,Set以及Map等集合体系详解(史上最全)
君羊
06-12 33万+
概述: List Set Map都是接口，前两个继承至Collection接口，Map为独立接口 Set下有HashSet，LinkedHashSet，TreeSet List下有ArrayList，Vector，LinkedList Map下有Hashtable，LinkedHashMap，HashMap，TreeMap 还有Collection接口下还有个Queue接口，有Priority...
Java 集合List取交集
张紫娃的博客
12-19 8842
【代码】Java 集合List取交集。
Java List集合反转元素
tanxinji的博客
05-04 2万+
 想要将ArrayList集合的元素 1 2 3 反转成 3 2 1。使用 Collections.reverse(list) 。包在import java.util.Collections  如: List<Integer> list = new ArrayList<>(); Collections.reverse(list);  示例1:将集合1 2 3 反转为 3 2 1 import java.util.ArrayList; import java.u
浅析Java集合及LIst接口
08-26
List集合中的每个元素都有对应的顺序索引，可以通过索引来访问指定位置的元素。List接口的实现类有ArrayList和LinkedList等。 ArrayList是基于数组实现的List类，它实现了所有可选列表操作，允许所有元素包括null。...
java集合 collection-list-LinkedList详解
08-31
在Java集合框架中，`List`接口是`Collection`接口的一个子接口，它代表了有序的元素列表，其中元素可以重复，并且可以通过索引来访问。`LinkedList`类是实现`List`接口的一个具体类，它提供了链表结构的数据存储方式...
Java-Java集合体系-List-Set
07-12
理解并熟练运用Java集合体系中的List、Set、Map接口及其实现类，对于日常开发和面试来说至关重要，因为它们是许多Java框架和库的基础。在实际项目中，根据需求选择合适的集合类型可以提高代码的效率和可维护性。在...
Java中对List集合的常用操作详解
09-02
在Java编程中，List集合是Java集合框架的重要组成部分，它是一种有序的集合，可以存储重复的元素。本文将深入解析Java中对List集合的常用操作，帮助开发者更好地理解和使用List接口。 1. **添加、获取和删除元素** ...
javalist.zip_list集合 java
09-23
"javalist.zip_list集合 java"这个标题暗示我们将探讨Java中的List集合以及它的应用。描述中提到“java中集合list的应用非常重要”，这确实不假，因为List在处理有序数据时具有广泛的应用场景。 List接口位于java....
Java List集合的应用.rar
06-24
Java List集合是Java编程语言中一个非常重要的数据结构，它属于集合框架的一部分，主要用于存储一组有序的、可重复的对象。...总的来说，理解和熟练运用List集合是成为一名合格Java程序员的关键步骤之一。
Java List集合排序实现方法解析
08-25
Java List 集合排序实现方法解析 Java List 集合排序实现方法解析是 Java 编程语言中一个非常重要的知识点。List 集合是 Java 中的一种常用的数据结构，它可以存储多个元素，并提供了许多操作元素的方法，例如添加...
在java中获取List集合中最大的日期时间操作
08-18
Java 中获取 List 集合中最大的日期时间操作 在 Java 中获取 List 集合中最大的日期时间操作是一个常见的需求，特别是在处理日期类型的数据时。下面将详细介绍如何获取 List 集合中最大的日期时间操作。 获取 List...
java集合数据结构
09-02
Java集合数据结构有多种类型，其中最常用的是ArrayList集合。ArrayList是基于数组结构实现的，它可以存储不同类型的元素，并且支持动态扩展。由于ArrayList在日常开发中使用最多的功能是查询数据和遍历数据，因此它是最常用的集合类型。 另外，还有其他类型的集合如Set集合。Set集合是基于哈希表实现的，它可以存储不重复的元素。与ArrayList不同，Set集合不保证元素的顺序。 以上提到的ArrayList和Set集合都是Java集合框架中的一部分，开发者可以根据自己的需求选择适合的数据结构来存储和操作数据。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [第三章 Java数据结构：集合](https://blog.csdn.net/gocode/article/details/115050462)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值