Java（14）集合，List

最新推荐文章于 2022-11-03 12:56:40 发布
最新推荐文章于 2022-11-03 12:56:40 发布
阅读量56 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69015218/article/details/124461291
版权
本文详细介绍了Java集合框架中的List接口，包括接口概述、数据结构比较、ArrayList的存储和读取、泛型在集合中的应用、实例化List的不同方式、可变与不可变集合的概念，以及如何使用for循环和迭代器遍历List。还提到了LinkedList的特点和使用。
摘要由CSDN通过智能技术生成

01 接口概括

java所有的集合类都位于java.util包下，提供了一个表示和操作对象集合的统一构架，包含大量集合接口，以及这些接口的实现类和操作它们的算法。

集合类和数组不一样，数组元素既可以是基本类型的值，也可以是对象（实际上保存的是对象的引用变量），而集合里只能保存对象（实际上只是保存对象的引用变量，但通常习惯上认为集合里保存的是对象）。

Java集合类型分为单列集合Collection和双列结合Map，Collection和Map是集合的根接口,这两个接口又包含了一些子接口和实现类

在这里插入图片描述

02 数据结构简介

01 数组Array

可以在内存中连续存储多个元素的结构，在内存中的分配也是连续，数组中的元素通过下标进行访问，数组下标从零开始

优点：

  1. 按照索引查询元素速度快
  2. 按照索引遍历数组方便

缺点：

  1. 数组的长度固定后无法扩容
  2. 数组只能存储单一数据类型

02 栈Stack

栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。

特点：先进后出或者说后进先出

03 队列Queue

队列与栈样也是一中线性表，不同是，队列可以在一端添加元素在另一端取出元素；

也就是先进先出。

队列从过一端放入元素称为入队，另一端取出元素称为出队

04 链表LinkedList

链表是物理存储非连续、非顺序存储结构，数据元素的逻辑顺序，是通过指针地址实现的。

每个元素有两个结点，一个存储元素的数据域（内存空间），另一个指向下一个结点地址的指针域。
在这里插入图片描述
从上图可以可出链表形成不同结构如单向链表和双向链表。
05 图Graph
06 散列表Hash
07 树Tree
08 堆Heap

List
特点：有序可重复

  • 有序指的是下标
  • 可重复指的是的可以存储相同元素，将相同元素存储在不同下标位置上实现

03 ArrayList存储读取数据

package;

public class Person {
}

public class ArrayListTest {
    @Test
    public void test() {
        List<String> list = new ArrayList<>(List.of("0", "1", "2", "3", "4"));
        System.out.println(list);
        // 末尾追加
        list.add("5");
        System.out.println(list);
        // 向指定index位置添加
        list.add(3, "33");
        System.out.println(list);
        // 将指定idnex位置上的元素从集合中删除
        list.remove(6);
        System.out.println(list);
        // 在集合中删除指定元素
        list.remove("33");
        System.out.println(list);
        list.add("哇");
        list.add("哇");
        System.out.println(list);
        list.remove("哇");
        System.out.println(list);
        // 更新指定index位置上元素的值
        list.set(3, "三");
        System.out.println(list);
        // 查询指定ndex位置上元素的值
        System.out.println(list.get(3));
    }
    /*
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 33, 3, 4, 5]
[0, 1, 2, 33, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 哇, 哇]
[0, 1, 2, 3, 4, 哇]
[0, 1, 2, 三, 4, 哇]
三
    */
}

04 集合中的泛型

public class linkedListTest {
   @Test
    public void test() {
        // List<String> list = new ArrayList<String>();
        // List<String> list = new ArrayList<>();
        // List<String> list = new ArrayList();
        List<String> list = new ArrayList<>();
        list.add("lll");
        list.add(String.valueOf(1));
    }

}

05 实例化List并赋值的两中方法

public class linkedListTest {
    @Test
    public void test() {
        List<Integer> list01 = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list01.add(i);
        }
        System.out.println(list01);
        list01.add(6);
        System.out.println(list01);
        
        List<Integer> list02 = new ArrayList<>() {{
            for (int i = 0; i < 5; i++) {
                add(i);
            }
        }};
        System.out.println(list02);
        list02.add(6);
        System.out.println(list02);
    }
    /*
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 6]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 6]
     */
}

06 List可变集合与不可变集合

public class linkedListTest {
    @Test
    public void test01() {
        // 不可变集合
        List<Integer> list = List.of(0, 1, 2, 3, 4);
        System.out.println(list);
        list.add(6);
        list.set(2, 20);
        // System.out.println(list);
    }
//[0, 1, 2, 3, 4]
    @Test
    public void test02() {
        // 不可变集合转为可变集合
        List<Integer> list = new ArrayList<>(List.of(0, 1, 2, 3, 4));
        System.out.println(list);
        list.add(6);
        System.out.println(list);
        list.set(2, 20);
        System.out.println(list);
    }
/*
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 6]
[0, 1, 20, 3, 4, 6]
 */

}

