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、五种遍历方式的对比

相关推荐
救救孩子把9 分钟前
深入理解 Java 对象的内存布局
java
落落落sss11 分钟前
MybatisPlus
android·java·开发语言·spring·tomcat·rabbitmq·mybatis
万物皆字节17 分钟前
maven指定模块快速打包idea插件Quick Maven Package
java
夜雨翦春韭23 分钟前
【代码随想录Day30】贪心算法Part04
java·数据结构·算法·leetcode·贪心算法
简单.is.good29 分钟前
【测试】接口测试与接口自动化
开发语言·python
我行我素，向往自由30 分钟前
速成java记录（上）
java·速成
一直学习永不止步36 分钟前
LeetCode题练习与总结：H 指数--274
java·数据结构·算法·leetcode·数组·排序·计数排序
邵泽明36 分钟前
面试知识储备-多线程
java·面试·职场和发展
Yvemil71 小时前
MQ 架构设计原理与消息中间件详解（二）
开发语言·后端·ruby
程序员是干活的1 小时前
私家车开车回家过节会发生什么事情
java·开发语言·软件构建·1024程序员节
热门推荐
01分享几个惊艳的 Three.js 个人站点02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04组基轨迹建模 GBTM的介绍与实现（Stata 或 R）05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache