JavaSE学习笔记（十六）—— List集合
一、List接口概述
1.1 List概述
有序（存储和取出的元素一致）的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。
1.2 List案例
【List集合存储字符串并遍历】
public class ListDemo { public static void main(String[] args) { // 创建集合对象 List list = new ArrayList(); // 创建字符串并添加字符串 list.add("hello"); list.add("world"); list.add("java"); // 遍历集合 Iterator it = list.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } } }
【存储自定义对象并遍历】
public class ListDemo { public static void main(String[] args) { // 创建集合对象 List list = new ArrayList(); // 创建学生对象 Student s1 = new Student("白骨精", 30); Student s2 = new Student("蜘蛛精", 40); Student s3 = new Student("观音姐姐", 22); // 把学生对象添加到集合对象中 list.add(s1); list.add(s2); list.add(s3); // 遍历 Iterator it = list.iterator(); while (it.hasNext()) { Student s = (Student) it.next(); System.out.println(s.getName() + "---" + s.getAge()); } } }
二、List的特有功能
2.1 基本功能
【添加功能】
void add(int index,Object element):在指定位置添加元素
【获取功能】
Object get(int index):获取指定位置的元素
【列表迭代器】
ListIterator listIterator()：List集合特有的迭代器
【删除功能】
Object remove(int index)：根据索引删除元素,返回被删除的元素
【修改功能】
Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
public class ListDemo { public static void main(String[] args) { // 创建集合对象 List list = new ArrayList(); // 添加元素 list.add("hello"); list.add("world"); list.add("java"); // void add(int index,Object element):在指定位置添加元素 // list.add(1, "android");//没有问题 // IndexOutOfBoundsException // list.add(11, "javaee");//有问题 // list.add(3, "javaee"); //没有问题 // list.add(4, "javaee"); //有问题 // Object get(int index):获取指定位置的元素 // System.out.println("get:" + list.get(1)); // IndexOutOfBoundsException // System.out.println("get:" + list.get(11)); // Object remove(int index)：根据索引删除元素,返回被删除的元素 // System.out.println("remove:" + list.remove(1)); // IndexOutOfBoundsException // System.out.println("remove:" + list.remove(11)); // Object set(int index,Object element):根据索引修改元素，返回被修饰的元素 System.out.println("set:" + list.set(1, "javaee")); System.out.println("list:" + list); } }
2.2 遍历功能
【使用普通for循环]
List集合的特有遍历功能：size()和get()方法结合使用
public class ListDemo { public static void main(String[] args) { // 创建集合对象 List list = new ArrayList(); // 添加元素 list.add("hello"); list.add("world"); list.add("java"); for (int x = 0; x < list.size(); x++) { String s = (String) list.get(x); System.out.println(s); } } }
存储自定义对象并遍历,用普通for循环。(size()和get()结合)
public class ListDemo3 { public static void main(String[] args) { // 创建集合对象 List list = new ArrayList(); // 创建学生对象 Student s1 = new Student("林黛玉", 18); Student s2 = new Student("刘姥姥", 88); Student s3 = new Student("王熙凤", 38); // 把学生添加到集合中 list.add(s1); list.add(s2); list.add(s3); // 遍历 // 迭代器遍历 Iterator it = list.iterator(); while (it.hasNext()) { Student s = (Student) it.next(); System.out.println(s.getName() + "---" + s.getAge()); } System.out.println("--------"); // 普通for循环 for (int x = 0; x < list.size(); x++) { Student s = (Student) list.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } }
【使用列表迭代器】
ListIterator listIterator()：List集合特有的迭代器。该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
特有功能：
- Object previous():获取上一个元素
- boolean hasPrevious():判断是否有元素
public class ListIteratorDemo { public static void main(String[] args) { // 创建List集合对象 List list = new ArrayList(); list.add("hello"); list.add("world"); list.add("java"); // 迭代器 Iterator it = list.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } System.out.println("----------"); // ListIterator listIterator() ListIterator lit = list.listIterator(); while (lit.hasPrevious()) { String s = (String) lit.previous(); System.out.println(s); } } }
注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
三、List的并发修改异常
问题：我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
public class ListIteratorDemo { public static void main(String[] args) { // 创建List集合对象 List list = new ArrayList(); // 添加元素 list.add("hello"); list.add("world"); list.add("java"); // 迭代器遍历 Iterator it = list.iterator(); while (it.hasNext()) { String s = (String) it.next(); if ("world".equals(s)) { list.add("javaee"); } } } }
运行上述代码时，出现了这样的异常：
ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
【产生的原因】
迭代器是依赖于集合而存在的，在判断成功后，集合中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。
【解决方法】
- 方式一：迭代器迭代元素，迭代器修改元素（元素是跟在刚才迭代的元素后面的）
public class ListIteratorDemo { public static void main(String[] args) { // 创建List集合对象 List list = new ArrayList(); // 添加元素 list.add("hello"); list.add("world"); list.add("java"); // 方式1：迭代器迭代元素，迭代器修改元素 // 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator ListIterator lit = list.listIterator(); while (lit.hasNext()) { String s = (String) lit.next(); if ("world".equals(s)) { lit.add("javaee"); } } System.out.println("list:" + list);//[hello, world, javaee, java] } }
- 方式2：集合遍历元素，集合修改元素（元素在最后添加的）
public class ListIteratorDemo { public static void main(String[] args) { // 创建List集合对象 List list = new ArrayList(); // 添加元素 list.add("hello"); list.add("world"); list.add("java"); // 方式2：集合遍历元素，集合修改元素(普通for) for (int x = 0; x < list.size(); x++) { String s = (String) list.get(x); if ("world".equals(s)) { list.add("javaee"); } } System.out.println("list:" + list);//[hello, world, java, javaee] } }
四、List接口的实现类
4.1 ArrayList
【ArrayList类概述】
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
【ArrayList案例】
存储字符串并遍历
public class ArrayListDemo { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 创建元素对象，并添加元素 array.add("hello"); array.add("world"); array.add("java"); // 遍历 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } System.out.println("-----------"); for (int x = 0; x < array.size(); x++) { String s = (String) array.get(x); System.out.println(s); } } }
ArrayList存储自定义对象并遍历
public class ArrayListDemo2 { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 创建学生对象 Student s1 = new Student("武松", 30); Student s2 = new Student("鲁智深", 40); Student s3 = new Student("林冲", 36); Student s4 = new Student("杨志", 38); // 添加元素 array.add(s1); array.add(s2); array.add(s3); array.add(s4); // 遍历 Iterator it = array.iterator(); while (it.hasNext()) { Student s = (Student) it.next(); System.out.println(s.getName() + "---" + s.getAge()); } System.out.println("----------------"); for (int x = 0; x < array.size(); x++) { // ClassCastException 注意，千万要搞清楚类型 // String s = (String) array.get(x); // System.out.println(s); Student s = (Student) array.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } }
去除集合中字符串的重复值(字符串的内容相同)
/* * 分析： * A:创建集合对象 * B:添加多个字符串元素(包含内容相同的) * C:创建新集合 * D:遍历旧集合,获取得到每一个元素 * E:拿这个元素到新集合去找，看有没有 * 有：不搭理它 * 没有：就添加到新集合 * F:遍历新集合 */ public class ArrayListDemo { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world"); // 创建新集合 ArrayList newArray = new ArrayList(); // 遍历旧集合,获取得到每一个元素 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); // 拿这个元素到新集合去找，看有没有 if (!newArray.contains(s)) { newArray.add(s); } } // 遍历新集合 for (int x = 0; x < newArray.size(); x++) { String s = (String) newArray.get(x); System.out.println(s); } } }
去除集合中字符串的重复值(字符串的内容相同)，要求：不能创建新的集合，就在以前的集合上做。
public class ArrayListDemo2 { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world"); // 由选择排序思想引入，我们就可以通过这种思想做这个题目 // 拿0索引的依次和后面的比较，有就把后的干掉 // 同理，拿1索引... for (int x = 0; x < array.size() - 1; x++) { for (int y = x + 1; y < array.size(); y++) { if (array.get(x).equals(array.get(y))) { array.remove(y); y--; } } } // 遍历集合 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } } }
去除集合中自定义对象的重复值(对象的成员变量值都相同)
/* * 我们按照和字符串一样的操作，发现出问题了。 * 为什么呢? * 我们必须思考哪里会出问题? * 通过简单的分析，我们知道问题出现在了判断上。 * 而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。 * contains()方法的底层依赖的是equals()方法。 * 而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法 * Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。 * 按照我们自己的需求，比较成员变量的值，重写equals()即可。 * 自动生成即可。 */ public class ArrayListDemo3 { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 创建学生对象 Student s1 = new Student("林青霞", 27); Student s2 = new Student("林志玲", 40); Student s3 = new Student("凤姐", 35); Student s4 = new Student("芙蓉姐姐", 18); Student s5 = new Student("翠花", 16); Student s6 = new Student("林青霞", 27); Student s7 = new Student("林青霞", 18); // 添加元素 array.add(s1); array.add(s2); array.add(s3); array.add(s4); array.add(s5); array.add(s6); array.add(s7); // 创建新集合 ArrayList newArray = new ArrayList(); // 遍历旧集合,获取得到每一个元素 Iterator it = array.iterator(); while (it.hasNext()) { Student s = (Student) it.next(); // 拿这个元素到新集合去找，看有没有 if (!newArray.contains(s)) { newArray.add(s); } } // 遍历新集合 for (int x = 0; x < newArray.size(); x++) { Student s = (Student) newArray.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } }
4.2 Vector
【Vector类概述】
底层数据结构是数组，查询快，增删慢
线程安全，效率低
注：Vector很少用了，现在ArrayList基本上取代了Vector。
【Vector类特有功能】
添加功能：public void addElement(Object obj) -- add()
获取功能：
public Object elementAt(int index) -- get()
public Enumeration elements() -- Iterator iterator()
boolean hasMoreElements() hasNext()
Object nextElement() next()
public class VectorDemo { public static void main(String[] args) { // 创建集合对象 Vector v = new Vector(); // 添加功能 v.addElement("hello"); v.addElement("world"); v.addElement("java"); // 遍历 for (int x = 0; x < v.size(); x++) { String s = (String) v.elementAt(x); System.out.println(s); } System.out.println("------------------"); Enumeration en = v.elements(); // 返回的是实现类的对象 while (en.hasMoreElements()) { String s = (String) en.nextElement(); System.out.println(s); } } }
4.3 LinkedList
【LinkedList类概述】
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
【LinkedList类特有功能】
A:添加功能
public void addFirst(Object e)
public void addLast(Object e)
B:获取功能
public Object getFirst()
public Obejct getLast()
C:删除功能
public Object removeFirst()
public Object removeLast()
public class LinkedListDemo { public static void main(String[] args) { // 创建集合对象 LinkedList link = new LinkedList(); // 添加元素 link.add("hello"); link.add("world"); link.add("java"); // public void addFirst(Object e) // link.addFirst("javaee"); // public void addLast(Object e) // link.addLast("android"); // public Object getFirst() // System.out.println("getFirst:" + link.getFirst()); // public Obejct getLast() // System.out.println("getLast:" + link.getLast()); // public Object removeFirst() System.out.println("removeFirst:" + link.removeFirst()); // public Object removeLast() System.out.println("removeLast:" + link.removeLast()); // 输出对象名 System.out.println("link:" + link); } }
【练习】
请用LinkedList模拟栈数据结构的集合，并测试
注意，题目的意思是：你自己的定义一个集合类，在这个集合类内部可以使用LinkedList模拟。
MyStack.java
/** * 自定义的栈集合 */ public class MyStack { private LinkedList linkedList; public MyStack() { linkedList = new LinkedList(); } public void add(Object obj) { linkedList.addFirst(obj); } public Object get() { return linkedList.removeFirst(); } public boolean isEmpty() { return linkedList.isEmpty(); } }
MyStackDemo.java
/** * MyStack的测试 */ public class MyStackDemo { public static void main(String[] args) { // 创建集合对象 MyStack myStack = new MyStack(); // 添加元素 myStack.add("hello"); myStack.add("world"); myStack.add("java"); while (!myStack.isEmpty()) { System.out.println(myStack.get()); } } }
五、List集合的综合练习
【题目一】
集合的嵌套遍历
需求：
我们班有学生，每一个学生都是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
但是呢，我们旁边还有班级，每个班级也是一个ArrayList<Student>。
而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
就是这个样子的：ArrayList<ArrayList<Student>>
public class ArrayListDemo { public static void main(String[] args) { // 创建大集合 ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<>(); // 创建第一个班级的学生集合 ArrayList<Student> firstArrayList = new ArrayList<>(); // 创建学生 Student s1 = new Student("唐僧", 30); Student s2 = new Student("孙悟空", 29); Student s3 = new Student("猪八戒", 28); Student s4 = new Student("沙僧", 27); Student s5 = new Student("白龙马", 26); // 学生进班 firstArrayList.add(s1); firstArrayList.add(s2); firstArrayList.add(s3); firstArrayList.add(s4); firstArrayList.add(s5); // 把第一个班级存储到学生系统中 bigArrayList.add(firstArrayList); // 创建第二个班级的学生集合 ArrayList<Student> secondArrayList = new ArrayList<Student>(); // 创建学生 Student s11 = new Student("诸葛亮", 30); Student s22 = new Student("司马懿", 28); Student s33 = new Student("周瑜", 26); // 学生进班 secondArrayList.add(s11); secondArrayList.add(s22); secondArrayList.add(s33); // 把第二个班级存储到学生系统中 bigArrayList.add(secondArrayList); // 创建第三个班级的学生集合 ArrayList<Student> thirdArrayList = new ArrayList<Student>(); // 创建学生 Student s111 = new Student("宋江", 40); Student s222 = new Student("吴用", 35); Student s333 = new Student("高俅", 30); Student s444 = new Student("李师师", 22); // 学生进班 thirdArrayList.add(s111); thirdArrayList.add(s222); thirdArrayList.add(s333); thirdArrayList.add(s444); // 把第三个班级存储到学生系统中 bigArrayList.add(thirdArrayList); // 遍历集合 for (ArrayList<Student> students : bigArrayList) { for (Student student : students) { System.out.println(student.getName() + "---" + student.getAge()); } } } }
【题目二】
获取10个1-20之间的随机数，要求不能重复
/** * 用数组实现，但是数组的长度是固定的，长度不好确定。所以我们使用集合实现。 * 分析： * A:创建产生随机数的对象 * B:创建一个存储随机数的集合。 * C:定义一个统计变量。从0开始。 * D:判断统计遍历是否小于10 * 是:先产生一个随机数，判断该随机数在集合中是否存在。 * 如果不存在:就添加，统计变量++。 * 如果存在:就不搭理它。 * 否：不搭理它 * E:遍历集合 */ public class RandomDemo { public static void main(String[] args) { // 创建产生随机数的对象 Random random = new Random(); // 创建一个存储随机数的集合 ArrayList<Integer> arrayList = new ArrayList<>(); // 定义一个统计变量。从0开始。 int count = 0; // 判断统计遍历是否小于10 while (count < 10) { //先产生一个随机数 int number = random.nextInt(20) + 1; //判断该随机数在集合中是否存在。 if (!arrayList.contains(number)) { //如果不存在:就添加，统计变量++。 arrayList.add(number); count++; } } // 遍历集合 for (Integer i : arrayList) { System.out.println(i); } } }
【题目三】
键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
/** * 分析： * A:创建键盘录入数据对象 * B:键盘录入多个数据,我们不知道多少个，所以用集合存储 * C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了 * D:把集合转成数组 * E:对数组排序 * F:获取该数组中的最大索引的值 */ public class ArrayListDemo { public static void main(String[] args) { // 创建键盘录入数据对象 Scanner sc = new Scanner(System.in); // 键盘录入多个数据,我们不知道多少个，所以用集合存储 ArrayList<Integer> arrayList = new ArrayList<>(); // 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了 while (true) { System.out.println("请输入数据："); int number = sc.nextInt(); if (number != 0) { arrayList.add(number); } else { break; } } // 把集合转成数组 // public <T> T[] toArray(T[] a) Integer[] i = new Integer[arrayList.size()]; arrayList.toArray(i); // 对数组进行排序 Arrays.sort(i); // 获取该数组中的最大索引的值 System.out.println("数组是:" + Arrays.toString(i) + "最大值是:" + i[i.length - 1]); } }
