Java集合 -List

于 2025-03-27 17:52:41 发布
阅读量761 收藏 30
点赞数 16
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31098483/article/details/146401281
版权

Collection

Java标准库自带的java.util包提供了集合类：Collection，它是除Map外所有其他集合类的根接口。Java的java.util包主要提供了以下三种类型的集合：

  • List：一种有序列表的集合，例如，按索引排列的Student的List；
  • Set：一种保证没有重复元素的集合，例如，所有无重复名称的Student的Set；
  • Map：一种通过键值（key-value）查找的映射表集合，例如，根据Student的name查找对应Student的Map。
  • Java的集合类定义在java.util包中，支持泛型，主要提供了3种集合类，包括List，Set和Map。Java集合使用统一的Iterator遍历，尽量不要使用遗留接口。

使用List

在集合类中，List是最基础的一种集合：它是一种有序列表。

List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始。

在实际应用中，需要增删元素的有序列表，我们使用最多的是ArrayList。实际上，ArrayList在内部使用了数组来存储所有元素。例如，一个ArrayList拥有5个元素，实际数组大小为6（即有一个空位）：

size=5
┌───┬───┬───┬───┬───┬───┐
│ A │ B │ C │ D │ E │   │
└───┴───┴───┴───┴───┴───┘

当添加一个元素并指定索引到ArrayList时，ArrayList自动移动需要移动的元素：

size=5
┌───┬───┬───┬───┬───┬───┐
│ A │ B │   │ C │ D │ E │
└───┴───┴───┴───┴───┴───┘

然后，往内部指定索引的数组位置添加一个元素，然后把size加1：

size=6
┌───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │
└───┴───┴───┴───┴───┴───┘

继续添加元素，但是数组已满，没有空闲位置的时候，ArrayList先创建一个更大的新数组，然后把旧数组的所有元素复制到新数组，紧接着用新数组取代旧数组：

size=6
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │   │   │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

现在，新数组就有了空位，可以继续添加一个元素到数组末尾，同时size加1：

size=7
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │ G │   │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

可见，ArrayList把添加和删除的操作封装起来，让我们操作List类似于操作数组，却不用关心内部元素如何移动。

我们考察List<E>接口，可以看到几个主要的接口方法：

  • 在末尾添加一个元素：boolean add(E e)
  • 在指定索引添加一个元素：boolean add(int index, E e)
  • 删除指定索引的元素：E remove(int index)
  • 删除某个元素：boolean remove(Object e)
  • 获取指定索引的元素：E get(int index)
  • 获取链表大小（包含元素的个数）：int size()

但是，实现List接口并非只能通过数组（即ArrayList的实现方式）来实现，另一种LinkedList通过“链表”也实现了List接口。在LinkedList中，它的内部每个元素都指向下一个元素：

HEAD ──▶│ A │ ●─┼──▶│ B │ ●─┼──▶│ C │ ●─┼──▶│ D │   │
ArrayListLinkedList
获取指定元素速度很快需要从头开始查找元素
添加元素到末尾速度很快速度很快
在指定位置添加/删除需要移动元素不需要移动元素
内存占用少较大

通常情况下，我们总是优先使用ArrayList。

List的特点

List接口允许我们添加重复的元素

List还允许添加null

  List<String> list = new ArrayList<>();
        list.add("apple"); // size=1
        list.add(null); // size=2
        list.add("pear"); // size=3
        String second = list.get(1); // null
        System.out.println(second);

除了使用ArrayList和LinkedList，我们还可以通过List接口提供的of()方法，根据给定元素快速创建List：JDK 1.8 不可用该方法这个方法是在 Java 9 中引入的

List<Integer> list = List.of(1, 2, 5);

但是List.of()方法不接受null值，如果传入null，会抛出NullPointerException异常。

遍历List

和数组类型类似，我们要遍历一个List，完全可以用for循环根据索引配合get(int)方法遍历：

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("apple", "pear", "banana");
        for (int i=0; i<list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
    }
}

但这种方式并不推荐，一是代码复杂，二是因为get(int)方法只有ArrayList的实现是高效的，换成LinkedList后，索引越大，访问速度越慢。

terator对象有两个方法：boolean hasNext()判断是否有下一个元素，E next()返回下一个元素。因此，使用Iterator遍历List代码如下：

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

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("apple", "pear", "banana");
        for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

有童鞋可能觉得使用Iterator访问List的代码比使用索引更复杂。但是，要记住，通过Iterator遍历List永远是最高效的方式。并且，由于Iterator遍历是如此常用，所以，Java的for each循环本身就可以帮我们使用Iterator遍历。把上面的代码再改写如下：

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("apple", "pear", "banana");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

上述代码就是我们编写遍历List的常见代码。

实际上，只要实现了Iterable接口的集合类都可以直接用for each循环来遍历，Java编译器本身并不知道如何遍历集合对象，但它会自动把for each循环变成Iterator的调用，原因就在于Iterable接口定义了一个Iterator<E> iterator()方法，强迫集合类必须返回一个Iterator实例。

List和Array转换

把List变为Array有三种方法，第一种是调用toArray()方法直接返回一个Object[]数组：

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("apple", "pear", "banana");
        Object[] array = list.toArray();
        for (Object s : array) {
            System.out.println(s);
        }
    }

这种方法会丢失类型信息，所以实际应用很少。 

第二种方式是给toArray(T[])传入一个类型相同的Array，List内部自动把元素复制到传入的Array中：

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = List.of(12, 34, 56);
        Integer[] array = list.toArray(new Integer[3]);
        for (Integer n : array) {
            System.out.println(n);
        }
    }
}

注意到这个toArray(T[])方法的泛型参数<T>并不是List接口定义的泛型参数<E>，所以，我们实际上可以传入其他类型的数组，例如我们传入Number类型的数组，返回的仍然是Number类型：

 Number[] array = list.toArray(new Number[3]);
        for (Number n : array) {
            System.out.println(n);
        }

如果传入的数组不够大，那么List内部会创建一个新的刚好够大的数组，填充后返回；如果传入的数组比List元素还要多，那么填充完元素后，剩下的数组元素一律填充null。

实际上，最常用的是传入一个“恰好”大小的数组：

Integer[] array = list.toArray(new Integer[list.size()]);

最后一种更简洁的写法是通过List接口定义的T[] toArray(IntFunction<T[]> generator)方法：

Integer[] array = list.toArray(Integer[]::new);

把Array变为List就简单多了，通过List.of(T...)方法最简单：

Integer[] array = { 1, 2, 3 };
List<Integer> list = List.of(array);

对于JDK 11之前的版本，可以使用Arrays.asList(T...)方法把数组转换成List。

要注意的是，返回的List不一定就是ArrayList或者LinkedList，因为List只是一个接口，如果我们调用List.of()，它返回的是一个只读List：

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = List.of(12, 34, 56);
        list.add(999); // UnsupportedOperationException
    }
}

对只读List调用add()、remove()方法会抛出UnsupportedOperationException。

Integer[] array3 = { 1, 2, 3 };

List<Integer> list4 = Arrays.asList(array3);

for(Integer m: list4)

{

System.out.println(m);

}

List是按索引顺序访问的长度可变的有序表，优先使用ArrayList而不是LinkedList；

可以直接使用for each遍历List；

List可以和Array相互转换。

给定一组连续的整数，例如：10，11，12，……，20，但其中缺失一个数字，试找出缺失的数字：

package hello;
import java.util.*;
public class listhomework {



	public static void main(String[] args) {
		// 构造从start到end的序列：
		final int start = 10;
		final int end = 20;
		List<Integer> list = new ArrayList<>();
		for (int i = start; i <= end; i++) {
			list.add(i);
		}
		// 随机删除List中的一个元素:
		int removed = list.remove((int) (Math.random() * list.size()));
		int found = findMissingNumber(start, end, list);
		System.out.println(list.toString());
		System.out.println("missing number: " + found);
		System.out.println(removed == found ? "测试成功" : "测试失败");
	}

	static int findMissingNumber(int start, int end, List<Integer> list) {
		for(Integer i:  list)
		{
			if(!i.equals(start) )
			{
				return start;
			}else{
				start ++;
			}
		}
		return 0;
	}
}

无序版本

package hello;
import java.util.*;
public class listhomeworksort {
	public static void main(String[] args) {
        // 构造从start到end的序列：
        final int start = 10;
        final int end = 20;
        List<Integer> list = new ArrayList<>();
        for (int i = start; i <= end; i++) {
            list.add(i);
        }
        // 洗牌算法shuffle可以随机交换List中的元素位置:
        Collections.shuffle(list);
        // 随机删除List中的一个元素:
        int removed = list.remove((int) (Math.random() * list.size()));
        int found = findMissingNumber(start, end, list);
        System.out.println(list.toString());
        System.out.println("missing number: " + found);
        System.out.println(removed == found ? "测试成功" : "测试失败");
    }

    static int findMissingNumber(int start, int end, List<Integer> list) {
    	 for (int i = start; i <= end; i++)
    	 {
    		if( !list.contains(i))
    		{
    			return i;
    		}
    		 
    	 }
        return 0;
    }
}

编写equals方法 

List还提供了boolean contains(Object o)方法来判断List是否包含某个指定元素。此外，int indexOf(Object o)方法可以返回某个元素的索引，如果元素不存在，就返回-1。

这里我们注意一个问题，我们往List中添加的"C"和调用contains("C")传入的"C"是不是同一个实例？

如果这两个"C"不是同一个实例，这段代码是否还能得到正确的结果？我们可以改写一下代码测试一下：

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("A", "B", "C");
        System.out.println(list.contains(new String("C"))); // true or false?
        System.out.println(list.indexOf(new String("C"))); // 2 or -1?
    }
}

因为我们传入的是new String("C")，所以一定是不同的实例。结果仍然符合预期，这是为什么呢？

因为List内部并不是通过==判断两个元素是否相等，而是使用equals()方法判断两个元素是否相等，例如contains()方法可以实现如下：

public class ArrayList {
    Object[] elementData;
    public boolean contains(Object o) {
        for (int i = 0; i < elementData.length; i++) {
            if (o.equals(elementData[i])) {
                return true;
            }
        }
        return false;
    }
}

因此，要正确使用List的contains()、indexOf()这些方法，放入的实例必须正确覆写equals()方法，否则，放进去的实例，查找不到。我们之所以能正常放入String、Integer这些对象，是因为Java标准库定义的这些类已经正确实现了equals()方法。

我们以Person对象为例，测试一下：

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Person> list = List.of(
            new Person("Xiao Ming"),
            new Person("Xiao Hong"),
            new Person("Bob")
        );
        System.out.println(list.contains(new Person("Bob"))); // false
    }
}

class Person {
    String name;
    public Person(String name) {
        this.name = name;
    }
}

不出意外，虽然放入了new Person("Bob")，但是用另一个new Person("Bob")查询不到，原因就是Person类没有覆写equals()方法。

编写equals

equals()方法要求我们必须满足以下条件：

  • 自反性（Reflexive）：对于非null的x来说，x.equals(x)必须返回true；
  • 对称性（Symmetric）：对于非null的x和y来说，如果x.equals(y)为true，则y.equals(x)也必须为true；
  • 传递性（Transitive）：对于非null的x、y和z来说，如果x.equals(y)为true，y.equals(z)也为true，那么x.equals(z)也必须为true；
  • 一致性（Consistent）：对于非null的x和y来说，只要x和y状态不变，则x.equals(y)总是一致地返回true或者false；
  • 对null的比较：即x.equals(null)永远返回false。

如果Person有好几个引用类型的字段，上面的写法就太复杂了。要简化引用类型的比较，我们使用Objects.equals()静态方法：

