Java集合中的List超详细讲解

2025-02-26 17:50
文章标签 java 讲解 详细 list 集合

本文主要是介绍Java集合中的List超详细讲解,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

《Java集合中的List超详细讲解》本文详细介绍了Java集合框架中的List接口,包括其在集合中的位置、继承体系、常用操作和代码示例,以及不同实现类(如ArrayList、LinkedList和V...

ListJava集合框架中一个非常重要的接口,它代表了一个有序的集合,允许元素重复,并且可以按照插入的顺序进行访问。

我们先来看看List在集合中的位置:

Java集合中的List超详细讲解

List是单列集合接口Collection下的一个分支,另两个分支是SetQueue,三者的区别:

  • List集合中的元素是有序的、可重复的
  • Set集合中的元素无需、不可重复
  • Qeue集合中的元素遵循先进先出的规则

一,List的继承体系

List接口继承自Collection接口,位于java.util包中。

List是有序集合的抽象表示,Java发展至今,List体系已经非常庞杂。

Java集合中的List超详细讲解

从上图看出,JDK中,直接或间接继承List接口的有80个类。当然,我们无需一一学习,通过三个常用的实现类的学习掌握原理即可:ArrayList、LinkedList和Vector。

  • ArrayList:基于动态数组实现,提供了快速的随机访问。
  • LinkedList:基于双向链表实现,擅长插入和删除操作,尤其是表头和表尾的操作。
  • Vector:早期版本的线程安全列表,与ArrayList相似,但现在多被ArrayList取代,因同步开销较大。

二,List的常用操作及代码示例

1,创建List实例

import java.util.*;
public class ListDemo {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>(); // 创建ArrayList实例
        List<String> linkedList = new LinkedList<>(); // 创建LinkedList实例
    }
}

2,增加元素

  • add(E element):在列表末尾添加元素。
  • add(int index, E element):在指定位置插入元素。
arrayList.add("Apple");
linkedList.add(0, China编程"Banana"); // 在首位插入

3,访问元素

  • 通过索引访问:get(int index)
  • php历:使用for-each循环或迭代器Iterator。
System.out.println(arrayList.get(0));
for (String fruit : arrayList) {
    System.out.println(fruit);
}

4,修改元素

  • 使用set(int index, E element)方法替换指定位置的元素。
arrayList.set(0, "Orange");

5,删除元素

  • remove(int index):根据索引删除。
  • remove(Object o):根据元素删除第一个匹配项。
arrayList.remove(0);
arrayList.remove("Orange");

6,判断与查找

  • contains(Object o):判断是否包含某元素。
  • indexOf(Object o):返回元素第一次出现的索引,未找到返回-1。
  • lastIndexOf(Object o):List集合中的元素可重复,返回元素最后一次出现的索引,未找到返回-1。
boolean hasApple = arrayList.contains("Apple");
int index = arrayList.indexOf("Apple");
int index = arrayList.lastIndexOf("Apple");

7,大小与清空

  • size():返回列表大小。
  • clear():清空列表。
int size = arrayList.size();
arrayList.clear();

8,List集合的遍历

Java List 接口提供了多种方式来遍历其中的元素,以下是三种常见的遍历方式,每种方式都有相应的代码示例。

① 使用 for-each 循环

这是最简洁也是最常用的遍历方式,适用于Java 5及以后的版本。通过for-each循环,可以直接遍历China编程List中的每个元素,而无需手动管理索引。

代码示例

import java.util.ArrayList;
import java.util.List;
public class ListTraversal {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        // 使用for-each循环遍历
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

并发修改异常ConcurrentModificationException

**注意,**使用for循环时,有可能会出现并发修改异常ConcurrentModificationException,如下面的例子,假设你有一个任务是遍历一个List,检查其中的元素,如果满足某个条件,就从List中删除该元素。

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
for (String item : list) {
    if ("B".equals(item)) {
        list.remove(item); // 这里会抛出ConcurrentModificationException
    }
}

Java集合框架中的许多类,如ArrayListLinkedList,为了检测到并发修改,使用了所谓的“快速失败”机制:

  • ①当迭代器创建之后,集合会维护一个名为modCount的字段来记录集合的修改次数
  • ②每当集合通过迭代器之外的方式(如直接调用addremove方法)发生修改时,modCount就会递增
  • ③迭代器在每次调用nexthasNext等方法时,都会检查这个计数器是否发生变化,如果发现modCount不等于它内部记录的初始修改次数,就会抛出ConcurrentModificationException

据此分析,上面的代码示例之所以会报错,是因为:

  • ①使用for循环时会创建迭代器,迭代器会缓存当前modCount的值
  • ②在循环中使用了remove,modCount的值发生了变化
  • ③下一循环时,迭代器会检查缓存的modCount值与真实的modCount值是否一致,不一致就会抛出错误

并发修改异常的解决办法

①使用迭代器的remove方法

正确的做法是在迭代过程中使用迭代器的remove方法来删除元素,因为迭代器的remove方法会在删除元素后同时更新内部的修改计数,以保持一致性。

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    if ("B".equals(item)) {
        iterator.remove(); // 正确的删除方式
    }
}

② 使用CopyOnWriteArrayList

对于多线程环境下的并发修改问题,可以考虑使用CopyOnWriteArrayList。这是一种线程安全的List实现,它通过在每次修改时创建集合的副本来避免并发修改异常,适合读多写少的场景。

List<String> list = new CopyOnWriteArrayList<>(Arrays.asList("A", "B", "C", "D"));
list.removeIf("B"::equals); // 线程安全的删除操作

② 使用迭代器 Iterator

迭代器是一种更通用的遍历集合的方法,适用于所有实现了Iterable接口的集合,包括List。通过调用List的iterator()方法获取Iterator对象,然后使用hasNext()next()方法进行遍历。

代码示例

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListTraversal {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        // 使用迭代器遍历
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
    }
}

③ 使用Java 8的Stream API

从Java 8开始,可以使用Stream API来遍历和处理集合中的元素,这种方式更加灵活,支持函数式编程风格。

代码示例

import java.util.ArrayList;
import java.util.List;
public class ListTraversal {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("javascriptCherry");
        // 使用Stream API遍历
        fruits.stream().forEach(System.out::println);
    }
}

④ 总结

  • for-each循环:简洁易读http://www.chinasem.cn,最适合日常使用。
  • Iterator:提供了更多的控制权,比如在遍历时移除元素,但在大多数情况下不如for-each方便。
  • Stream API:功能强大,支持复杂的集合处理和并行处理,适合进行复杂的聚合操作和过滤操作。

9,List集合的排序

在Java中,对List集合中的元素进行排序可以通过多种方式实现,主要依赖于java.util.Collections类和List接口本身提供的排序方法。下面我将介绍几种常见的排序方法,并提供相应的代码示例。

① 使用Collections.sort()方法

这是最直接的方式,适用于实现了Comparable接口的元素列表,进行自然排序。

代码示例(自然排序):

import java.util.*;
class Person implements Comparable<Person> {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age); // 按年龄排序
    }
    @Override
    public String toString() {
        return name + " " + age;
    }
}
public class SortListExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Tom", 25));
        people.add(new Person("Jerry", 20));
        people.add(new Person("Bob", 30));
        Collections.sort(people);
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

②使用Collections.sort()方法和自定义Comparator

如果列表中的元素没有实现Comparable接口,或者你想根据不同的规则进行排序,可以提供一个Comparator

代码示例(自定义比较器排序):

import java.util.*;
public class SortListExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1); // 倒序排序
            }
        });
        names.forEach(System.out::println); // 输出:Charlie, Bob, Alice
    }
}

③使用List自带的sort()方法

从Java 8开始,List接口直接提供了sort()方法,它同样接受Comparator来控制排序逻辑。

代码示例

import java.util.*;
public class SortListExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
        numbers.sort(Integer::compareTo); // 自然排序
        System.out.println(numbers); // 输出:[1, 1, 3, 4, 5, 9]
        numbers.sort(Collections.reverseorder()); // 倒序排序
        System.out.println(numbers); // 输出:[9, 5, 4, 3, 1, 1]
    }
}

④小结

  • 使用Collections.sort()适用于不支持Lambda表达式的较早Java版本。
  • 从Java 8开始,直接使用List的sort()方法配合Lambda表达式或方法引用来实现排序更为简洁。
  • 通过自定义Comparator,可以灵活地控制排序逻辑,适应不同的排序需求。

三,不同List实现的底层原理及区别

ArrayList

  • 底层原理:基于可变大小的数组实现,数组扩容时会创建新数组并复制旧数据。
  • 适用场景:当需要频繁查询元素,且元素数量变化不大时效率高。

LinkedList

  • 底层原理:每个元素都是一个节点,包含前驱和后继节点的引用,形成双向链表。
  • 适用场景:适合于频繁的插入和删除操作,尤其是在列表的开始或结尾。

