java.util
接口 List<E>
所有超级接口:
Collection<E>, Iterable<E>
所有已知实现类:
AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector
List的概念:
有序的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。
List与Set不同,List允许重复的元素;List 接口提供了 4 种对列表元素进行定位(索引)访问方法;
List 接口提供了特殊的迭代器,称为 ListIterator,除了允许 Iterator 接口提供的正常操作外,该迭代器还允许元素插入和替换,以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。
几种数据结构的比较:
Array读取快,修改慢;
Linked修改快,读取慢;
Hash介于两者之间;
List的方法:
/*
*created by yangyinglong at 20180516
*List接口的学习
*/
import java.util.*;
public class ListTest {
public static void main(String[] args) {
List l1 = new LinkedList();
List l2 = new LinkedList();
List l3 = new ArrayList();
// boolean add(E e) 向列表的尾部添加指定的元素(可选操作)。
for (int i = 1; i <= 5; i ++ ) {
l1.add("a"+i);
}
System.out.println("循环添加元素到l1中,l1的值为: " + l1);
// void add(int index, E element) 在列表的指定位置插入指定元素(可选操作)。
l1.add(0, "a0");
System.out.println("在l1的第0个位置添加元素a0之后的l1为: " + l1);
// 循环添加元素到l1中,l1的值为: [a1, a2, a3, a4, a5]
// 在l1的第0个位置添加元素a0之后的l1为: [a0, a1, a2, a3, a4, a5]
// boolean addAll(Collection<? extends E> c)
// 添加指定 collection 中的所有元素到此列表的结尾,顺序是指定 collection 的迭代器返回这些元素的顺序(可选操作)。
l3.add("b0");
System.out.println("l3的值为: " + l3);
l3.addAll(l1);
System.out.println("l3中addAll(l1)之后的l3为: " + l3);
// l3的值为: [b0]
// l3中addAll(l1)之后的l3为: [b0, a0, a1, a2, a3, a4, a5]
// boolean addAll(int index, Collection<? extends E> c)
// 将指定 collection 中的所有元素都插入到列表中的指定位置(可选操作)。
l3.addAll(3, l1);
System.out.println("在l3中的第3个位置添加l1之后的l3为: " + l3);
// 在l3中的第3个位置添加l1之后的l3为: [b0, a0, a1, a0, a1, a2, a3, a4, a5, a2, a3, a4, a5]
// void clear() 从列表中移除所有元素(可选操作)。
l3.clear();
System.out.println("l3执行clear()方法之后为: " + l3);
// l3执行clear()方法之后为: []
// boolean contains(Object o) 如果列表包含指定的元素,则返回 true。
boolean is_contains_a1 = l1.contains("a1");
System.out.println("l1 是否包含 a1 元素: " + is_contains_a1);
// l1 是否包含 a1 元素: true
// boolean containsAll(Collection<?> c)
// 如果列表包含指定 collection 的所有元素,则返回 true。
l3.add("a1");
l3.add("a2");
boolean is_containsAll_l3 = l1.containsAll(l3);
System.out.println("l1为: " + l1);
System.out.println("l3为: " + l3);
System.out.println("l1是否包含l3所有的元素: " + is_containsAll_l3);
// l1为: [a0, a1, a2, a3, a4, a5]
// l3为: [a1, a2]
// l1是否包含l3所有的元素: true
// boolean equals(Object o)
// 比较指定的对象与列表是否相等。
boolean l1_is_equals_l3 = l1.equals(l3);
System.out.println("l1为: " + l1);
System.out.println("l3为: " + l3);
System.out.println("l1 与 l3 是否相等: " + l1_is_equals_l3);
// l1为: [a0, a1, a2, a3, a4, a5]
// l3为: [a1, a2]
// l1 与 l3 是否相等: false
// E get(int index) 返回列表中指定位置的元素。
Object get_index = l1.get(3);
System.out.println("l1 第3个位置上的元素为: " + get_index);
// l1 第3个位置上的元素为: a3
// int hashCode() 返回列表的哈希码值。
// int indexOf(Object o)
// 返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。
int index_a1 = l1.indexOf("a1");
int index_a9 = l1.indexOf("a9");
System.out.println("l1: " + l1);
System.out.println("在l1中 a1的位置: " + index_a1 + " a9的位置: " + index_a9);
// l1: [a0, a1, a2, a3, a4, a5]
// 在l1中 a1的位置: 1 a9的位置: -1
// int lastIndexOf(Object o)
// 返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。
// Iterator<E> iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。
// Iterator<String> iter = l1.iterator();
// Iterator<Object> iter = l1.iterator();
Iterator iter = l1.iterator();
System.out.print("l1迭代输出为: ");
while (iter.hasNext()) {
// String s = iter.next();
Object s = iter.next();
System.out.print(s + " ");
}
System.out.println();
// l1迭代输出为: a0 a1 a2 a3 a4 a5
// ListIterator<E> listIterator() 返回此列表元素的列表迭代器(按适当顺序)。
// l1.add(3, "a12");
// l1.add(3, "a18");
// System.out.println("l1: " + l1);
// 前三行实验了ListIterator并不能对列表进行排序
ListIterator<String> list_iter = l1.listIterator();
int index = 0;
while (list_iter.hasNext()) {
index ++;
if (index%3 == 0) {
Object s = list_iter.previous();
System.out.print("previous: " + s + " ");
} else {
Object s = list_iter.next();
System.out.print("next: " + s + " ");
}
}
System.out.println();
// next: a0 next: a1 previous: a1 next: a1 next: a2 previous: a2 next: a2
// next: a3 previous: a3 next: a3 next: a4 previous: a4 next: a4 next: a5
// ListIterator<E> listIterator(int index)
// 返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。
// E remove(int index)
// 移除列表中指定位置的元素(可选操作)。
// boolean remove(Object o)
// 从此列表中移除第一次出现的指定元素(如果存在)(可选操作)。
// boolean removeAll(Collection<?> c)
// 从列表中移除指定 collection 中包含的其所有元素(可选操作)。
// boolean retainAll(Collection<?> c)
// 仅在列表中保留指定 collection 中所包含的元素(可选操作)。
// E set(int index, E element)
// 用指定元素替换列表中指定位置的元素(可选操作)。
System.out.print("原来的l1为: " + l1 + " ");
Object get_o = l1.set(1, "a99");
System.out.print("修改过的l1为: " + l1 + " ");
System.out.println("返回值为: " + get_o);
// 原来的l1为: [a0, a1, a2, a3, a4, a5]
// 修改过的l1为: [a0, a99, a2, a3, a4, a5]
// 返回值为: a1
// int size()
// 返回列表中的元素数。
System.out.println("l1的长度size()为: " + l1.size());
// List<E> subList(int fromIndex, int toIndex)
// 返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。
List l4 = l1.subList(1, 5);
System.out.println("截取l1从第1个位置到第5个位置的元素: " + l4);
// 截取l1从第1个位置到第5个位置的元素: [a99, a2, a3, a4]
// Object[] toArray()
// 返回按适当顺序包含列表中的所有元素的数组(从第一个元素到最后一个元素)
Object[] l1_to_array = l1.toArray();
System.out.print("l1转成数组之后的输出: ");
for (int i = 0; i < l1_to_array.length; i++ ) {
System.out.print(l1_to_array[i] + " ");
}
System.out.println();
// l1转成数组之后的输出: a0 a99 a2 a3 a4 a5
// <T> T[] toArray(T[] a)
// 返回按适当顺序(从第一个元素到最后一个元素)包含列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。
// l1.add(new Integer(111));
// System.out.println(l1);
// String[] a = {"a11", "a0", "a13", "a2"};
// String[] l1_to_array_string = l1.toArray(new String[0]);
// l1.remove(new Integer(111));
// System.out.print("<T> T[] toArray(T[] a) 的结果为: ");
// for (int i = 0; i < l1_to_array_string.length; i++ ) {
// System.out.print(l1_to_array_string[i] + " ");
// }
// error
//复制 void copy(List dest, List src) 将src拷贝到dest
//复制的时候,l2的长度size不会改变,所以会抛出越界异常,在复制的时候,要改变l2的长度
// 它的capacity(容纳能力大小)可以指定(最好指定)。
// 而初始化时size的大小永远默认为0,只有在进行add和remove等相关操作 时,size的大小才变化。
// 然而进行copy()时候,首先做的是将desc的size和src的size大小进行比较,
// 只有当desc的 size 大于或者等于src的size时才进行拷贝,
// 否则抛出IndexOutOfBoundsException异常
Collections.addAll(l2, new Object[l1.size()]);
Collections.copy(l2, l1);
System.out.println("l1拷贝到l2中,l2的值为: " + l2);
// 随机排列顺序
Collections.shuffle(l1);
System.out.println("l1随机排序后为" + l1);
// l1随机排序后为[a0, a4, a5, a2, a99, a3]
//逆序 void reversee(List) 倒序
Collections.reverse(l2);
System.out.println("l1倒序之后为: " + l2);
// l1倒序之后为: [a5, a4, a3, a2, a99, a0]
//排序 sort(List)
Collections.sort(l1);
System.out.println("l1排序之后为: " + l1);
// l1排序之后为: [a0, a2, a3, a4, a5, a99]
//求交集
l1.add("a10");
l1.add("a11");
l1.add("a12");
System.out.println("l1为: " + l1);
l1.retainAll(l2);
System.out.println("l2为: " + l2);
System.out.println("l1与l2的交集为: " + l1);
// l1为: [a0, a2, a3, a4, a5, a99, a10, a11, a12]
// l2为: [a5, a4, a3, a2, a99, a0]
// l1与l2的交集为: [a0, a2, a3, a4, a5, a99]
// 折半查找 int binarySearch(List, Object) 折半查找
int index_ = Collections.binarySearch(l1, "a5");
System.out.println("折半查找的位置为: " + index_);
// 折半查找的位置为: 4
}
}
int size()
返回列表中的元素数。如果列表包含多于 Integer.MAX_VALUE 个元素,则返回 Integer.MAX_VALUE。
boolean isEmpty()
如果列表不包含元素,则返回 true。
boolean contains(Object o)
如果列表包含指定的元素,则返回 true。更确切地讲,当且仅当列表包含满足 (o==null ? e==null : o.equals(e)) 的元素 e 时才返回 true。
Iterator<E> iterator()
返回按适当顺序在列表的元素上进行迭代的迭代器。
Object[] toArray()
返回按适当顺序包含列表中的所有元素的数组(从第一个元素到最后一个元素)。
由于此列表不维护对返回数组的任何引用,因而它将是“安全的”。(换句话说,即使数组支持此列表,此方法也必须分配一个新数组)。因此,调用者可以随意修改返回的数组。
此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。
<T> T[] toArray(T[] a)
返回按适当顺序(从第一个元素到最后一个元素)包含列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。如果指定数组能容纳列表,则在其中返回该列表。否则,分配具有指定数组的运行时类型和此列表大小的新数组。
如果指定数组能容纳列表,并剩余空间(即数组的元素比列表的多),那么会将数组中紧随列表尾部的元素设置为 null。(只有 在调用者知道列表不包含任何 null 元素时此方法才能用于确定列表的长度)。
像 toArray() 方法一样,此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。更进一步说,此方法允许对输出数组的运行时类型进行精确控制,在某些情况下,可以用来节省分配开销。
假定 x 是只包含字符串的一个已知列表。以下代码用来将该列表转储到一个新分配的 String 数组:
String[] y = x.toArray(new String[0]);
注意,toArray(new Object[0]) 和 toArray() 在功能上是相同的。
boolean add(E e)
向列表的尾部添加指定的元素(可选操作)。
支持该操作的列表可能对列表可以添加的元素有一些限制。特别是某些列表将拒绝添加 null 元素,其他列表将在可能添加的元素类型上施加限制。List 类应该在它们的文档中明确指定有关添加元素的所有限制。
boolean remove(Object o)
从此列表中移除第一次出现的指定元素(如果存在)(可选操作)。如果列表不包含元素,则不更改列表。更确切地讲,移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i 的元素(如果存在这样的元素)。如果此列表已包含指定元素(或者此列表由于调用而发生更改),则返回 true。
boolean containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素,则返回 true。
boolean addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾,顺序是指定 collection 的迭代器返回这些元素的顺序(可选操作)。如果在操作正在进行中修改了指定的 collection,那么此操作的行为是不确定的(注意,如果指定的 collection 是此列表,并且它是非空的,则会发生这种情况。)
boolean addAll(int index,
Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置(可选操作)。将当前处于该位置的元素(如果有的话)和所有后续元素向右移动(增加其索引)。新元素将按照它们通过指定 collection 的迭代器所返回的顺序出现在此列表中。如果在操作正在进行中修改了指定的 collection,那么该操作的行为是不确定的(注意,如果指定的 collection 是此列表,并且它是非空的,则会发生这种情况。)
boolean removeAll(Collection<?> c)
从列表中移除指定 collection 中包含的其所有元素(可选操作)。
boolean retainAll(Collection<?> c)
仅在列表中保留指定 collection 中所包含的元素(可选操作)。换句话说,该方法从列表中移除未包含在指定 collection 中的所有元素。也就是求交集。
void clear()
从列表中移除所有元素(可选操作)。此调用返回后该列表将是空的。
boolean equals(Object o)
比较指定的对象与列表是否相等。当且仅当指定的对象也是一个列表、两个列表有相同的大小,并且两个列表中的所有相应的元素对相等 时才返回 true( 如果 (e1==null ? e2==null :e1.equals(e2)),则两个元素 e1 和 e2 是相等 的)。换句话说,如果所定义的两个列表以相同的顺序包含相同的元素,那么它们是相等的。该定义确保了 equals 方法在 List 接口的不同实现间正常工作。
int hashCode()
返回列表的哈希码值。列表的哈希码定义为以下计算的结果:
int hashCode = 1;Iterator<E> i = list.iterator();
while (i.hasNext()) {
E obj = i.next();
hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
}
这确保了 list1.equals(list2) 意味着对于任何两个列表 list1 和 list2 而言,可实现 list1.hashCode()==list2.hashCode(),正如 Object.hashCode() 的常规协定所要求的。
返回:此列表的哈希码值
E get(int index)
返回列表中指定位置的元素。返回:列表中指定位置的元素
E set(int index, E element)
用指定元素替换列表中指定位置的元素(可选操作)。返回:以前在指定位置的元素
void add(int index, E element)
在列表的指定位置插入指定元素(可选操作)。将当前处于该位置的元素(如果有的话)和所有后续元素向右移动(在其索引中加 1)。
E remove(int index)
移除列表中指定位置的元素(可选操作)。将所有的后续元素向左移动(将其索引减 1)。返回从列表中移除的元素。
参数:index - 要移除的元素的索引
返回:以前在指定位置的元素
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。更确切地讲,返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i;如果没有这样的索引,则返回 -1。
参数:o - 要搜索的元素
返回:此列表中第一次出现的指定元素的索引,如果列表不包含该元素,则返回 -1
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。更确切地讲,返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i;如果没有这样的索引,则返回 -1。
参数:o - 要搜索的元素
返回:列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1
ListIterator<E> listIterator()
返回此列表元素的列表迭代器(按适当顺序)。
返回:此列表元素的列表迭代器(按适当顺序)
ListIterator<E> listIterator(int index)
返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。指定的索引表示 next 的初始调用所返回的第一个元素。previous 方法的初始调用将返回索引比指定索引少 1 的元素。
参数:index - 从列表迭代器返回的第一个元素的索引(通过调用 next 方法)
返回:此列表中元素的列表迭代器(按适当顺序),从列表中的指定位置开始
List<E> subList(int fromIndex,
int toIndex)
返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。(如果 fromIndex 和 toIndex 相等,则返回的列表为空)。返回的列表由此列表支持,因此返回列表中的非结构性更改将反映在此列表中,反之亦然。返回的列表支持此列表支持的所有可选列表操作。
此方法省去了显式范围操作(此操作通常针对数组存在)。通过传递 subList 视图而非整个列表,期望列表的任何操作可用作范围操作。例如,下面的语句从列表中移除了元素的范围:
list.subList(from, to).clear();可以对 indexOf 和 lastIndexOf 构造类似的语句,而且 Collections 类中的所有算法都可以应用于 subList。
如果支持列表(即此列表)通过任何其他方式(而不是通过返回的列表)从结构上修改,则此方法返回的列表语义将变为未定义(从结构上修改是指更改列表的大小,或者以其他方式打乱列表,使正在进行的迭代产生错误的结果)。
参数:
fromIndex - subList 的低端(包括)
toIndex - subList 的高端(不包括)
返回:列表中指定范围的视图