Core Java Tutorial -- List

本是古典何须时尚 2022-05-28 21:10 175阅读 0赞

Java List 是一个有序集合。Java List 是一个扩展 Collection 接口的接口。Java List 提供了对可以插入元素的位置的控制。你可以按索引访问元素，也可以在列表中搜索元素。

1.  Java List  
    
    
    1.  Java List Class Diagram  
        
        
        1.  Java List Methods
        2.  Java Array to List
        3.  Java List to Array
        4.  Java List sort
        5.  Java List Common Operations
        6.  Java List iterator

# 1. Java List #

关于 Java List 的一些重要观点有：

*  Java List 接口是 Java 集合框架的成员。
 *  List 允许你添加重复的元素。
 *  List 允许你有 null 元素。
 *  List 接口在 Java 8 中有许多默认方法，栗如 `replaceAll`、`sort` 和 `spliterator`
 *  List 索引从 0 开始，就像数组一样。
 *  List 支持泛型，我们应该尽可能使用它。在 List 中使用泛型将在运行时避免 `ClassCastException` 异常

## Java List Class Diagram ##

Java List 接口扩展了 Collection 接口。Collection 接口扩展了 Iterable 接口。一些最常用的 List 实现类有`ArrayList`、`LinkedList`、`Vector`、`Stack`、`CopyOnWriteArrayList`。`AbstractList` 提供了 List 接口的骨架实现，以减少 List 的工作量。

![java-list-diagram][]

## Java List Methods ##

Java List 一些有用的方法有：

1.  `int size()`：获取列表中元素的数量。
2.  `boolean isEmpty`：检查列表是否为空。
3.  `boolean contains(Object o)`：如果此列表包含指定㢝，则返回 true。
4.  `iterator<E> iterator()`：以适当的顺序返回此列表中元素的迭代器。
5.  `Object[] toArray()`：以适当的顺序放回包含此列表中所有元素的数组。
6.  `boolean add(E e)`：将指定元素追加到此列表的末尾。
7.  `boolean remove(Object o)`：从此列表中删除第一次出现的指定元素。
8.  `boolean retainAll(Collection<?> c)`：只保留包含在指定集合中的列表中的元素。
9.  `void clear()`：从列表中删除所有元素。
10. `E get(int index)`：返回列表中指定位置的元素
11. `E set(int index, E element)`：用指定的元素替换列表中指定位置的元素。
12. `ListIterator<E> listIterator()`：返回列表中元素的列表迭代器。
13. `List<E> subList(int fromIndex, int toIndex)`：返回指定的 fromIndex（包含）和toIndex（不包括）之间该列表部分的视图。返回的列表由此列表支持，因此返回列表中的非结构化更改将反映在此列表中，反之亦然。

Java 8 中添加到 List 的一些 default 方法：  
1. `default void replaceAll(UnaryOperator<E> operator)`：将运算符应用于该元素的结果替换此列表中的每个元素。  
2. `default void sort(Comparator<super E> c)`：根据指定比较器引发的顺序对此列表进行排序。  
3. `default Spliterator<E> spliterator()`：在此列表中的元素上创建一个 Spliterator。

## Java Array to List ##

我们可以使用 Array 类来获取了表的数组视图。但是，我们无法对列表进行任何结构修改，它会抛出`java.lang.UnsupportedOperationException` 异常。所以最好的方法是使用 for 循环通过遍历数组来创建列表。下面是一个简单的栗子，展示了如何将 [Java Array][] 正确转换为 List。

package List;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class ArrayToList { 
        public static void main(String[] args) {
            String[] vowels = {
       "a", "e", "i", "o", "u"};
    
            List<String> vowelsList = Arrays.asList(vowels);
    
            System.out.println(vowelsList);
    
            /** * List is backed by array, we can't do structural modification * Both of the below statements will throw java.lang.UnsupportedOperationException */
    
            //vowelsList.remove("e");
            //vowelsList.clear();
    
            //using for loop to copy elements from array to list, safe for modification of list
    
    
            List<String> myList = new ArrayList<>();
            for (String vowel : vowels) {
                myList.add(vowel);
            }
    
            System.out.println(myList);
    
            myList.clear();
        }
    }

根据你项目要求选择上述任何方法。

## Java List to Array ##

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