07 使用for循环和foreach遍历集合List

public class linkedListTest {
    @Test
    public void test() {
        List<Integer> list = new ArrayList<>(List.of(0, 1, 2, 3, 4));
        for (int i = 0; i < 5; i++) {
            System.out.println(list.get(i));
        }
        System.out.println("元素的数量 >>> " + list.size());
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("++++++++++++++++++++++++++++");
        // for(集合中元素的数据类型 集合中每一个元的是变量 : 被遍历的结合)
        for (int num : list) {
            System.out.println(num);
        }
    }
    /*
0
1
2
3
4
元素的数量 >>> 5
0
1
2
3
4
++++++++++++++++++++++++++++
0
1
2
3
4
     */

}

08 使用迭代器遍历集合List

public class linkedListTest {
    @Test
    public void test() {
        List<Integer> list = new ArrayList<>(List.of(0, 1, 2, 3, 4));
        Iterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            Integer next = it.next();
            System.out.println(next);
        }
        System.out.println("第一次遍历完成");
        while (it.hasNext()){
            Integer next = it.next();
            System.out.println(next);
        }
        System.out.println("第二次遍历完成");
    }
    /*
0
1
2
3
4
第一次遍历完成
第二次遍历完成
     */
}

09 LinkedList

package;

public class Person {
}

package Test;

import Person;
import org.junit.jupiter.api.Test;

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

/**
 * 数组：只能存储单一数据类型
 * 优点：线性存储 查询速度快
 * 缺点：数组一旦声明长度不可修改
 * List:有序可重复
 * 泛型：限定数据类型
 * <>钻石操作符
 */
public class linkedListTest {

    @Test
    public void test01() {
        List list = new LinkedList();
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4L;
        double e = 5.0d;
        float f = 6.0f;
        char g = 'a';
        boolean h = false;
        String i = "lll";
        Person person = new Person();
        list.add(a);
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(e);
        list.add(f);
        list.add(g);
        list.add(h);
        list.add(i);
        list.add(person);
        System.out.println(list.size());
    }
//10
    @Test
    public void test02() {
        List list = new LinkedList();
        list.add("xm");
        list.add("x");
        list.add("xm");
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
    }
/*
xm
x
xm
 */
    @Test
    public void test03() {
        // List<String> list = new LinkedList<String>();
        // List<String> list = new LinkedList<>();
        // List<String> list = new LinkedList();
        List<String> list = new LinkedList<>();
        list.add("lll");
        list.add(String.valueOf(1));
    }

