百度360必应搜狗淘宝本站头条
nodejsbufferorg.jsoupsetnocountoncv2.bitwise_nottime.strptime
当前位置：网站首页 > 编程字典 > 正文

学习廖雪峰的JAVA教程---集合(使用List、List和Array转换)

toyiye 2024-09-03 01:13 5 浏览 0 评论

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

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

数组和List类似，也是有序结构，如果我们使用数组，在添加和删除元素的时候，会非常不方便。例如，从一个已有的数组{'A', 'B', 'C', 'D', 'E'}中删除索引为2的元素：

┌───┬───┬───┬───┬───┬───┐
│ A │ B │ C │ D │ E │ │
└───┴───┴───┴───┴───┴───┘
 │ │
 ┌───┘ │
 │ ┌───┘
 │ │
 ▼ ▼
┌───┬───┬───┬───┬───┬───┐
│ A │ B │ D │ E │ │ │
└───┴───┴───┴───┴───┴───┘

这个“删除”操作实际上是把'C'后面的元素依次往前挪一个位置，而“添加”操作实际上是把指定位置以后的元素都依次向后挪一个位置，腾出来的位置给新加的元素。这两种操作，用数组实现非常麻烦。

因此，在实际应用中，需要增删元素的有序列表，我们使用最多的是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>接口，可以看到几个主要的接口方法：

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

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

 ┌───┬───┐ ┌───┬───┐ ┌───┬───┐ ┌───┬───┐
HEAD ──>│ A │ ●─┼──>│ B │ ●─┼──>│ C │ ●─┼──>│ D │ │
 └───┴───┘ └───┴───┘ └───┴───┘ └───┴───┘

我们来比较一下ArrayList和LinkedList：

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

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

List的特点

使用List时，我们要关注List接口的规范。List接口允许我们添加重复的元素，即List内部的元素可以重复：

import java.util.ArrayList;

import java.util.List;

public class Main {

public static void main(String[] args) {

List<String> list = new ArrayList<>();

list.add("apple"); // size=1

list.add("pear"); // size=2

list.add("apple"); // 允许重复添加元素，size=3

System.out.println(list.size());

}

}

List还允许添加null：

import java.util.ArrayList;
import java.util.List;
public class Main {
 public static void main(String[] args) {
 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);
 }
}

创建List

除了使用ArrayList和LinkedList，我们还可以通过List接口提供的of()方法，根据给定元素快速创建List：

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后，索引越大，访问速度越慢。

所以我们要始终坚持使用迭代器Iterator来访问List。Iterator本身也是一个对象，但它是由List的实例调用iterator()方法的时候创建的。Iterator对象知道如何遍历一个List，并且不同的List类型，返回的Iterator对象实现也是不同的，但总是具有最高的访问效率。

Iterator对象有两个方法：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的常见代码。

实际上，只要实现了Iterator接口的集合类都可以直接用for each循环来遍历，Java编译器本身并不知道如何遍历集合对象，但它会自动把for each循环变成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类型：

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

但是，如果我们传入类型不匹配的数组，例如，String[]类型的数组，由于List的元素是Integer，所以无法放入String数组，这个方法会抛出ArrayStoreException。

如果我们传入的数组大小和List实际的元素个数不一致怎么办？根据List接口的文档，我们可以知道：

如果传入的数组不够大，那么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。

import java.util.*;
public class Main {
 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);
 }
 // 洗牌算法suffle可以随机交换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) {
		 int result = 10;
		 int key = 1;
		for(int i = start; i<=end; i++){
			result = i;
			key = 1;
 for(int f : list){
 if(i!=f){
 continue;
						}else {
							key = 0;
							break;
						}
 }
 if(key == 1) {
 	 break;
 }
		 }
		return result;
 }
}

小结

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

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

List可以和Array相互转换。