public boolean equals(Object o) {
    if (o instanceof Person p) {
        return Objects.equals(this.name, p.name) && this.age == p.age;
    }
    return false;
}

因此，我们总结一下equals()方法的正确编写方法：

  1. 先确定实例“相等”的逻辑，即哪些字段相等，就认为实例相等；
  2. 用instanceof判断传入的待比较的Object是不是当前类型，如果是，继续比较，否则，返回false；
  3. 对引用类型用Objects.equals()比较，对基本类型直接用==比较。

使用Objects.equals()比较两个引用类型是否相等的目的是省去了判断null的麻烦。两个引用类型都是null时它们也是相等的。

如果不调用List的contains()、indexOf()这些方法，那么放入的元素就不需要实现equals()方法。

在List中查找元素时，List的实现类通过元素的equals()方法比较两个元素是否相等，因此，放入的元素必须正确覆写equals()方法，Java标准库提供的String、Integer等已经覆写了equals()方法；

编写equals()方法可借助Objects.equals()判断。

如果不在List中查找元素，就不必覆写equals()方法。

萝卜123abc
关注
Java——列表（List）
tm1560000的博客
02-19 2329
List 是 Java 集合框架中的一种接口，继承自 Collection 接口。添加元素：add(E e)、add(int index, E element)删除元素：remove(Object o)、remove(int index)获取元素：get(int index)修改元素：set(int index, E element)查找元素：indexOf(Object o)、lastIndexOf(Object o)获取列表大小：size()
Java集合-List
棉花糖老丫
04-15 1870
1、ArrayList 是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。 2、LinkedList 是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快 问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。
JAVA集合（含List、Map、Set）（超详细版）
热门推荐
rc1596919047的博客
06-09 1万+
java集合可分为Set、List、Queue和Map四种体系。set代表无序、不可重复的集合List代表有序、重复的集合而Map则代表具有映射关系的集合Queue代表一种队列集合实现Java集合就像是一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从Java5 增加了泛型以后，Java集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。2.集合和数组的区别长度区别：数组的长度固定，而集合长度可变。
java集合基础
weixin_46532327的博客
12-16 719
Java的java.utilListStudentListSetStudentSetMapStudentnameStudentMapJava的集合类定义在java.util包中，支持泛型，主要提供了3种集合类，包括ListSet和Map。Java集合使用统一的Iterator遍历，尽量不要使用遗留接口。ListArrayList在内部使用了数组来存储所有元素。例如，一个ArrayList拥有5个元素，实际数组大小为6当添加一个元素并指定索引到ArrayList时，ArrayList。
JAVA List用法
古语云
05-23 727
1、List中可以添加任何对象，包括自己定义的新的类。 class Person{ ..... } 上面定义了一个Person类，下面看好如何使用List Person p1=new Person(); Person p2=new Person(); List list=new ArrayList(); list.add(p1); list.add(p2);/
Java集合之List(超详细)
epitomizelu的专栏
06-06 1万+
for-each循环：简洁易读，最适合日常使用。Iterator：提供了更多的控制权，比如在遍历时移除元素，但在大多数情况下不如for-each方便。Stream API：功能强大，支持复杂的集合处理和并行处理，适合进行复杂的聚合操作和过滤操作。
Java中List详解
weixin_34148508的博客
10-02 813
List是Java中比较常用的集合类，关于List接口有很多实现类，本文就来简单介绍下其中几个重点的实现ArrayList、LinkedList和Vector之间的关系和区别。 List List 是一个接口，它继承于Collection的接口。它代表着有序的队列。当我们讨论List的时候，一般都和Set作比较。List中元素可以重复，并且是有序的(这里的有序指的是按照放入的顺序进行存储。如按...
Java 6-6 jmu-Java-05集合-List中指定元素的删除 (15分)
inooll的博客
11-19 1472
编写以下两个函数 /*以空格(单个或多个)为分隔符，将line中的元素抽取出来，放入一个List*/ public static List<String> convertStringToList(String line) /*在list中移除掉与str内容相同的元素*/ public static void remove(List<String> list, String str) 裁判测试程序： public class Main { /*covnertString
6-1 jmu-Java-05集合-List中指定元素的删除 (20分)
sddfnsff的博客
05-26 3637
编写以下两个函数 /以空格(单个或多个)为分隔符，将line中的元素抽取出来，放入一个List/ public static List convertStringToList(String line) /在list中移除掉与str内容相同的元素/ public static void remove(List list, String str) 裁判测试程序： *public class Main { /covnertStringToList函数代码/ 加粗样式 /remove函数代码/ public
java8集合源码-Java-Android-Framework-List:所有java框架列表
06-04
java8集合源码Java-Android-Framework-List 所有java框架列表 很棒的 Java [![很棒] Java 框架、库和软件。 内容 项目 豆映射 简化 bean 映射的框架。 - 为类型安全域模型验证和映射提供流畅的 API。 它使用注释、...
6-2 jmu-Java-05集合-List中指定元素的删除 (15分)
一只小菜鸡
11-23 1583
编写以下两个函数 /*以空格(单个或多个)为分隔符，将line中的元素抽取出来，放入一个List*/ public static List<String> convertStringToList(String line) /*在list中移除掉与str内容相同的元素*/ public static void remove(List<String> list, String str) 裁判测试程序： public class Main { /*covnertStringT
java有序列表
weixin_30342209的博客
09-08 1645
关于有序和无序的定义： 有序：有序列表中的元素具有某种内在的关联，这种关联定义了列表之间的顺序 无序：无序列表中的元素按使用者所选择得任意方式排序 索引：索引列表为他的元素维护一段连续的数字索引值 有序列表： List HashTable TreeMap 无序列表 HashMap Set 测试代码： package com.nps.base.xue...
java List
bobo的博客
01-23 149
###15.01_集合框架(去除ArrayList中重复字符串元素方式)(掌握) * A:案例演示      * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)      * 思路：创建新集合方式 案例:   @SuppressWarnings({ "rawtypes", "unchecked" }) public class Demo1_ArrayList {...
java当中的list集合
最新发布
开往1982的博客
03-23 1181
java当中的list集合
java 有序的list_Java 中的 List —— 有序序列
weixin_39839018的博客
02-15 5127
List 在 java 中是个有序序列：一、容量ArrayList 中有一个容量概念，表示基础数组的大小(无参时默认为 10)。在需要的时候(比如 add操作)会自动增加其容量。LinkedList 没有这个概念。TreeMap 也有容量，默认是 16.二、改善的 search 方法LinkedList 与 ArrayList 都很低效。比如 Collection 的 contain 和 remo...
Java中的List集合
qq_41571224的博客
12-19 1万+
List2.1 List集合概述和特点2.2List集合特有方法案例：List集合存储学生对象并遍历2.3并发修改异常 2.1 List集合概述和特点 public interface List<E> extends Collection<E> ~List有序集合也称为序列。该界面的用户可以精确的控制列表中每个元素的插入位置。用户可以通过整数索引访问元素。并搜索列表中的元素。 ~与Set集合不同，列表通常允许重复元素。 List集合特点： 有序：存储和取出的元素顺序一致； 可重复：
java list...用法_Java------list用法
weixin_33601504的博客
02-24 121
定义list并将数组放入其中：List temp = new ArrayList()；List temp = new ArrayList()；获得集合内元素个数：list.size();添加元素：默认添加：list.add(e);指定下标添加(添加后下标后的元素向后挪一位)：list.add(index,e);如果我们得到的List还想要增删，那么可以用addAll方法String[] str =...
Java基础之List
qq_45344586的博客
04-08 3256
Java基础之List
Java List集合与迭代器实战教程
List集合是Java集合框架的一部分，它是一个有序的、允许重复元素的集合。常见的List实现有ArrayList和LinkedList。以下是List的一些常用操作： 1. **添加元素**：使用`add()`方法可以在List末尾添加元素，`add...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值