java-单列集合List详解

一、List概述

​​​​​​​List 接口继承自 Collection 接口。这意味着所有 List 类型的对象都是 Collection 类型的对象，它们共享 Collection 接口中定义的所有方法。

List集合的特点：

1、有序：存和取得元素顺序一致

2、有索引：可以通过索引操作元素

3、可重复：存储的元素可以重复

二、List的方法

Collection接口的方法List都继承了，在此基础上List还增加了索引操作的方法

List独有的方法：

它的特有方法都与索引有关

1、增加元素

语法1：集合名称.add(元素)；

在集合的末尾添加元素

语法2：集合名称.add(索引，元素)；    特有方法

在指定索引添加元素，原索引及其之后的元素都会向后移动一位 而不是覆盖该索引处的元素

import java.util.ArrayList;
import java.util.List;

public class test1 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        // 通用方法
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");
        System.out.println(l);// [aaa, bbb, ccc]
        // 特有方法
        // 在指定索引处添加元素 原索引及其之后的元素都会向后移动一位 而不是覆盖该索引处的元素
        l.add(1,"在索引1处添加元素");
        System.out.println(l);// [aaa, 在索引1处添加元素, bbb, ccc]
    }
}

2、删除元素

语法1：集合名称.remove(元素)；

根据元素删除，如果存在则删除成功，返回值为true，如果不存在则删除失败，返回值为false

语法2：集合名称.remove(索引，元素)；    特有方法

在指定索引删除元素，返回值为删除的元素

import java.util.ArrayList;
import java.util.List;

public class test1 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        // 通用方法
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");
        System.out.println(l);// [aaa, bbb, ccc]
        // 特有方法
        // 在指定索引处添加元素 原索引及其之后的元素都会向后移动一位 而不是覆盖该索引处的元素
        l.add(1,"qqq");
        System.out.println(l);// [aaa, qqq, bbb, ccc]

        // 3.删除元素
        // 通用方法
        // 集合未存在java 删除失败 返回false
        boolean r1=l.remove("java");
        System.out.println(r1);// false
        System.out.println(l);// [aaa, qqq, bbb, ccc]
        // 集合存在qqq 删除成功 返回true
        boolean r2=l.remove("qqq");
        System.out.println(r2);// true
        System.out.println(l);// [aaa , bbb, ccc]

        // 特有方法
        // 在指定索引处删除元素
        String r3=l.remove(2);
        System.out.println(r3);// ccc
        System.out.println(l);// [aaa , bbb]
    }
}

3、修改元素

语法：集合名称.set(索引，元素)；特有方法

修改指定索引的元素，返回值为修改前的元素

import java.util.ArrayList;
import java.util.List;

public class test1 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        // 通用方法
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");
        System.out.println(l);// [aaa, bbb, ccc]
        // 特有方法
        // 在指定索引处添加元素 原索引及其之后的元素都会向后移动一位 而不是覆盖该索引处的元素
        l.add(1,"qqq");
        System.out.println(l);// [aaa, qqq, bbb, ccc]

        // 3.修改元素
        // 修改指定索引的元素 返回修改前的元素
        String r1=l.set(1, "kkk");
        System.out.println(r1);// qqq
        System.out.println(l);// [aaa, kkk, bbb, ccc]
    }
}

4、获取元素

语法：集合名称.set(索引)；特有方法

返回值为该索引对应的元素

import java.util.ArrayList;
import java.util.List;

public class test1 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        // 通用方法
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");
        System.out.println(l);// [aaa, bbb, ccc]
        // 特有方法
        // 在指定索引处添加元素 原索引及其之后的元素都会向后移动一位 而不是覆盖该索引处的元素
        l.add(1,"qqq");
        System.out.println(l);// [aaa, qqq, bbb, ccc]

        // 3.获取元素
        // 返回值为该索引对应的元素
        String r1=l.get(1);
        System.out.println(r1);// qqq
    }
}

5、注意点

因为出现了方法的重载，在调用方法时，会优先调用形参类型与实参类型一致的方法

三、List的遍历方式

List的遍历方式不仅继承Collection接口的遍历方式，还有自己特有的根据索引遍历的方式，它的遍历方式共5种，包括迭代器遍历、增强for遍历、lamdba表达式遍历、普通for循环（特有 因为List集合存在索引）、列表迭代器遍历（特有），其中迭代器遍历、增强for遍历、lamdba表达式遍历是继承Collection接口的遍历方式，用法完全一致

