在上一章提到过List是Collection的子接口，下面我们来了解一下List集合
List
- 概述：集合中的元素有序，且每一个元素都会存在一个索引，元素可重复
- 特有功能：
void add(int index,E element):在指定索引处添加元素
E remove(int index):删除指定索引元素，返回被删除的元素
E get(int index):获取指定索引的元素
E set(int index,E element):更改指定索引的元素，返回被更改的元素
演示：
package org.org.westos.demo;
import java.util.ArrayList;
import java.util.List;
public class MyClass {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(500);
list.add(600);
System.out.println(list);
//调用add方法在指定位置添加元素
list.add(1,150);
System.out.println(list);
//调用remove方法删除指定索引元素，并返回该元素
Object o = list.remove(0);
System.out.println(o);
System.out.println(list);
//调用get方法获取指定索引元素
Object o1 = list.get(list.size()-1);
System.out.println(o1);
//调用set方法更改指定索引元素，返回被更改的元素
Object o2 = list.set(0,100);
System.out.println(o2);
System.out.println(list);
//调用subList方法根据起始索引和终止索引，截取一段放到新的集合中
List list1 = list.subList(2,4);//含头不含尾
System.out.println(list1);
}
}
根据代码一步步输出原集合
- List的遍历
在上一章，我们知道可以通过迭代器遍历集合，对于List同样适用
package org.org.westos.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyClass {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(500);
list.add(600);
//迭代器遍历集合
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
但List还有自己特有的遍历功能
（1）通过size()方法和get()方法遍历集合
（2）可以通过列表迭代器遍历集合
演示：
package org.org.westos.demo;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class MyClass {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(500);
list.add(600);
//for循环遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("---------");
//通过列表迭代器遍历集合
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
System.out.println(listIterator.next());
}
}
}
如果我们在使用迭代器遍历集合途中对集合元素进行增删操作，这里就会涉及并发修改异常，而产生这个异常的原因就是迭代器在遍历集合之前就知道了遍历元素个数，在遍历途中，一旦进行增删操作，就会改变元素的个数，迭代器遍历顺序就会被打乱，所以就会报出异常
package org.org.westos.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyClass {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(500);
list.add(600);
//迭代器遍历集合
Iterator iterator = list.iterator();
while(iterator.hasNext()){
list.add(400);
System.out.println(iterator.next());
}
}
}
那么，如果解决这个异常呢，要么使用迭代器特有的增删功能进行操作，要么通过for循环遍历集合
以上说的遍历都是正向遍历，对于反向遍历，List也提供了特有功能
boolean hasPreVious():是否存在前一个元素
E previous():返回列表中的前一个元素
演示：
package org.org.westos.demo;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class MyClass {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(400);
ListIterator listIterator = list.listIterator();
//通过列表迭代器正向遍历集合
while(listIterator.hasNext()){
System.out.println(listIterator.next());
}
System.out.println("--------");
//通过列表迭代器反向遍历集合
while(listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
}
}
这里注意，要进行反向遍历，必须先正向遍历，因为指针最开始指向的是第一个元素，只有正向遍历后，指针才会指向最后一个元素，这时候才能实现反向遍历
数据结构
在介绍List集合的三个子类之前，先来了解一下数据结构
- 概述：数据结构就是存储数据的格式
- 分类：栈，队列，数组，链表，树，哈希表
- 特点：
栈：先进后出（先存储的元素，最后获取到）
队列：先进先出（先存储的元素，先获取到）
数组：查询快，增删慢
链表：查询慢，增删快
List集合的三个子类
到底使用哪个子类，取决于使用它的人是要安全性高，还是效率高等，根据每个类的特点去选择
ArrayList
- 特有功能
protected void removeRange(int fromIndex,int toIndex):移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素，此方法受保护，所以要使用需要重写此方法且修改权限修饰符
void forEach(Consumer<? super E> action) ：执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常
void sort (Comparator < ? super E > c)：比较元素，排序
package org.org.westos.demo;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;
public class MyClass {
public static void main(String[] args) {
//创建一个初始容量为10的列表
ArrayList arrayList = new ArrayList();
arrayList.add(100);
arrayList.add(200);
arrayList.add(500);
arrayList.add(400);
arrayList.add(300);
arrayList.add(150);
//使用匿名内部类,forEach方法
arrayList.forEach(new Consumer() {
@Override
public void accept(Object o) {
System.out.println(o);
}
});
System.out.println("-----");
//调用sort方法，匿名内部类给集合元素排序
arrayList.sort(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//要运算，需向下转型
Integer o3 = (Integer) o1;
Integer o4 = (Integer) o2;
return o3-o4;
}
});
System.out.println(arrayList);
}
}
- 遍历
（1）迭代器遍历
（2）列表迭代器遍历（不重复写，看List）
（3）for循环遍历
package org.org.westos.demo;
import java.util.ArrayList;
import java.util.Iterator;
public class MyClass {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(100);
arrayList.add(200);
arrayList.add(500);
arrayList.add(400);
//迭代器遍历
Iterator iterator = arrayList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("-----");
//for循环遍历
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
}
}
Vector
- 特有功能
public void addElement(E obj):给集合添加元素
public E elementAt(int index):根据索引查元素
public E firstElement():获取第一个元素
public E lastElement():获取最后一个元素
package org.org.westos.demo;
import java.util.Vector;
public class MyClass {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("aaa");
vector.add("bbb");
vector.add("ccc");
vector.add("ddd");
//调用addElement给集合添加元素
vector.addElement("eee");
System.out.println(vector);
//调用elementAt方法根据索引查元素
Object o = vector.elementAt(2);
System.out.println(o);
//调用firstElement方法获取第一个元素
Object o1 = vector.firstElement();
System.out.println(o1);
//调lastElement方法获取最后一个元素
Object o2 = vector.lastElement();
System.out.println(o2);
}
}
- 遍历
（1）for循环遍历集合
（2）迭代器遍历集合
（3）自带的迭代器Enumeration遍历集合
（4）列表迭代器遍历
package org.org.westos.demo;
import java.util.Enumeration;
import java.util.Vector;
public class MyClass {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("aaa");
vector.add("bbb");
vector.add("ccc");
vector.add("ddd");
//for循环，迭代器ArrayList类一样
//使用自带的迭代器遍历
Enumeration enumeration = vector.elements();
while(enumeration.hasMoreElements()){
System.out.println(enumeration.nextElement());
}
}
}
LinkedList
- 特有功能
public void addFirst(E e):在集合最前面添加元素
public void addLast(E e):在集合最后面添加元素
public E getFirst():获取集合中的第一个元素
public E getLast():获取集合中的最后元素
public E removeFirst():删除集合中的第一个元素
public E removeLast():删除集合中的最后一个元素
演示：
package org.org.westos.demo;
import java.util.LinkedList;
public class MyClass {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(123);
linkedList.add(456);
linkedList.add(789);
linkedList.add(111);
//调用addFirst方法在集合最前面添加元素
linkedList.addFirst(100);
System.out.println(linkedList);
//调用addLast方法在集合最后面添加元素
linkedList.addLast(222);
System.out.println(linkedList);
//调用getFirst获取集合第一个元素
Object o1 = linkedList.getFirst();
System.out.println(o1);
//调用getLast获取集合最后一个元素
Object o2 = linkedList.getLast();
System.out.println(o2);
//调用removeFirst删除第一个元素
linkedList.removeFirst();
System.out.println(linkedList);
//调用removeLast删除最后一个元素
linkedList.removeLast();
System.out.println(linkedList);
}
}
- 遍历
（1）for循环遍历集合
（2）迭代器遍历集合
（3）列表迭代器遍历集合
package org.org.westos.demo;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class MyClass {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(123);
linkedList.add(456);
linkedList.add(789);
linkedList.add(111);
//for循环遍历
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
System.out.println("-----");
//迭代器遍历
Iterator iterator = linkedList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("-----");
//列表迭代器遍历
ListIterator listIterator = linkedList.listIterator();
while(listIterator.hasNext()){
System.out.println(listIterator.next());
}
}
}
总结一下，在遍历集合时，如果对象类型是List，则可通过迭代器遍历，for循环遍历，还可通过特有的列表迭代器遍历，如果对象类型是它的三个子类，那同样可以通过迭代器、for循环还有列表迭代器遍历，但Vector类还可以通过自带的迭代器Enumeration遍历Vector集合
扫一扫
943
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