    @Test
    public void test04() {
        List<Integer> list01 = new LinkedList<>();
        for (int i = 0; i < 5; i++) {
            list01.add(i);
        }
        System.out.println(list01);
        list01.add(6);
        System.out.println(list01);
        List<Integer> list02 = new LinkedList<>() {{
            for (int i = 0; i < 5; i++) {
                add(i);
            }
        }};
        System.out.println(list02);
        list02.add(6);
        System.out.println(list02);
    }
/*
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 6]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 6]
 */
    @Test
    public void test05() {
        // 不可变集合
        List<Integer> list = List.of(0, 1, 2, 3, 4);
        System.out.println(list);
        // list.add(6);
        // list.set(2, 20);
        // System.out.println(list);
    }
//[0, 1, 2, 3, 4]
    @Test
    public void test06() {
        // 不可变集合转为可变集合
        List<Integer> list = new LinkedList<>(List.of(0, 1, 2, 3, 4));
        System.out.println(list);
        list.add(6);
        System.out.println(list);
        list.set(2, 20);
        System.out.println(list);
    }
/*
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 6]
[0, 1, 20, 3, 4, 6]
 */
    @Test
    public void test07() {
        List<String> list = new LinkedList<>(List.of("0", "1", "2", "3", "4"));
        System.out.println(list);
        // 末尾追加
        list.add("5");
        System.out.println(list);
        // 向指定index位置添加
        list.add(3, "33");
        System.out.println(list);
        // 将指定idnex位置上的元素从集合中删除
        list.remove(6);
        System.out.println(list);
        // 在集合中删除指定元素
        list.remove("33");
        System.out.println(list);
        list.add("李");
        list.add("李");
        System.out.println(list);
        list.remove("李");
        System.out.println(list);
        // 更新指定index位置上元素的值
        list.set(3, "三");
        System.out.println(list);
        // 查询指定ndex位置上元素的值
        System.out.println(list.get(3));
    }
/*
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 33, 3, 4, 5]
[0, 1, 2, 33, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 李, 李]
[0, 1, 2, 3, 4, 李]
[0, 1, 2, 三, 4, 李]
三
 */
    @Test
    public void test08() {
        List<Integer> list = new LinkedList<>(List.of(0, 1, 2, 3, 4));
        for (int i = 0; i < 5; i++) {
            System.out.println(list.get(i));
        }
        System.out.println("元素的数量 >>> " + list.size());
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("++++++++++++++++++++++++++++");
        // for(集合中元素的数据类型 集合中每一个元的是变量 : 被遍历的结合)
        for (int num : list) {
            System.out.println(num);
        }
    }
/*
0
1
2
3
4
元素的数量 >>> 5
0
1
2
3
4
++++++++++++++++++++++++++++
0
1
2
3
4
 */
    @Test
    public void test09() {
        List<Integer> list = new LinkedList<>(List.of(0, 1, 2, 3, 4));
        Iterator<Integer> it = list.listIterator();
        while (it.hasNext()) {
            Integer next = it.next();
            System.out.println(next);
        }
        System.out.println("第一次遍历完成");
        while (it.hasNext()) {
            Integer next = it.next();
            System.out.println(next);
        }
        System.out.println("第二次遍历完成");
    }
/*
0
1
2
3
4
第一次遍历完成
第二次遍历完成
 */
    @Test
    public void test10() {
        List<Integer> list = new LinkedList<>(List.of(0, 1, 2, 3, 4));
        list.stream().forEach(System.out::println);
    }
    /*
0
1
2
3
4
     */
}
weixin_69015218
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-1.0.1.jar
10-15
java-1.0.1.jar 压缩 包里面有对应的jar 架包，解压出来就可以
【Java】1.0 Java环境搭建
最新发布
m0_69442905的博客
05-17 429
JDK 安装，编写第一个Java程序
1.0_Java 简介
燃吹 U 客帮
05-05 559
Java 简介 什么是 Java 官方网站 关于 Java 高级语言 Java 技术平台 JDK、JRE、Server JRE 区别 详细说一下三个版本SE/EE/ME 扩展 J2ME 知识
Java中day17 集合一
weixin_53233582的博客
04-27 96
集合 在编程时，可以使用数组来保存多个对象，但数组长度不可变化，一旦在初始化数组时指定了数组长度，这个数组长度就是不可变的。如果需要保存数量变化的数据，数组就有点无能为力了。而且数组无法保存具有映射关系的数据，例如: key value 课程 分数 java 95 python 90 为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），java提供集合类.集合类主要负责保存其他数据因此集合类也被称之为容器类。 java所有的集合类都位于java.util包
Java基础1.0
m0_46708637的博客
06-05 189
Java基础Java概述编程Java概述jdk1.5后的三大版本JVM、JRE和JDK的关系跨平台性Java语言的特点字节码Java的主类，应用程序和小程序的主类应用程序和小程序的区别基础语法数据类型switch的作用类型算术题编码访问修饰符关键字gotofinalfinal、finally、finalize区别thissuperthis和super的区别static面向对象概述类与接口抽象类与接口对象实例和对象引用变量和方法成员变量和局部变量的区别定义无参构造方法的作用Java中调用子类的构造方法之前会调
Java List集合排序实现方法解析
08-25
Java List 集合排序实现方法解析 Java List 集合排序实现方法解析是 Java 编程语言中一个非常重要的知识点。List 集合是 Java 中的一种常用的数据结构，它可以存储多个元素，并提供了许多操作元素的方法，例如添加...
Java List集合的应用.rar
06-24
Java List集合是Java编程语言中一个非常重要的数据结构，它属于集合框架的一部分，主要用于存储一组有序的、可重复的对象。List接口提供了许多方法，使得在处理列表数据时具有很高的灵活性和效率。在这个“Java List...
Java中对List集合的常用操作详解
09-02
在Java编程中，List集合是Java集合框架的重要组成部分，它是一种有序的集合，可以存储重复的元素。本文将深入解析Java中对List集合的常用操作，帮助开发者更好地理解和使用List接口。 1. **添加、获取和删除元素** ...
javalist.zip_list集合 java
09-23
描述中提到“java中集合list的应用非常重要”，这确实不假，因为List在处理有序数据时具有广泛的应用场景。 List接口位于java.util包下，它继承自Collection接口。Java提供了多种List的实现类，如ArrayList、...
Java-Java集合体系-List-Set
07-12
理解并熟练运用Java集合体系中的List、Set、Map接口及其实现类，对于日常开发和面试来说至关重要，因为它们是许多Java框架和库的基础。在实际项目中，根据需求选择合适的集合类型可以提高代码的效率和可维护性。在...
java-1.0.2.jar
10-11
amr转MP3 JAVE Java Audio Video Encoder 类库是一个 ffmpeg 项目的 Java 语言封装 开发人员可以使用JAVE 在不同的格式间转换视频和音频 例如将 AVI 转成 MPEG 动画 等等 ffmpeg 中可以完成的在 JAVE 都有对应的方法
JAVA笔记1.0
weixin_45815335的博客
07-17 92
JAVA笔记1.0 入门与环境搭建JAVA笔记1.01.Java 发展史2.Java 体系特点3.Java 特性面向对象跨平台较高的安全性。4.核心机制：JVM 与 GC4.1Java虚拟机（JVM）4.2垃圾回收器（GC）JDK 与 JRE代码分类环境配置 1.Java 发展史 1991年，Java在Sun Microsystems公司(以下简称Sun)被设计出来，开发第一个版本花了18个月。该语言开始名叫“Oak”，于1995年更名为“Java”，是一门高级的编程语言。 2009年，sun公司被甲骨文公
Java学习1.0
weixin_43931093的博客
10-29 507
第一章：java语言概述： 一.java的特点：平台无关性、面向对象、多线程、安全、动态。 二.java运行平台： java SE——java标志板或java标准平台 java EE——java企业版或java企业平台 java ME——java微型版或java小型平台 三.java程序开发： 1.编写源文件： （1）源文件的结构： ——java应用程序的源文件由若干个书写形式互相独立的类组成。 ...
rxjava1.0
riqthen的博客
05-22 253
实现倒计时功能(发送短信、启动页等待等) void beginCountdown(int time) { //time 为需要执行的时间 if (time &lt; 0) { time = 0; } final int countTime = time; Observable.interval(0, 1, TimeUnit.SECOND...
[细碎的java1.0]
m0_61998789的博客
11-03 169
作者很懒，什么都没留下~
java基础汇总1.0
qq_36900377的博客
04-03 185
java学习 idea快捷键 注释：ctrl+/ 快速new一个对象：先写右边new的内容，然后在把鼠标放在new前面，按ctrl+alt+v for循环快捷键：比如要循环100次：100.for+回车 java基础 1、JDK 、JRE、JVM的异同 JDK 用于开发， JRE 用于运行 java 程序 ；如果只是运行 Java 程序，可以只安装 JRE ，无序安装 JDK 。 JDk 包含 JRE ， JDK 和 JRE 中都包含 JVM 。 JVM 是相当于模拟了一个cpu，让其可以在不同的操作
java 1 0_【Java】1.0 开发环境
weixin_33264203的博客
02-20 123
本文并非最终版本，如果想要关注更新或更正的内容请关注文集，联系方式详见文末，如有疏忽和遗漏，欢迎指正。本文目录1、Java语言概述1.1 Java的简介Java 是一门语言，也是一种技术代码分为结构定义语句和功能执行语句，功能执行语句的最后必须用分号结束1.2 Java的发展历史1.3 Java的分类：按应用环境划分1.4 Java的语言特点开源面向对象跨平台性/可移植性跨平台的表现形式：Java...
java1.0特性_//Java学习笔记——基础中的基础 0 - 1.1
weixin_39709262的博客
02-25 102
开始边学边写吧！0环境搭建 //skip传 统 艺能publicclassHello{publicstaticvoidmain(String[]args){System.out.println("HelloWorld!");}}输出效果：Hello World!public class 直接定义一个公共的类。注意类名要与文件名一致！有了类就要往里面塞方法了。首...
（一）JAVA的初认识 1.0.0
jason郑东的博客
10-26 385
文章目录JAVA入门1.Java各版本的含义2.java的特性和优势3.java应用程序的运行机制4. JVM、JRE和JDK JAVA入门 1.Java各版本的含义 JAVA分为三个版本 JAVAEE(企业版):定位在服务器端的应用 JAVASE(标准版):定位在个人计算机上的应用。 JAVAME(微型版):定位在消费性电子产品的应用上 它们三者的关系如下图： JAVAEE包含SE，而ME是SE的一个内伸 2.java的特性和优势 跨平台/可移植性 安全性 面向对象 简单性 高性能 分布式 多线程
Java集合深度解析：List与Set接口实战
"Java集合体系List-Set" 在Java编程中，集合体系是处理对象存储和操作的核心部分。本文深入探讨了Java集合体系中的List和Set接口，以及它们的实现类，如ArrayList、LinkedList、HashSet和TreeSet。这些知识点对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值