详情可以参考以下文章：http://t.csdnimg.cn/zTdXHicon-default.png?t=N7T8http://t.csdnimg.cn/zTdXH

1、迭代器遍历

语法：

Iterator<集合元素类型>迭代器名称=集合名称.Iterator()；

while(迭代器对象名称.hasnext()){

        System.out.println(迭代器对象名称.next())；

}

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

public class 迭代器遍历 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");

        // 3.遍历集合
        // 通过iterator方法创建迭代器对象
        Iterator<String> it=l.iterator();
        // hasNext()判断该位置是否存在元素 若存在则返回true 不存在则返回false
        while (it.hasNext()){
            // next()是用来返回当前位置元素 并指向下一位置的元素
            String s=it.next();
            System.out.println(s);
        }
        // aaa
        // bbb
        // ccc
    }
}

2、列表迭代器遍历（特有）

列表迭代器遍历与迭代器遍历的方法很相似，不同的是列表迭代器遍历不仅可以在遍历的时候删除元素，还可以在遍历的时候添加元素

语法：（仅仅遍历）

ListIterator<集合元素类型>迭代器名称=集合名称.ListIterator()；

while(迭代器对象名称.hasnext()){

        System.out.println(迭代器对象名称.next())；

}

补充知识：

ListIterator与Iterator的关系： ListIterator接口则是一个专门为List设计的迭代器接口 它扩展了Iterator接口，并添加了一些针对List集合特有的方法

ListIterator与List的关系： ListIterator是专门为List设计的一个迭代器的接口 List含有获取ListIterator迭代器的方法 即listIterator()

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

public class 列表迭代器遍历 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");

        // 3.列表迭代器遍历
        // 通过listIterator方法生成列表迭代器
         /*
            ListIterator与Iterator的关系：
            ListIterator接口则是一个专门为List设计的迭代器接口
            它扩展了Iterator接口，并添加了一些针对List集合特有的方法
            ListIterator与List的关系：
            ListIterator是专门为List设计的一个迭代器的接口
            List含有获取ListIterator迭代器的方法 即listIterator()
          */
        ListIterator<String> it=l.listIterator();
        // hasNext()判断该位置是否存在元素 若存在则返回true 不存在则返回false
        while (it.hasNext()){
            // next()是用来返回当前位置元素 并指向下一位置的元素
            String s=it.next();
            System.out.println(s);
        }
        //aaa
        //bbb
        //ccc
    }
}

语法：（遍历中增加元素）

it.add(元素)；

注意：ListIterator的add()方法的作用是在当前迭代器位置之前插入一个元素

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

public class 列表迭代器遍历 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");

        // 3.列表迭代器遍历
        // 通过listIterator方法生成列表迭代器
         /*
            ListIterator与Iterator的关系：
            ListIterator接口则是一个专门为List设计的迭代器接口
            它扩展了Iterator接口，并添加了一些针对List集合特有的方法
            ListIterator与List的关系：
            ListIterator是专门为List设计的一个迭代器的接口
            List含有获取ListIterator迭代器的方法 即listIterator()
          */
        ListIterator<String> it=l.listIterator();
        // hasNext()判断该位置是否存在元素 若存在则返回true 不存在则返回false
        while (it.hasNext()){
            // next()是用来返回当前位置元素 并指向下一位置的元素
            String s=it.next();
            if(s.equals("bbb")){
                it.add("qqq");
            }
            System.out.println(s);
        }
        /*
                第一次遍历时指针指向aaa 调用it.next(); 将aaa赋值给s 并将指针指向下一位置bbb
                然后判断s是否为bbb 此时s不是bbb 因此it.add("qqq");没有执行  输出aaa
                第二次遍历时指针指向bbb 调用it.next(); 将bbb赋值给s 并输出bbb 并将指针指向下一位置ccc
                然后判断s是否为bbb 此时s是bbb 因此it.add("qqq");执行 并输出bbb
                ListIterator的add()方法的作用是在当前迭代器位置之前插入一个元素。
                所以在ccc前添加qqq 
                将ccc赋值给s 此时s不是bbb 因此it.add("qqq");不执行 并将指针指向下一位置(没有元素) 循环结束
                整个过程qqq没有输出
        */
        //aaa
        //bbb
        //ccc
        System.out.println(l);// [aaa, bbb, qqq, ccc]
    }
}
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class 列表迭代器遍历 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");

        // 3.列表迭代器遍历
        // 通过listIterator方法生成列表迭代器
         /*
            ListIterator与Iterator的关系：
            ListIterator接口则是一个专门为List设计的迭代器接口
            它扩展了Iterator接口，并添加了一些针对List集合特有的方法
            ListIterator与List的关系：
            ListIterator是专门为List设计的一个迭代器的接口
            List含有获取ListIterator迭代器的方法 即listIterator()
          */
        ListIterator<String> it=l.listIterator();
        // hasNext()判断该位置是否存在元素 若存在则返回true 不存在则返回false
        while (it.hasNext()){
            // next()是用来返回当前位置元素 并指向下一位置的元素
            it.add("qqq");
            String s=it.next();
             /*
                ListIterator的add()方法的作用是在当前迭代器位置之前插入一个元素。
                第一次遍历时指针指向aaa 调用it.add("qqq"); 会在aaa前添加qqq
                然后调用it.next()输出aaa 并将指针指向下一位置bbb 因此qqq不会输出
                第二次遍历时指针指向bbb 调用it.add("qqq"); 会在bbb前添加qqq
                然后调用it.next()输出bbb 并将指针指向下一位置ccc 因此qqq不会输出
                第三次遍历时指针指向aaa 调用it.add("qqq"); 会在ccc前添加qqq
                然后调用it.next()输出aaa 并将指针指向下一位置(没有元素) 因此qqq不会输出
                循环结束
             */
            System.out.println(s);
        }
        //aaa
        //bbb
        //ccc
        System.out.println(l);// [qqq, aaa, qqq, bbb, qqq, ccc]
    }
}