【关键：

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

  • 在末尾添加一个元素：void add(E e)
  • 在指定索引添加一个元素：void add(int index, E e)
  • 删除指定索引的元素：int remove(int index)
  • 删除某个元素：int remove(Object e)
  • 获取指定索引的元素：E get(int index)
  • 获取链表大小（包含元素的个数）：int size()
  1. 除了使用ArrayList和LinkedList，我们还可以通过List接口提供的of()方法，根据给定元素快速创建List
  2. List还允许添加null；允许我们添加重复的元素
  3. List.of()方法不接受null值
  4. 坚持使用迭代器Iterator来访问List，通过Iterator遍历List永远是最高效的方式
  5. 实际上，只要实现了Iterator接口的集合类都可以直接用for each循环来遍历，Java编译器本身并不知道如何遍历集合对象，但它会自动把for each循环变成Iterator的调用

】

相关推荐

# Python 3 # Python 3字典Dictionary(1)

Python3字典字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中,格式如...

Python第八课:数据类型中的字典及其函数与方法

Python3字典字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值...

Python中字典详解（python 中字典）

字典是Python中使用键进行索引的重要数据结构。它们是无序的项序列(键值对)，这意味着顺序不被保留。键是不可变的。与列表一样，字典的值可以保存异构数据，即整数、浮点、字符串、NaN、布尔值、列表、数...

Python3.9又更新了:dict内置新功能，正式版十月见面

机器之心报道参与：一鸣、JaminPython3.8的热乎劲还没过去，Python就又双叒叕要更新了。近日，3.9版本的第四个alpha版已经开源。从文档中，我们可以看到官方透露的对dic...

Python3 基本数据类型详解（python三种基本数据类型）

文章来源：加米谷大数据Python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在Python中，变量就是变量，它没有类型，我们所说的"类型"是变...

一文掌握Python的字典（python字典用法大全）

字典是Python中最强大、最灵活的内置数据结构之一。它们允许存储键值对，从而实现高效的数据检索、操作和组织。本文深入探讨了字典，涵盖了它们的创建、操作和高级用法，以帮助中级Python开发...

超级完整|Python字典详解（python字典的方法或操作）

一、字典概述01字典的格式Python字典是一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型。字典的每个键值key=>value对用冒号:分割，每个对之间用逗号,...

Python3.9版本新特性:字典合并操作的详细解读

处于测试阶段的Python3.9版本中有一个新特性：我们在使用Python字典时，将能够编写出更可读、更紧凑的代码啦！Python版本你现在使用哪种版本的Python？3.7分？3.5分？还是2.7...

python 自学，字典3(一些例子)（python字典有哪些基本操作）

例子11；如何批量复制字典里的内容2；如何批量修改字典的内容3；如何批量修改字典里某些指定的内容...

Python3.9中的字典合并和更新，几乎影响了所有Python程序员

全文共2837字，预计学习时长9分钟Python3.9正在积极开发，并计划于今年10月发布。2月26日，开发团队发布了alpha4版本。该版本引入了新的合并(|)和更新(|=)运算符，这个新特性几乎...

Python3大字典:《Python3自学速查手册.pdf》限时下载中

最近有人会想了，2022了，想学Python晚不晚，学习python有前途吗？IT行业行业薪资高，发展前景好，是很多求职群里严重的香饽饽，而要进入这个高薪行业，也不是那么轻而易举的，拿信工专业的大学生...

python学习——字典（python字典基本操作）

字典Python的字典数据类型是基于hash散列算法实现的，采用键值对(key:value)的形式，根据key的值计算value的地址，具有非常快的查取和插入速度。但它是无序的，包含的元素个数不限，值...

324页清华教授撰写【Python 3 菜鸟查询手册】火了，小白入门字典

如何入门学习python...

Python3.9中的字典合并和更新，了解一下

全文共2837字，预计学习时长9分钟Python3.9正在积极开发，并计划于今年10月发布。2月26日，开发团队发布了alpha4版本。该版本引入了新的合并(|)和更新(|=)运算符，这个新特性几乎...

python3基础之字典（python中字典的基本操作）

字典和列表一样，也是python内置的一种数据结构。字典的结构如下图:列表用中括号[]把元素包起来，而字典是用大括号{}把元素包起来，只不过字典的每一个元素都包含键和值两部分。键和值是一一对应的...

取消回复欢迎 你 发表评论:

请填写验证码
一周热门
最近发表
标签列表