Java 集合之List接口 方法 遍历

Java 集合之List接口

• 有序collection（也称为序列）。 此接口的用户可以对列表中每个元素的插入位置进行精确地控制。 用户可以通过它们的整数索引（在列表中的位置）访问元素，并在列表中搜索元素。

• 与set不同，列表通常允许重复元素。 更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。 难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。

• List 接口对iterator、add、remove、equals 和 hashCode 方法的协定上进行了额外的规定，超出了 Collection 接口中指定的规定。 为方便起见，此处还包括其他继承方法的声明。

• List 接口提供了四种对列表元素进行位置（索引）访问的方法。 列表（如 Java 数组）是从零开始的。 请注意，对于某些实现（例如 LinkedList 类），这些操作的执行时间可能与索引值成正比。 因此，如果调用者不知道实现，那么在列表元素上迭代通常优于用索引遍历列表。

• List 接口提供了一个特殊的迭代器，称为 ListIterator，除了 Iterator 接口提供的正常操作之外，它还允许元素插入和替换以及双向访问。 还提供了一种方法来获取从列表中的指定位置开始的列表迭代器。

• List 接口提供了两种方法来搜索指定的对象。 从性能的角度来看，应谨慎使用这些方法。 在许多实现中，它们将执行代价高昂的线性搜索。

• List 接口提供了两种方法来有效地在列表中的任意点插入和删除多个元素。

• 注意：虽然允许列表将自身包含为元素，但建议格外小心：equals 和 hashCode 方法不再在此类列表上明确定义。

• 一些列表实现对它们可能包含的元素有限制。 例如，有些实现禁止null元素，有些实现对其元素的类型有限制。

  • 尝试添加不合格的元素会引发未经检查的异常，通常为 NullPointerException 或 ClassCastException。
  • 尝试查询不合格元素的存在可能会引发异常，或者可能只是返回 false
  • 概括地说，尝试对不合格元素执行操作，如果完成该操作后不会导致在列表中插入不合格的元素，则该操作可能抛出一个异常，也可能成功，这取决于实现的选择。此接口的规范中将这样的异常标记为“可选”。

• Unmodifiable Lists不可修改列表， List.of（9新增） 和 List.copyOf（10新增） 静态工厂方法提供了一种创建不可修改列表的便捷方法。 这些方法创建的 List 实例具有以下特点：

  • 它们是不可修改的。 不能添加、删除或替换元素。
  • 调用 List 上的任何 mutator 方法将始终导致抛出 UnsupportedOperationException。
  • 但是，如果包含的元素本身是可变的，这可能会导致 List 的内容发生变化。

方法

Modifier and Type	Method	Description
boolean	add(E e)	将指定的元素追加到此列表的末尾（可选操作）。
void	add(int index, E element)	将指定的元素插入此列表中的指定位置（可选操作）。
boolean	addAll(Collection<? extends E> c)	添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extends E> c)	将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear()	从此列表中删除所有元素（可选操作）。
boolean	contains(Object o)	如果此列表包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c)	如果列表包含指定 collection 的所有元素，则返回 true。
static <E> List<E>	copyOf(Collection<? extends E> coll)	返回一个不可修改的 List，其中包含给定 Collection 的元素，按其迭代顺序。
boolean	equals(Object o)	比较指定的对象与列表是否相等。
E	get(int index)	返回此列表中指定位置的元素。
int	hashCode()	返回此列表的哈希码值。
int	indexOf(Object o)	返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
boolean	isEmpty()	如果此列表不包含元素，则返回 true 。
Iterator<E>	iterator()	以正确的顺序返回该列表中的元素的迭代器。
int	lastIndexOf(Object o)	返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator<E>	listIterator()	返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E>	listIterator(int index)	返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
static <E> List<E>	of()	返回包含零个元素的不可修改列表。
static <E> List<E>	of(E... elements)	返回包含任意数量元素的不可修改列表。
static <E> List<E>	of(E e1, E e2,){1~10}	返回包含1~10个（具体取决于定义的E ei的个数）元素的不可修改列表。
E	remove(int index)	删除该列表中指定位置的元素（可选操作）。
boolean	remove(Object o)	从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c)	从列表中移除指定 collection 中包含的其所有元素（可选操作）。
default void	replaceAll(UnaryOperator<E> operator)	用将运算符应用于该元素的结果替换此列表的每个元素。
boolean	retainAll(Collection<?> c)	仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element)	用指定的元素替换此列表中指定位置的元素（可选操作）。
int	size()	返回此列表中的元素数。
default void	sort(Comparator<? super E> c)	根据由指定的 Comparator 得出的顺序对此列表进行排序。
default Spliterator<E>	spliterator()	在此列表中的元素上创建一个 Spliterator。
List<E>	subList(int fromIndex, int toIndex)	返回此列表中指定的 fromIndex （含）和 toIndex（不含）之间的视图。
Object[]	toArray()	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）。
<T> T[]	toArray(T[] a)	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。

常用方法

均与索引有关，也是列表的一个特点

增加

• void add(int index, E element)在列表的指定位置插入指定元素（可选操作）。
  • index - 要在其中插入指定元素处的索引，element - 要插入的元素
  • 将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。

删除

• E remove(int index)移除列表中指定位置的元素（可选操作）。

  • index - 要移除的元素的索引
  • 将所有的后续元素向左移动（将其索引减 1）。返回从列表中移除的元素。

• boolean remove(Object o)从此列表中移除第一次出现的指定元素o（如果存在）（可选操作）。

  • 如果列表不包含元素，则不更改列表。更确切地讲，移除满足(o==null ? get(i)==null : o.equals(get(i)))的最低索引 i 的元素（如果存在这样的元素）。
  • 如果此列表已包含指定元素（或者此列表由于调用而发生更改），则返回 true。
  • Specified by:接口 Collection 中的 remove

修改

• E set(int index, E element)用指定元素替换列表中指定位置的元素（可选操作）。
  • index - 要替换的元素的索引，element - 要在指定位置存储的元素
  • 返回以前在指定位置的元素

查看

• E get(int index)返回列表中指定位置的元素。
  • index - 要返回的元素的索引

List list = new ArrayList();
list.add(2);
list.add(8);
list.add(9.2);
list.add(true);
list.add("abc");
System.out.println(list); //[2, 8, 9.2, true, abc]

list.add(1,66);
System.out.println(list); //[2, 66, 8, 9.2, true, abc]

list.set(1,6);
System.out.println(list); //[2, 6, 8, 9.2, true, abc]

list.remove(2);//在集合中存入的是Integer类型数据的时候，调用remove方法调用的是：remove(int index)
System.out.println(list); //[2, 6, 9.2, true, abc]

list.remove("abc");
System.out.println(list); //[2, 6, 9.2, true]

Object o = list.get(0);
System.out.println(o); //2

遍历方法

public class Meth {
    
    
    public static void main(String[] args) {
    
    
        List list = new ArrayList();
        list.add(2);
        list.add(8);
        list.add(9.2);
        list.add(true);
        list.add("abc");
        System.out.println(list);
        //List集合遍历：
        //方式1：普通for循环：
        System.out.println("-------普通for循环-------");
        for(int i = 0;i<list.size();i++){
    
    
            System.out.print(list.get(i) + "\t");
        }
        //方式2：增强for循环：
        System.out.println("\n-------增强for循环-------");
        for(Object obj:list){
    
    
            System.out.print(obj + "\t");
        }
        //方式3：迭代器：
        System.out.println("\n-------迭代器-------");
        Iterator it = list.iterator();
        while(it.hasNext()){
    
    
            System.out.print(it.next() + "\t");
        }
    }
}