3、增强for遍历

快速生成增强for遍历：集合名称.for+回车

import java.util.ArrayList;
import java.util.List;

public class 增强for遍历 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");

        // 3.遍历集合
        // 增强for遍历
        // 快速生成增强for遍历：集合名称.for+回车
        // s是用来存储遍历的元素
        for (String s : l) {
            System.out.println(s);
        }
        // aaa
        // bbb
        // ccc
    }
}

4、lamdba表达式遍历

forEach方法的底层其实是一个循环遍历  依次得到集合中的每一个元素

并将每一个元素传递给accept方法(其中String s中,s就是传入的元素)

 accept方法就是将传入的元素输出

最后利用lamdba表达式进行简化

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class lamaba表达式遍历 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");

        // 3.lamdba表达式遍历
        // forEach方法的底层其实是一个循环遍历 依次得到集合中的每一个元素
        // 并将每一个元素传递给accept方法(其中String s,s就是传入的元素)
        // accept方法就是将传入的元素输出
        // 简化前：
        l.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        // aaa
        // bbb
        // ccc

        // 简化后:
        l.forEach(s->System.out.println(s));
        // aaa
        // bbb
        // ccc
    }
}

5、普通for循环（特有 因为List集合存在索引）

语法：       

for (int i = 0; i < l.size(); i++) {
            System.out.println(l.get(i));
  }

通过get和size方法结合，遍历集合的元素

import java.util.ArrayList;
import java.util.List;

public class 普通for遍历 {
    public static void main(String[] args) {
        // 1.创建集合
        List<String> l=new ArrayList<>();

        // 2.添加元素
        l.add("aaa");
        l.add("bbb");
        l.add("ccc");

        // 3.普通for遍历元素
        // 通过集合名称.size().fori快速生成for循环
        // l.size()获取集合的长度
        // l.get(i)获取索引为i的元素值
        for (int i = 0; i < l.size(); i++) {
            System.out.println(l.get(i));
        }
        //aaa
        //bbb
        //ccc
    }
}

6、五种遍历方式的对比

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/562525.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Java- Object根父类

Java- Object根父类

在java中&#xff0c;所有的类都有一个公共的父类&#xff0c;这个java.lang.Object类 * * * Object所有类的根&#xff0c;成为超类。 1.证明Object是根 public class A_Object01 {public static void main(String[] args) {//证明Object是根//基本数据类型int a 0;Object…
阅读更多...
【硬十宝典】——1.4【基础知识】电源完整性——理解与设计

【硬十宝典】——1.4【基础知识】电源完整性——理解与设计