package List;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class ListToArray { 
        public static void main(String[] args) {
            List<String> letters = new ArrayList<>();
    
            // add example
            letters.add("A");
            letters.add("B");
            letters.add("C");
    
            // convert list to array
            String[] strArray = new String[letters.size()];
            strArray = letters.toArray(strArray);
            System.out.println(Arrays.toString(strArray));// will print "[A, B, C]"
        }
    }

## Java List sort ##

有两种方法可以对列表进行排序。我们可以使用集合类的自然排序，或者使用 List sort() 方法并使用我们自己的比较器进行排序。下面是 Java List 排序的一个简单栗子。

package List;
    
    import java.util.*;
    
    public class ListSortExample { 
        public static void main(String[] args) {
            List<Integer> integers = new ArrayList<>();
            Random random = new Random();
            for (int i = 0; i < 10; i++) {
                integers.add(random.nextInt(1000));
            }
    
            // natural sorting Collection class
            Collections.sort(integers);
            System.out.println("Natural Sorting: " + integers);
    
            // My custom soring, reverse order
            integers.sort((o1, o2) -> (o2 - o1)); /* integers.sort((o1, o2) -> { return (o2 - o1); });*/ System.out.println("Reverse Sorting: " + integers); } }

示例输出如下。由于我使用随机生成列表元素，它每次都会有所不同。

Natural Sorting: [109, 405, 446, 591, 676, 761, 801, 901, 935, 992]
    Reverse Sorting: [992, 935, 901, 801, 761, 676, 591, 446, 405, 109]

## Java List Common Operations ##

在 Java List 上执行的大多数常见操作是添加，删除，设置，清除，大小等。下面是一个简单的 Java List 示例，显示常见的方法用法。

package List;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ListExample {
        public static void main(String[] args) {
            List<String> vowels = new ArrayList<>();
    
            // add example
            vowels.add("A");
            vowels.add("I");
    
            // let's insert E between A and I
    
            vowels.add(1, "E");
            System.out.println(vowels);
    
    
            List<String> list = new ArrayList<>();
            list.add("O");
            list.add("U");
    
            // appending list elements to letters
            vowels.addAll(list);
            System.out.println(vowels);
    
            // clear example to empty the list
            list.clear();
    
            // seize example
            System.out.println("letters list size = " + vowels.size());
    
            // set example
            vowels.set(2, "E");
            System.out.println(vowels);
    
            // subList example
            vowels.clear();
            vowels.add("E");
            vowels.add("E");
            vowels.add("I");
            vowels.add("O");
            list = vowels.subList(0, 2);
            System.out.println("letters = " + vowels + ", list = " + list);
            vowels.set(0, "A");
            System.out.println("letters = " + vowels + ", list = " + list);
            list.add("U");
            System.out.println("letters = " + vowels + ", list = " + list);
        }
    }

输出结果如下：

[A, E, I]
    [A, E, I, O, U]
    letters list size = 5
    [A, E, E, O, U]
    letters = [E, E, I, O], list = [E, E]
    letters = [A, E, I, O], list = [A, E]
    letters = [A, E, U, I, O], list = [A, E, U]

## Java List iterator ##

下面是展示如何迭代 List 的栗子。

package List;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class ListIteratorExample {
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < 5; i++) {
                list.add(i);
            }
    
            Iterator<Integer> iterator = list.iterator();
    
    
            // simple iteration
            while (iterator.hasNext()) {
                int i = iterator.next();
                System.out.println(i + ", ");
            }
    
            System.out.println("\n" + list);
    
            // modification of using iterator
            iterator = list.iterator();
            while (iterator.hasNext()) {
                int x = iterator.next();
                if (x % 2 == 0) {
                    iterator.remove();
                }
            }
            System.out.println(list);
    
            // changing list structure while iterating
            iterator = list.iterator();
            while (iterator.hasNext()) {
                int x = iterator.next();
                if (x == 1) {
                    //ConcurrentModificationException here
                    list.add(10);
                }
            }
    
    
        }
    }

运行结果如下:

0, 1, 2, 3, 4, 
    [0, 1, 2, 3, 4]
    [1, 3]
    Exception in thread "main" java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
        at java.util.ArrayList$Itr.next(ArrayList.java:859)
        at List.ListIteratorExample.main(ListIteratorExample.java:38)

我希望这些 Java List 示例将帮助您开始使用 List 集合编程。

[java-list-diagram]: 
[Java Array]: https://www.journaldev.com/16851/java-array