目录
1 概述
List是一个接口，继承自Collection接口。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
public interface List<E> extends Collection<E>
2 常用实现类
- ArrayList【重点】
- 数组结构实现，查询快、增删慢；
- JDK1.2版本，运行效率快、线程不安全
- Vector
- 数组结构实现，查询快、增删慢；
- JDK1.0版本，运行效率慢、线程安全
- LinkedList
- 链表结构实现，增删快，查询慢
3 常用方法
4 使用范例
4.1 ArrayList
public class List1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
//添加
list.add("Java1");
list.add("Java2");
list.add("Java3");
list.add("Java4");
//遍历
//增强for
for (String s : list) {
System.out.println(s);
}
//for下标
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));
// }
//迭代器
// Iterator<String> iterator = list.iterator();
// while (iterator.hasNext()){
// System.out.println(iterator.next());
// }
//list迭代器 向后遍历
// ListIterator<String> listIterator1 = list.listIterator();
// while (listIterator1.hasNext()){
// System.out.println(listIterator1.nextIndex()+" " + listIterator1.next());
// }
//list迭代器 向前遍历
// ListIterator<String> listIterator2 = list.listIterator(list.size());
// while (listIterator2.hasPrevious()){
// int index = listIterator2.previousIndex();
// System.out.println(index+" "+listIterator2.previous());
// }
System.out.println(list);
//设置指定位置的元素
list.set(0,"Java0000");
//获取指定位置的元素
System.out.println(list.get(0));
//删除指定位置的元素
list.remove(0);
//删除指定元素，第一次出现删除
list.remove("Java2");
//大小
System.out.println("大小:"+list.size());
//判断是否非空
System.out.println("非空:"+list.isEmpty());
//包含
System.out.println("包含："+list.contains("Java2"));;
//清空集合
list.clear();
System.out.println(list);
}
}
Java1
Java2
Java3
Java4
[Java1, Java2, Java3, Java4]
Java0000
大小:2
非空:false
包含：false
[]
4.2 Vector(不使用)
Vector中的方法大部分是和ArrayList是一样的，方法使用上没有太大差别。
/**
* Vector集合的使用
*/
public class Vector1 {
public static void main(String[] args) {
//创建集合
Vector<String> myVector = new Vector<>();
//添加元素
myVector.add("Hello");
myVector.add(1,"World");
myVector.add("!");
System.out.println(myVector);
/**
* 遍历元素
*/
//使用迭代器iterator
//增强for
//普通for
//使用Enumeration
Enumeration<String> elements = myVector.elements();
while (elements.hasMoreElements()){
System.out.println(elements.nextElement());
}
//获取第一个元素
System.out.println("first:"+myVector.firstElement());
//获取最后一个元素
System.out.println("last:"+myVector.lastElement());
//修改指定索引的值
myVector.set(1,"Java");
System.out.println("修改后:"+myVector);
//删除指定索引的值
myVector.remove(2);
myVector.remove("Java");
System.out.println("删除后:"+myVector);
}
}
[Hello, World, !]
Hello
World
!
first:Hello
last:!
修改后:[Hello, Java, !]
删除后:[Hello]
不使用原因参考：java数据结构中，什么情况下用Vector,什么情况下用ArrayList呢？
- Vector所有方法都是同步，有性能损失。
- Vector初始length是10 超过length时 以100%比率增长，ArrayList初始容量为10 超过容量，增长50%，所以Vector更消耗内存。
- 部分方法名字过长（遍历时候的
hasMoreElements）
4.3 LinkedList集合使用
/**
* LinkedList集合使用
*/
public class LinkedList1 {
public static void main(String[] args) {
//创建集合
LinkedList<Student> studentList = new LinkedList<>(); //Student类重写了equals方法
/**
* 添加元素
* 没有指定位置：
* 添加到集合末尾
* 指定位置：
* 位置不能超过集合大小，如果指定的位置已经有元素，则该位置的元素后移
*/
studentList.add(new Student("s1",18));
studentList.add(1,new Student("s2",19));//在指定位置添加，位置不能超过集合大小
studentList.add(new Student("s3",20));
studentList.add(new Student("s4",21));
System.out.println(studentList);
//获取头尾元素
System.out.println("头元素："+studentList.getFirst());
System.out.println("尾元素"+studentList.getLast());
//判断非空
System.out.println("是否为空:"+studentList.isEmpty());
//集合大小
System.out.println("大小:"+studentList.size());
//获取集合中的指定位置元素
System.out.println("get某个元素:"+studentList.get(1));
//设置指定位置上的元素（修改）
studentList.set(1,new Student("s22",199));
//是否存在某个元素
boolean contains = studentList.contains(new Student("s4", 21));
System.out.println("s4是否存在:"+contains);
//删除元素
//1.根据位置删除
studentList.remove(3);
//2.根据元素值删除
// studentList.remove(new Student("s4", 21));
//3.清空集合
// studentList.clear();
System.out.println("删除后："+studentList);
//查找指定元素的索引(第一次出现的位置)
int index = studentList.indexOf(new Student("s3", 20));
System.out.println(index);//2
//查找指定元素的索引(最后一次出现的位置)
int lastIndex = studentList.lastIndexOf(new Student("s1", 18));
System.out.println(lastIndex);//0
/**
* 遍历
*/
//增强for
//普通for
//迭代器
Iterator<Student> iterator = studentList.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//List迭代器
ListIterator<Student> listIterator = studentList.listIterator();
while (listIterator.hasNext()){
System.out.println(listIterator.next());
}
}
}
[Student{name='s1', age=18}, Student{name='s2', age=19}, Student{name='s3', age=20}, Student{name='s4', age=21}]
头元素：Student{name='s1', age=18}
尾元素Student{name='s4', age=21}
是否为空:false
大小:4
get某个元素:Student{name='s2', age=19}
s4是否存在:true
删除后：[Student{name='s1', age=18}, Student{name='s22', age=199}, Student{name='s3', age=20}]
2
0
Student{name='s1', age=18}
Student{name='s22', age=199}
Student{name='s3', age=20}
Student{name='s1', age=18}
Student{name='s22', age=199}
Student{name='s3', age=20}
4.3.1 LinkedList源码解析
4.4 ArrayList与LinkedList的区别
1. ArrayList的实现是基于数组，LinkedList的实现是基于双向链表
2. 对于随机访问，ArrayList优于LinkedList
3. 对于插入和删除操作，LinkedList优于ArrayList
4. LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素
5. ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10，当数组需要增长时，新的容量按如下公式获得：新容量 = 旧容量×1.5 ，也就是说每一次容量大概会增长50%