定义&#xff1a; 电源完整性&#xff08;Power integrity&#xff09;简称PI&#xff0c;是确认电源来源及目的端的电压及电流是否符合需求。 电源完整性在现今的电子产品中相当重要。有几个有关电源完整性的层面&#xff1a;芯片层面、芯片封装层面、电路板层面及系统层面。…
阅读更多...
18-Echarts 配置系列之：数据集 dataset

18-Echarts 配置系列之：数据集 dataset

简介&#xff1a; 数据集&#xff08;dataset&#xff09;是专门用来管理数据的组件。简化在每一个系列中设置数据&#xff0c;这一个配置是在Echarts4 中开始支持。 通过数据集配置&#xff0c;避免为每一个系列创建一个数据&#xff0c;避免格式转化的痛苦。 简单举例&…
阅读更多...
开启智慧之旅，AI与机器学习驱动的微服务设计模式探索

开启智慧之旅，AI与机器学习驱动的微服务设计模式探索

​&#x1f308; 个人主页&#xff1a;danci_ &#x1f525; 系列专栏&#xff1a;《设计模式》 &#x1f4aa;&#x1f3fb; 制定明确可量化的目标&#xff0c;坚持默默的做事。 &#x1f680; 转载自热榜文章&#x1f525;&#xff1a;探索设计模式的魅力&#xff1a;开启智慧…
阅读更多...
2024年腾讯云免费服务器最新申请入口链接

2024年腾讯云免费服务器最新申请入口链接

腾讯云免费服务器申请入口 txybk.com/go/free 免费服务器可选轻量应用服务器和云服务器CVM&#xff0c;轻量配置可选2核2G3M、2核8G7M和4核8G12M&#xff0c;CVM云服务器可选2核2G3M和2核4G3M配置&#xff0c;腾讯云百科txybk.com分享2024年最新腾讯云免费服务器申请入口、限制…
阅读更多...
YOLOv8操作指南-下载+配置环境

YOLOv8操作指南-下载+配置环境

下载&#xff1a;github&#xff0c;进入搜索YOLOv8 就这个&#xff0c;点开 下载就可以了&#xff0c;然后解压一下 配置环境&#xff1a; 安装Pytorch 先看一下这个&#xff1a; 如果电脑有GPU的话&#xff1a; 判断自己电脑GPU&#xff1a;打开任务管理器 我的是英伟达3…
阅读更多...
sherpa + ncnn 离线语音识别

sherpa + ncnn 离线语音识别

目录结构 前言音视频格式转为wavsherpa-ncnn编译LinuxWindowswindows编译中遇到的问题问题“nmake -? failed with: no such file or directory”编译失败原因 成功编译截图 可执行程序说明模型下载语言识别测试LinuxWindows 参考文献 前言 小编需要实现离线音视频语言部分识…
阅读更多...
vulfocus靶场couchdb 权限绕过 （CVE-2017-12635）

vulfocus靶场couchdb 权限绕过 （CVE-2017-12635）

Apache CouchDB是一个开源数据库&#xff0c;专注于易用性和成为"完全拥抱web的数据库"。它是一个使用JSON作为存储格式&#xff0c;JavaScript作为查询语言&#xff0c;MapReduce和HTTP作为API的NoSQL数据库。应用广泛&#xff0c;如BBC用在其动态内容展示平台&…
阅读更多...
完结撒花！ java算法day60 | 84.柱状图中最大的矩形

完结撒花！ java算法day60 | 84.柱状图中最大的矩形

84.柱状图中最大的矩形 思路&#xff1a; 这道题和接雨水很像&#xff0c;不过有两点差别&#xff1a; 这道题需要找到一个位置前一个比他小的数和后一个比他小的数&#xff0c;而接雨水是找到前一个和后一个比他大的数。需要在原数组前后各补上0&#xff0c;防止忽略一些边缘…
阅读更多...
Excel数据处理：高级筛选、查找定位、查找函数（VLOOKUP）

Excel数据处理：高级筛选、查找定位、查找函数（VLOOKUP）

高级筛选 先去选中筛选区域 如果筛选的条件在同一行那么就是且的关系 如果筛选的条件不在同一行那么就是或的关系 查找定位空值 使用VLOOKUP函数
阅读更多...
C语言中, 文件包含处理,#include＜ ＞ 与 #include ““的区别

C语言中, 文件包含处理,#include＜ ＞ 与 #include ““的区别

