6 List集合
- List系列集合：添加的元素是有序，可重复，有索引
- ArrayList: 添加的元素是有序，可重复，有索引
- LinkedList: 添加的元素是有序，可重复，有索引
- Vector ：是线程安全的，速度慢，开发中很少使用
6.1 List集合概述和特点
List集合概述
1、有序集合(也称为序列)，用户可以精确控制列表中每个元索的插入位置。用户可以通过整数索引访问元素,并获取列表中的元素
2、与Set集合不同，List集合允许重复的元素
List集合特点
1、有序: 存储和取出的元素顺序一致
2、可重复: 存储的元素可以重复
package ceshi;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<>();
//添加元素
list.add("java");
list.add("天下");
list.add("无敌");
list.add("java");
System.out.println(list); //[java, 天下, 无敌, java]
//迭代器遍历
Iterator<String> it = list.iterator();
while(it.hasNext()) {
String s = it.next();
System.out.println(s);
/*java
天下
无敌
java*/
}
}
}
6.2 List集合的特有方法
| 方法名 | 说明 |
|---|---|
| public void add(int index,E element) | 该集合中的指定位置上插入元素 |
| public E remove(int index) | 删除列表中指定位置的元素，返回被删除的元素 |
| public E set(int index,E element) | 修改指定索引的元素，返回被修改的元素 |
| public E get(int index) | 返回集合中指定位置的元素 |
package ceshi;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<>();
//添加元素
list.add("java");
list.add("天下");
list.add("无敌");
list.add("java");
System.out.println(list); //[java, 天下, 无敌, java]
//1、public void add(int index,E element) 该集合中的指定位置上插入元素
list.add(1,"javase");
System.out.println(list); //[java, javase, 天下, 无敌, java]
//2、public E remove(int index) 删除列表中指定位置的元素，返回被删除的元素
System.out.println(list.remove(1)); //javase
System.out.println(list); //[java, 天下, 无敌, java]
//3、public E set(int index,E element) 修改指定索引的元素，返回被修改的元素
System.out.println(list.set(0,"java1")); //java
System.out.println(list); //[java1, 天下, 无敌, java]
//4、public E get(int index) 返回集合中指定位置的元素
System.out.println(list.get(2)); //无敌
//for循环遍历
for(int i=0;i< list.size();i++) {
//5,public E get(int index) 返回集合中指定位置的元素
String s = list.get(i);
System.out.println(s);
/*java1
天下
无敌
java*/
}
}
}
-
案例
-
测试类
package ceshi;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//2、创建集合对象
List<Student> list = new ArrayList<Student>();
//3、创建学生对象
Student s1 = new Student("y1",10);
Student s2 = new Student("y2",20);
Student s3 = new Student("y3",30);
//4、学生对象添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//5、遍历集合：迭代器方法
Iterator<Student> it = list.iterator();
while(it.hasNext()) {
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
/*y1,10
y2,20
y3,30*/
}
//5、遍历集合：for循环
for(int i=0;i<list.size();i++) {
Student ss = list.get(i);
System.out.println(ss.getName()+","+ss.getAge());
/*y1,10
y2,20
y3,30*/
}
}
}
6.3 ListIterator迭代器
- Lstlterator:列表迭代器
- 通过List集合的
listterator()方法得到，所以说它是List集合特有的迭代器 - 用于允许程序员沿任一方向遍历列表的列表迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置
- 通过List集合的
- 常用方法
| 方法名 | 说明 |
|---|---|
| list.listIterator() | 得到 listIterator 迭代器 |
| E next() | 返回迭代中的下一个元素 |
| boolean hasNext() | 如果迭代具有更多元素，则返回true |
| E previous() [ˈpriːviəs] | 返回列表中的上一个元素 |
| boolean hasPrevious() | 如果此列表迭代器在相反方向遍历列表时具有更多元索，则返回true |
| void add(E e) | 将指定的元索插入列表 |
package ceshi;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("java");
list.add("python");
list.add("scala");
//通过list集合的listIterator() 方法得到迭代器
/*ListIterator<String> lit = list.listIterator();
while(lit.hasNext()) {
String s = lit.next();
System.out.println(s);
*//*java
python
scala*//*
}
System.out.println("---------");
//逆向遍历
*//*E previous0 返回列表中的上一个元素
boolean hasPrevious() 如果此列表迭代器在相反方向遍历列表时具有更多元索，则返回true*//*
while(lit.hasPrevious()) {
String s = lit.previous();
System.out.println(s);
*//*scala
python
java*//*
}*/
//获取列表迭代器
ListIterator<String> lit = list.listIterator();
while(lit.hasNext()) {
String s = lit.next();
if(s.equals("java")) {
lit.add("world");
}
}
System.out.println(list); //[java, world, python, scala]
}
}
6.4 foreach（增强for循环）
增强for：简化数组和Collection集合的遍历
- 实现Iterable接口的类允许其对象成为增强型 for语句的目标
- 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
- 格式
for(元素类型 变量名: 数组名或collection集合){
}
//范例
int[] arr = {1,2,3,4,5};
for(int i : arr) {
System.out.println(i);
}
- 范例：
package ceshi;
import java.util.ArrayList;
import java.util.List;
public class ForDemo {
public static void main(String[] args) {
//int类型数组
int[] arr = {1,2,3,4,5};
for(int i : arr) {
System.out.println(i);
/*
1
2
3
4
5*/
}
//String类型数组
String[] strArray = {"java","python","scala"};
for(String s : strArray) {
System.out.println(s);
/*java
python
scala*/
}
//集合
List<String> list = new ArrayList<>();
list.add("y1");
list.add("y2");
list.add("y3");
for(String lt:list) {
System.out.println(lt);
/*y1
y2
y3*/
}
//判断：内部原理是一个Iterator迭代器
for(String s:list) {
if(s.equals("y1")) {
list.add("y4"); //ConcurrentModificationException:并发修改异常
}
}
}
}
6.5 案例：List集合存储学生对象用三种方式遍历
- 测试类
package ceshi;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
Student s1 = new Student("y1",10);
Student s2 = new Student("y2",20);
Student s3 = new Student("y3",30);
list.add(s1);
list.add(s2);
list.add(s3);
//迭代器方式
Iterator<Student> it = list.iterator();
while(it.hasNext()) {
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("----------");
//for带索引方式
for(int i =0;i<list.size();i++) {
Student s = list.get(i);
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("----------");
//增强for
for(Student s: list) {
System.out.println(s.getName()+","+s.getAge());
}
}
}
6.6 List集合子类特点
ArrayList：底层数据结构数组实现，查询快，增删慢LinkedList：底层数据结构链表实现，查询慢，增删快- 范例：分别用ArrayList和LinkedList存储字符串并遍历
package ceshi;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//1、创建ArrayList集合对象
ArrayList<String> arraylist = new ArrayList<>();
arraylist.add("java");
arraylist.add("python");
arraylist.add("scala");
//增强for
for(String s: arraylist) {
System.out.println(s);
}
System.out.println("-------");
//普通for循环
for(int i=0;i< arraylist.size();i++) {
String s = arraylist.get(i);
System.out.println(s);
}
System.out.println("-------");
//迭代器的方式
Iterator<String> it = arraylist.iterator();
while(it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("-------");
//2、创建LinkedList集合对象
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("a");
linkedList.add("b");
linkedList.add("c");
//增强for
for(String s:linkedList) {
System.out.println(s);
}
System.out.println("-------");
//普通for
for(int i=0;i< linkedList.size();i++) {
String s = linkedList.get(i);
System.out.println(s);
}
System.out.println("-------");
//迭代器
Iterator<String> it1 = linkedList.iterator();
while(it1.hasNext()) {
String s = it1.next();
System.out.println(s);
}
}
}
6.7 LinkedList集合特有方法
| 方法名 | 说明 |
|---|---|
| public void addFirst(E,e) | 在该列表开头插入指定的元素 |
| public void addLast(E,e) | 将指定的元索追加到此列表的末尾 |
| public E getFirst() | 返回此列表中的第一个元索 |
| public E getLast() | 返回此列表中的最后一个元素 |
| public E removeFirst | 从此列表中删除并返回第一个元素 |
| public E removeLast | 从此列表中删除并返回最后一个元素 |
package ceshi;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
//创建集合对象
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("java");
linkedList.add("python");
linkedList.add("scala");
System.out.println(linkedList); //[java, python, scala]
//1、public void addFirst(E,e) 在该列表开头插入指定的元素
linkedList.addFirst("1");
System.out.println(linkedList); //[1, java, python, scala]
//2、public void addLast(E,e) 将指定的元索追加到此列表的末尾
linkedList.addLast("5");
System.out.println(linkedList); //[1, java, python, scala, 5]
//3、public E getFirst() 返回此列表中的第一个元索
System.out.println(linkedList.getFirst()); //1
//4、public E getLast() 返回此列表中的最后一个元素
System.out.println(linkedList.getLast()); //5
//5、public E removeFirst 从此列表中删除并返回第一个元素
System.out.println(linkedList.removeFirst()); //1
System.out.println(linkedList);//[java, python, scala, 5]
//6、public E removeLast 从此列表中删除并返回最后一个元素
System.out.println(linkedList.removeLast()); //5
System.out.println(linkedList); //[java, python, scala]
}
}
