List简单介绍
List接口是Collection的子接口。
List集合是有序的(输入和输出顺序不变)，且允许重复元素存在。
List集合每个元素都有其对应的顺序索引，即List支持索引。
List使用及常用方法
首先是所有Collection中的方法在List中都可以使用，其次List 集合里添加了一些根据索引来操作集合元素的方法：
-
void add(int index, Object ele):在index位置插入ele元素
-
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
-
Object get(int index):获取指定index位置的元素
-
int indexOf(Object obj):返回obj在集合中首次出现的位置
-
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
-
Object remove(int index):移除指定index位置的元素，并返回此元素
-
Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换.
-
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
package class_List;
import java.util.List;
import java.util.ArrayList;
public class ClassTest01 {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
List list = new ArrayList();
for(int i = 1; i<=10;i++) {
list.add("hello" + "0" + i);
}
System.out.println(list);
//1. void add(int index, Object ele):在index位置插入ele元素
list.add(2, "hello川农");
System.out.println(list);
//2. boolean addAll(int index, Collection eles):将else从0到index位置之间的元素添加进来，返回布尔值
// list.addAll(8, list);
if(list.addAll(2, list)) System.out.println(list);
//3. Object get(int index):获取指定index位置的元素
System.out.println(list.get(4));
//4. int indexOf(Object obj):返回obj在集合中首次出现的位置
System.out.println(list.indexOf("hello03"));
//5. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
System.out.println(list.lastIndexOf("hello02"));
//6. Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(2);
System.out.println(obj);
//7. Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换
System.out.println(list);
Object obj2 = list.set(0,"hi川农"); //返回值：原list上指定index位置上的元素
System.out.println(obj2);
System.out.println(list);
//8. List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
List list2 = list.subList(6, 8); //java中绝大部分范围都是前闭后开的，即 [ 6,8)
System.out.println(list2);
}
}
List练习
添加10个以上的元素(比如String “hello” )，在2号位插入一个元素"川农"， 获得第5个元素，删除第6个元素，修改第7个元素，在使用迭代器遍历集合，要求:使用List的实现类ArrayList完成。
package class_List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ClassWork01 {
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void main(String[] args) {
List arrayList = new ArrayList();
for(int i = 1;i<10;i++) {
arrayList.add("hello" + i);
}
//获得第5个元素，删除第6个元素，修改第7个元素
System.out.println(arrayList.get(4));
System.out.println("==============");
arrayList.remove(5);
arrayList.set(6, "hello川农");
//在2号位插入一个元素"川农"，
arrayList.add(1, "川农");
Iterator iterator = arrayList.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
iterator = arrayList.iterator();
}
}
List的三种遍历方式
由于List支持索引，所以多了普通for循环的遍历方式。(与遍历数组一样)
这里将三种方法都列出，用于复习Collection的两种遍历方式。
package class_List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ClassTest02_ForeachList {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
List list = new ArrayList();
for(int i = 1;i<4;i++) {
list.add("hello" + i);
}
System.out.println("=============方式一=============");
//方式一：迭代器
Iterator iterator = list.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
iterator = list.iterator();
System.out.println("=============方式二=============");
//方式二：增强for循环
for(Object obj:list) {
System.out.println(obj);
}
System.out.println("=============方式三=============");
//方式三：普通for循环
for(int i = 0 ;i<list.size();i++) {
System.out.println(list.get(i));
}
}
}
简单应用案例
使用List的实现类添加三本图书，并遍历，打印如下效果：
名称：xx 价格：xx 作者：xx
名称：xx 价格：xx 作者：xx
名称：xx 价格：xx 作者：xx
要求： 按价格排序,从低到高(使用冒泡法) 要求使用LinkedList集合实现。
只要实现了List接口，那么List的实现类都可以使用List接口中的方法。
package class_ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ClassWork03 {
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void main(String[] args) {
List linkedList = new LinkedList();
linkedList.add(new Book("三体1", 36.6, "刘慈欣"));
linkedList.add(new Book("三体2", 32.6, "刘慈欣"));
linkedList.add(new Book("三体3", 33.6, "大刘"));
for (Object obj : linkedList) {
System.out.println(obj);
}
sort(linkedList);
System.out.println("====================排序后==========================");
Iterator iterator = linkedList.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void sort(List linkedList) {
// 按价格排序,从低到高(使用冒泡法)
for (int i = 0; i < linkedList.size(); i++) {
for (int j = 0; j < linkedList.size() - 1 - i; j++) {
Book b1 = (Book) linkedList.get(j);
Book b2 = (Book) linkedList.get(j+1);
//使用List之后，不需要再像以前交换数组元素一样，使用临时变量。
//上面b1,b2都已经保存了需要交换的元素
if(b1.getPrice() > b2.getPrice()) {
linkedList.set(j, b2);
linkedList.set(j+1, b1);
}
}
}
}
}
class Book {
private String name;
private double price;
private String author;
public Book(String name, double price, String author) {
super();
this.name = name;
this.price = price;
this.author = author;
}
public Book() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
@Override
public String toString() {
return "名称：" + name + " 价格：" + price + " 作者：" + author;
}
}
程序输出
名称：三体1 价格：36.6 作者：刘慈欣
名称：三体2 价格：32.6 作者：刘慈欣
名称：三体3 价格：33.6 作者：大刘
================排序后==================
名称：三体2 价格：32.6 作者：刘慈欣
名称：三体3 价格：33.6 作者：大刘
名称：三体1 价格：36.6