文件包含处理 指一个源文件可以将另外一个文件的全部内容包含进来 &#xff23;语言提供了#include命令用来实现文件包含的操作 #include< > 与 #include ""的区别 <> 表示系统直接按系统指定的目录检索 "" 表示系统先在 "" 指定…
阅读更多...
PACS/RIS影像管理系统源码，医院影像科室PACS系统源码，三维医学影像系统源码 支持图像后处理与重建

PACS/RIS影像管理系统源码，医院影像科室PACS系统源码，三维医学影像系统源码 支持图像后处理与重建

PACS/RIS影像管理系统源码&#xff0c;支持图像后处理与重建 医院影像科室PACS系统源码&#xff0c;三维医学影像系统源码 PACS&#xff0c;全称为Picture Archiving and Communication Systems&#xff0c;中文意思是医学影像存档与通讯系统。它主要是应用在医院影像科室中&a…
阅读更多...
java算法day4

java算法day4

删除链表的倒数第N个结点链表相交环形链表 删除链表的倒数第N个结点 解法&#xff1a;双指针&#xff08;快慢指针&#xff09; 首先一定要有删除结点的思想。所以这个题是用虚拟头结点比较方便。 先上模拟图&#xff0c;然后看流程&#xff1a; 这里后移根据不同的想法有不同…
阅读更多...
java优先级队列（堆）详解

java优先级队列（堆）详解

一、优先级概念 什么是优先级&#xff1a;比如女士优先&#xff0c;个子低的优先排到前面去&#xff0c;有一部分数据具备优先级&#xff0c;要以优先级的顺序将顺序存储起来。 前面介绍过队列&#xff0c;队列是一种先进先出(FIFO)的数据结构&#xff0c;但有些情况下&#…
阅读更多...
OceanBase开发者大会2023届视频及PPT汇总

OceanBase开发者大会2023届视频及PPT汇总

数据库技术趋势 我眼中的数据库技术 阳振坤OceanBase 首席科学家 观看视频 下载 PDF 未来&#xff0c;中国需要什么样的数据库&#xff1f; 周傲英华东师范大学副校长&#xff0c;CCF 会士 观看视频 下载 PDF 云原生技术趋势解读 Keith ChanCNCF 云原生计算基金会中国区总监 …
阅读更多...
开发工具的使用

开发工具的使用

IDEA的安装与使用&常用快捷键 文章目录 IDEA的安装与使用&常用快捷键一、认识IntelliJ IDEA二、IDEA 的下载&卸载三、IEAD相关设置3.1 JDK的相关设置3.2 系统设置&#xff08;启动项/自动更新&#xff09;3.3 设置整体主题&#xff08;主题/字体/背景&#xff09;3…
阅读更多...
Linux--链表 第二十五天

Linux--链表 第二十五天

1. 链表 t1.next -> data t1.next->next->data .(点号)的优先级比->的大 所以 t1.next->data 就可以了 不用(t1.next)->data 2. 链表的静态增加和动态遍历 打印链表算法&#xff0c; void printLink(struct Test *head) { struct Te…
阅读更多...
如何做一个优秀的系统工程师？

如何做一个优秀的系统工程师？

一、背景 做好一个优秀系统工程师的关键在于其在产品开发生命周期中对需求分析的有效把握与运用&#xff0c;这个过程直接影响到系统的整体架构设计、规格参数的明确设定以及业务流程的深度挖掘与优化。需求分析不仅是理解用户实际问题的核心环节&#xff0c;更是界定系统开发…
阅读更多...
Java基础之JVM对象内存分配机制简介

Java基础之JVM对象内存分配机制简介

一 对象内存分配 1.1 运行时数据区域 1.2 常见java应用启动JVM参数&#xff1a; -Xss&#xff1a;每个线程的栈大小(单位kb)-Xms&#xff1a;堆的初始大小&#xff0c;默认物理内存的1/64,示例&#xff1a;-Xms:4g -Xms:10m-Xmx&#xff1a;堆的最大可用大小&#xff0c;默认物…
阅读更多...
LeetCode 热题 100 题解：普通数组部分

LeetCode 热题 100 题解：普通数组部分

文章目录 题目一&#xff1a;最大子数组和&#xff08;No. 53&#xff09;题解 题目二&#xff1a;合并区间&#xff08;No. 56&#xff09;题解 题目三&#xff1a;轮转数组&#xff08;No. 189&#xff09;题解 题目四&#xff1a;除自身以外数组的乘积&#xff08;No. 238&a…
阅读更多...
最新文章

Copyright @ 2022~2023