java-单列集合List详解

新野一.2024-04-22 8:55

一、List概述

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

List集合的特点：

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

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

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

二、List的方法

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

List独有的方法：

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

1、增加元素

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

在集合的末尾添加元素

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

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

java 复制代码 
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(索引，元素)； 特有方法

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

java 复制代码 
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(索引，元素)；特有方法

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

java 复制代码 
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(索引)；特有方法

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

java 复制代码 
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/zTdXHhttp://t.csdnimg.cn/zTdXH

1、迭代器遍历

语法：

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

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

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

}

java 复制代码 
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()

java 复制代码 
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()方法的作用是在当前迭代器位置之前插入一个元素

java 复制代码 
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]
    }
}
java 复制代码 
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+回车

java 复制代码 
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表达式进行简化

java 复制代码 
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方法结合，遍历集合的元素

java 复制代码 
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、五种遍历方式的对比

相关推荐
Chrikk22 分钟前
Go-性能调优实战案例
开发语言·后端·golang
幼儿园老大*24 分钟前
Go的环境搭建以及GoLand安装教程
开发语言·经验分享·后端·golang·go
canyuemanyue25 分钟前
go语言连续监控事件并回调处理
开发语言·后端·golang
杜杜的man27 分钟前
【go从零单排】go语言中的指针
开发语言·后端·golang
测开小菜鸟28 分钟前
使用python向钉钉群聊发送消息
java·python·钉钉
P.H. Infinity1 小时前
【RabbitMQ】04-发送者可靠性
java·rabbitmq·java-rabbitmq
生命几十年3万天1 小时前
java的threadlocal为何内存泄漏
java
caridle2 小时前
教程：使用 InterBase Express 访问数据库（五）：TIBTransaction
java·数据库·express
萧鼎2 小时前
Python并发编程库：Asyncio的异步编程实战
开发语言·数据库·python·异步
学地理的小胖砸2 小时前
【一些关于Python的信息和帮助】
开发语言·python
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06【经验分享】Ubuntu22.04安装微信(linux官方版)07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）09RAG 实践- Ollama+RagFlow 部署本地知识库10你还在傻傻的打开页面输用户名和密码？来我教你实现自动化