Java 列表

Java 列表是一个有序的集合。Java 列表是一个扩展 Collection 界面的界面。Java 列表提供对您可以插入元素位置的控制。

关于Java列表的一些重要点是;

Java 列表接口是 Java 收藏框架的一员 *列表允许你添加重复元素 *列表允许你有null元素 *列表接口在 Java 8 中获得了许多默认方法,例如取代All、 Sort 和 Spliterator *列表索引从 0 开始,就像列表 *列表支持通用,我们应该随时使用它。

Java 列表类图表

Java List interface extends Collection interface. Collection interface externs Iterable interface. Some of the most used List implementation classes are ArrayList, LinkedList, Vector, Stack, CopyOnWriteArrayList. AbstractList provides a skeletal implementation of the List interface to reduce the effort in implementing List.

Java 列表方法

一些有用的Java列表方法是;

**int大小 () **: 获取列表中的元素数.
**boolean isEmpty () **: 检查列表是否为空.
** boolean 含有(o)**: 如果此列表包含指定的元素, 返回真实性。
** Iterator Experator () ** : 以适当的顺序返回此列表中的元素的浏览器。 5。 ** 对象到箭头 () : 以适当的顺序返回包含此列表中所有元素的数组 6 。 ** boolean 添加(E): 将指定元素添加到此列表的末尾。 (_) (英语). 7. 布尔去除(对象o): 从此列表中删除指定的元素的首次出现。
** 布尔保留全部( 收集 <? > ) (c) **: 仅保留此列表中包含在指定收藏中的元素.
** 明确(): 删除列表中的所有元素( ) )10 (英语). E 获得(指数): 返回列表中指定位置的元素。 () )11 (英语). ** Eset(指数,E元素): 将列表中指定位置的元素替换为指定元素. () )12 (英语). ** 列表编辑器列表编辑器()**: 返回列表对列表中元素的浏览器。 () )13 (英语). ** 列表子列表( 从Index 中插入到Index) ** : 返回从 Index(包含)到toIndex(独家)之间指定部分的视图。返回的列表由这个列表支持,所以返回列表中的非结构变化在本列表中反映,反之亦然. ( (英语)

Java 8 中的列表中添加的一些默认方法是;

default void replaceAll(UnaryOperator操作员):用将操作员应用于该元素的结果代替本列表中的每个元素
default void sort(Comparator c):根据指定的 Comparator 引发的顺序来排序此列表。

Java Array 列表

我们可以使用 Arrays 类来获取数组视图作为列表,但是我们将无法对列表进行任何结构性修改,它将丢弃 java.lang.UnsupportedOperationException,所以最好的方法是通过重复数组来创建列表。

 1package com.journaldev.examples;
 2
 3import java.util.ArrayList;
 4import java.util.Arrays;
 5import java.util.List;
 6
 7public class ArrayToList {
 8
 9    public static void main(String[] args) {
10    	
11    	String[] vowels = {"a","e","i","o","u"};
12    	
13    	List<String> vowelsList = Arrays.asList(vowels);
14    	System.out.println(vowelsList);
15    	
16    	/**
17    	 * List is backed by array, we can't do structural modification
18    	 * Both of the below statements will throw java.lang.UnsupportedOperationException
19    	 */
20    	//vowelsList.remove("e");
21    	//vowelsList.clear();
22    			
23    	//using for loop to copy elements from array to list, safe for modification of list
24    	List<String> myList = new ArrayList<>();
25    	for(String s : vowels){
26    		myList.add(s);
27    	}
28    	System.out.println(myList);
29    	myList.clear();
30    }
31
32}

根据您的项目要求,选择上述任何方法。

Java 列表到 Array

一个简单的示例,显示将列表转换为数组的正确方法。

 1package com.journaldev.examples;
 2
 3import java.util.ArrayList;
 4import java.util.Arrays;
 5import java.util.List;
 6
 7public class ListToArray {
 8
 9    public static void main(String[] args) {
10
11    	List<String> letters = new ArrayList<String>();
12
13    	// add example
14    	letters.add("A");
15    	letters.add("B");
16    	letters.add("C");
17    	
18    	//convert list to array
19    	String[] strArray = new String[letters.size()];
20    	strArray = letters.toArray(strArray);
21    	System.out.println(Arrays.toString(strArray)); //will print "[A, B, C]"
22    }
23
24}

java 清单

我们可以使用 Collections 类用于自然排序,或者我们可以使用 List sort() 方法,并使用我们自己的比较器进行排序。

 1package com.journaldev.examples;
 2
 3import java.util.ArrayList;
 4import java.util.Collections;
 5import java.util.List;
 6import java.util.Random;
 7
 8public class ListSortExample {
 9
10    public static void main(String[] args) {
11    	
12    	List<Integer> ints = new ArrayList<>();
13    	Random random = new Random();
14    	for (int i = 0; i < 10; i++) ints.add(random.nextInt(1000));
15    	
16    	//natural sorting using Collections class
17    	Collections.sort(ints);
18    	System.out.println("Natural Sorting: "+ints);
19    	
20    	//My custom sorting, reverse order
21    	ints.sort((o1,o2) -> {return (o2-o1);});
22    	System.out.println("Reverse Sorting: "+ints);
23    }
24}

由于我正在使用随机生成列表元素,每次都会有所不同。

1Natural Sorting: [119, 273, 388, 450, 519, 672, 687, 801, 812, 939]
2Reverse Sorting: [939, 812, 801, 687, 672, 519, 450, 388, 273, 119]

Java 常见操作列表

在 java 列表中执行的最常见操作是添加、删除、设置、清除、大小等下面是一个简单的 java 列表示例,展示了常见方法的使用。

 1package com.journaldev.examples;
 2
 3import java.util.ArrayList;
 4import java.util.Arrays;
 5import java.util.List;
 6
 7public class ListExample {
 8
 9    public static void main(String args[]) {
10    	List<String> vowels= new ArrayList<String>();
11    	
12    	//add example
13    	vowels.add("A");
14    	vowels.add("I");
15    	
16    	//let's insert E between A and I
17    	vowels.add(1,"E");
18    	System.out.println(vowels);
19    	
20    	List<String> list = new ArrayList<String>();
21    	list.add("O");list.add("U");
22    	
23    	//appending list elements to letters
24    	vowels.addAll(list);
25    	System.out.println(vowels);
26    	
27    	//clear example to empty the list
28    	list.clear();
29    	
30    	//size example
31    	System.out.println("letters list size = "+vowels.size());
32    	
33    	//set example
34    	vowels.set(2, "E");
35    	System.out.println(vowels);
36    	
37    	//subList example
38    	vowels.clear();vowels.add("E"); vowels.add("E");vowels.add("I"); vowels.add("O");
39    	list = vowels.subList(0, 2);
40    	System.out.println("letters = "+vowels+", list = "+list);
41    	vowels.set(0, "A");
42    	System.out.println("letters = "+vowels+", list = "+list);
43    	list.add("U");
44    	System.out.println("letters = "+vowels+", list = "+list);
45    	
46    	
47    }
48
49}

上面的Java列表示例程序的输出是;

1[A, E, I]
2[A, E, I, O, U]
3letters list size = 5
4[A, E, E, O, U]
5letters = [E, E, I, O], list = [E, E]
6letters = [A, E, I, O], list = [A, E]
7letters = [A, E, U, I, O], list = [A, E, U]

Java 列表迭代器

下面是一個簡單的例子,顯示如何在Java中重複列表。

 1package com.journaldev.examples;
 2
 3import java.util.ArrayList;
 4import java.util.Iterator;
 5import java.util.List;
 6
 7public class ListIteratorExample {
 8
 9    public static void main(String[] args) {
10
11    	List<Integer> list = new ArrayList<>();
12    	for(int i=0; i<5; i++) list.add(i);
13    	
14    	Iterator<Integer> iterator = list.iterator();
15    	
16    	//simple iteration
17    	while(iterator.hasNext()){
18    		int i = (int) iterator.next();
19    		System.out.print(i + ", ");
20    	}
21    	System.out.println("\n"+list);
22    	
23    	//modification of list using iterator
24    	iterator = list.iterator();
25    	while(iterator.hasNext()){
26    		int x = (int) iterator.next();
27    		if(x%2 ==0) iterator.remove();
28    	}
29    	System.out.println(list);
30    	
31    	//changing list structure while iterating
32    	iterator = list.iterator();
33    	while(iterator.hasNext()){
34    		int x = (int) iterator.next(); //ConcurrentModificationException here
35    		if(x==1) list.add(10);
36    	}
37    }
38
39}

上面的Java列表迭代程序的输出是;

10, 1, 2, 3, 4, 
2[0, 1, 2, 3, 4]
3[1, 3]
4Exception in thread "main" java.util.ConcurrentModificationException
5    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
6    at java.util.ArrayList$Itr.next(ArrayList.java:851)
7    at com.journaldev.examples.ListIteratorExample.main(ListIteratorExample.java:34)

我希望这些Java列表示例可以帮助你开始编程列表集合。