Vector

  • 底层原理:与ArrayList相似,但Vector是线程安全的,通过在关键方法上加锁实现。
  • 区别与注意事项:由于同步操作,Vector在多线程环境下更安全,但并发访问时性能较低。现代开发中,推荐使用Collections.synchronizedList(List<T> list)CopyOnWriteArrayList作为替代。

通过上述内容,我们不仅了解了List接口的继承体系、常用操作,还深入探讨了ArrayList、LinkedList和Vector这三种常见实现的底层原理及其应用场景。掌握这些知识,将有助于在实际开发中更加高效、灵活地使用List集合。

到此这篇关于Java集合中的List超详细讲解的文章就介绍到这了,更多相关java集合list内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持China编程(www.chinasem.cn)!

这篇关于Java集合中的List超详细讲解的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!


原文地址:http://www.cppcns.com/ruanjian/java/701996.html
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.chinasem.cn/article/1153551

相关文章

java中long的一些常见用法

《java中long的一些常见用法》在Java中,long是一种基本数据类型,用于表示长整型数值,接下来通过本文给大家介绍java中long的一些常见用法,感兴趣的朋友一起看看吧... 在Java中,long是一种基本数据类型,用于表示长整型数值。它的取值范围比int更大,从-922337203685477

java Long 与long之间的转换流程

《javaLong与long之间的转换流程》Long类提供了一些方法,用于在long和其他数据类型(如String)之间进行转换,本文将详细介绍如何在Java中实现Long和long之间的转换,感... 目录概述流程步骤1:将long转换为Long对象步骤2:将Longhttp://www.cppcns.c

SpringBoot集成LiteFlow实现轻量级工作流引擎的详细过程

《SpringBoot集成LiteFlow实现轻量级工作流引擎的详细过程》LiteFlow是一款专注于逻辑驱动流程编排的轻量级框架,它以组件化方式快速构建和执行业务流程,有效解耦复杂业务逻辑,下面给大... 目录一、基础概念1.1 组件(Component)1.2 规则(Rule)1.3 上下文(Conte

SpringBoot服务获取Pod当前IP的两种方案

《SpringBoot服务获取Pod当前IP的两种方案》在Kubernetes集群中,SpringBoot服务获取Pod当前IP的方案主要有两种,通过环境变量注入或通过Java代码动态获取网络接口IP... 目录方案一:通过 Kubernetes Downward API 注入环境变量原理步骤方案二:通过

Springboot整合Redis主从实践

《Springboot整合Redis主从实践》:本文主要介绍Springboot整合Redis主从的实例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言原配置现配置测试LettuceConnectionFactory.setShareNativeConnect

Java中Map.Entry()含义及方法使用代码

《Java中Map.Entry()含义及方法使用代码》:本文主要介绍Java中Map.Entry()含义及方法使用的相关资料,Map.Entry是Java中Map的静态内部接口,用于表示键值对,其... 目录前言 Map.Entry作用核心方法常见使用场景1. 遍历 Map 的所有键值对2. 直接修改 Ma

Springboot3+将ID转为JSON字符串的详细配置方案

《Springboot3+将ID转为JSON字符串的详细配置方案》:本文主要介绍纯后端实现Long/BigIntegerID转为JSON字符串的详细配置方案,s基于SpringBoot3+和Spr... 目录1. 添加依赖2. 全局 Jackson 配置3. 精准控制(可选)4. OpenAPI (Spri

Java中实现线程的创建和启动的方法

《Java中实现线程的创建和启动的方法》在Java中,实现线程的创建和启动是两个不同但紧密相关的概念,理解为什么要启动线程(调用start()方法)而非直接调用run()方法,是掌握多线程编程的关键,... 目录1. 线程的生命周期2. start() vs run() 的本质区别3. 为什么必须通过 st

关于跨域无效的问题及解决(java后端方案)

《关于跨域无效的问题及解决(java后端方案)》:本文主要介绍关于跨域无效的问题及解决(java后端方案),具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录通用后端跨域方法1、@CrossOrigin 注解2、springboot2.0 实现WebMvcConfig

Java SWT库详解与安装指南(最新推荐)

《JavaSWT库详解与安装指南(最新推荐)》:本文主要介绍JavaSWT库详解与安装指南,在本章中,我们介绍了如何下载、安装SWTJAR包,并详述了在Eclipse以及命令行环境中配置Java... 目录1. Java SWT类库概述2. SWT与AWT和Swing的区别2.1 历史背景与设计理念2.1.