【Java学习笔记】List接口及其实现类

目录

1.List集合的特点

2.List集合的特有功能

2.1 添加功能

2.2 获取功能

2.3 删除功能

2.4 列表迭代器

 2.5 修改功能

3.并发修改异常的产生原因及解决方法

4.List集合的特有遍历功能

5.List的三个子类的特点

6.ArrayList案例

6.1 存储字符串并遍历

6.2 存储自定义对象并遍历

7.Vector的特有功能

7.1 添加功能

7.2 获取功能

8.LinkedList的特有功能

8.1 添加功能

8.2 获取功能

8.3 删除功能

---

1.List集合的特点

集合中的对象按照索引位置进行排序，可以有重复对象。

2.List集合的特有功能

2.1 添加功能

• void add(int index, Object element)：在指定位置添加元素

2.2 获取功能

• Object get(int index)：获取指定位置的元素

2.3 删除功能

• Object remove(int index)：根据索引删除元素，返回被删除的元素

2.4 列表迭代器

• ListIterator listIterator()：List集合特有的迭代器，该迭代器继承了Iterator迭代器，所以可以直接使用hasNext()和next()方法。列表迭代器有如下特有功能：
  • boolean hasPrevious():判断是否有元素
  • Object previous():获取上一个元素 

具体用法，参考以下代码：

package com.hw.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/**
 * 列表迭代器 ListIterator
 * 		listIterator()：List集合特有的迭代器，该迭代器继承了Iterator迭代器，所以可以直接使用hasNext()和next()方法。
 * 
 * 特有功能： 
 * 		Object previous():获取上一个元素 
 * 		boolean hasPrevious():判断是否有元素
 * 
 * @author HW
 * 
 */
public class ListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		List<String> list = new ArrayList<String>();

		// 添加元素
		list.add("Jmeter");
		list.add("Selenium");
		list.add("AirTest");
		
		// 遍历集合
		// 通过集合对象获取列表迭代器对象
		ListIterator<String> lit = list.listIterator();
		while (lit.hasNext()) {
			System.out.println(lit.next());
		}
		
		System.out.println("==========");
		
		// 逆向遍历集合，前提是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
		while(lit.hasPrevious()){
			System.out.println(lit.previous());
		}
	}
}

运行结果如下：

Jmeter
Selenium
AirTest
==========
AirTest
Selenium
Jmeter

 2.5 修改功能

• Object set(int index, Object element)：根据索引修改元素，返回被修改的元素

List集合特有功能的具体用法，参考以下代码：

// 创建集合对象
List<String> list = new ArrayList<String>();
		
// 添加元素
list.add("Jmeter");
list.add("Selenium");
list.add("AirTest");
		
System.out.println("原始数据：" + list);
		
// void add(int index,Object element):在指定位置添加元素
list.add(1, "Python");
		
System.out.println("在索引为1的位置添加元素后：" + list);
		
// Object get(int index):获取指定位置的元素
System.out.println("获取索引为2的元素：" + list.get(2));
		
System.out.println("修改元素前：" + list);
		
// Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
System.out.println("被修改的元素：" + list.set(3, "Fiddler"));
		
System.out.println("修改元素后：" + list);
		
// Object remove(int index)：根据索引删除元素,返回被删除的元素
System.out.println("删除索引为0的元素：" + list.remove(0));
		
System.out.println("最终元素：" + list);

运行结果如下：

原始数据：[Jmeter, Selenium, AirTest]
在索引为1的位置添加元素后：[Jmeter, Python, Selenium, AirTest]
获取索引为2的元素：Selenium
修改元素前：[Jmeter, Python, Selenium, AirTest]
被修改的元素：AirTest
修改元素后：[Jmeter, Python, Selenium, Fiddler]
删除索引为0的元素：Jmeter
最终元素：[Python, Selenium, Fiddler]

3.并发修改异常的产生原因及解决方法

需求：有一个集合[Hello, World, Java]，想判断里面有没有"world"这个元素，如果有，就添加一个"javaee"元素，请写代码实现。 

代码如下：

// 创建集合对象
List<String> list = new ArrayList<String>();

// 添加元素
list.add("hello");
list.add("world");
list.add("Java");

// 遍历集合
// 使用迭代器遍历
Iterator<String> it = list.iterator();
while (it.hasNext()) {
	String str = it.next();
	if (str.equals("world")) {
		list.add("javaee");
	}
}

System.out.println("list：" + list);

运行结果报异常ConcurrentModificationException，如下图所示：

ConcurrentModificationException：当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。 

产生并发修改异常的原因：迭代器是依赖于集合而存在的，在判断成功后，集合中新添加了元素，而迭代器却不知道，所以就报异常了，这个异常叫并发修改异常。其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。

并发修改异常的解决方法：

• 方式一：迭代器遍历元素，迭代器修改元素

// 方式一：迭代器遍历元素，迭代器修改元素
// 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
ListIterator<String> lit = list.listIterator();
while (lit.hasNext()) {
	String str = lit.next();
	if (str.equals("world")) {
		lit.add("javaee");
	}
}

• 方式二：集合遍历元素，集合修改元素（即普通for循环）

// 方式二：集合遍历元素，集合修改元素
for (int i = 0; i < list.size(); i++) {
	String str = list.get(i);
	if (str.equals("world")) {
		list.add("javaee");
	}
}

完整代码如下:

package com.hw.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * 需求：有一个集合[Hello, World, Java]，想判断里面有没有"world"这个元素，如果有，就添加一个"javaee"元素，请写代码实现。
 * 
 * ConcurrentModificationException：当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。 
 * 
 * @author HW
 * 
 */
public class ConcurrentModificationExceptionDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<String> list = new ArrayList<String>();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("Java");

		// 遍历集合
		// 使用迭代器遍历
		/*Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			String str = it.next();
			if (str.equals("world")) {
				list.add("javaee");
			}
		}*/
		

		// 方式一：迭代器遍历元素，迭代器修改元素
		// 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
		/*ListIterator<String> lit = list.listIterator();
		while (lit.hasNext()) {
			String str = lit.next();
			if (str.equals("world")) {
				lit.add("javaee");
			}
		}*/

		// 方式二：集合遍历元素，集合修改元素
		for (int i = 0; i < list.size(); i++) {
			String str = list.get(i);
			if (str.equals("world")) {
				list.add("javaee");
			}
		}

		System.out.println("list：" + list);
	}
}

4.List集合的特有遍历功能

• size()方法和get()方法结合使用

// 创建集合对象
List<String> list = new ArrayList<String>();

// 添加元素
list.add("Jmeter");
list.add("Selenium");
list.add("AirTest");
list.add("Python");
list.add("Fiddler");
		
// 遍历集合
// List集合的特有遍历功能（普通for循环遍历集合）
for (int i = 0; i < list.size(); i++) {
	System.out.println(list.get(i));
}

5.List的三个子类的特点

ArrayList

• 底层数据结构是数组，查询快，增删慢
• 线程不安全，效率高

Vector

• 底层数据结构是数组，查询快，增删慢
• 线程安全，效率低

LinkedList

• 底层数据结构是链表，查询慢，增删快
• 线程不安全，效率高

6.ArrayList案例

6.1 存储字符串并遍历

// 创建集合对象
ArrayList<String> list = new ArrayList<String>();

// 添加元素
list.add("Jmeter");
list.add("Selenium");
list.add("AirTest");
list.add("Python");
list.add("Fiddler");
		
// 遍历集合
// 方式一：普通for循环遍历集合
for (int i = 0; i < list.size(); i++) {
	System.out.println(list.get(i));
}
		
System.out.println("==========");
		
// 方式二：迭代器遍历集合
// 通过集合对象获取迭代器对象
Iterator<String> it = list.iterator();
while (it.hasNext()) {
	System.out.println(it.next());
}

6.2 存储自定义对象并遍历

• Student(name, age)

// 创建集合对象
ArrayList<Student> list = new ArrayList<Student>();

// 创建学生对象
Student s1 = new Student("西施", 18);
Student s2 = new Student("貂蝉", 16);
Student s3 = new Student("昭君", 20);
Student s4 = new Student("杨贵妃", 22);

// 把学生对象添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);

// 遍历集合
// 方式一：通过迭代器对象遍历集合
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
	Student stu = it.next();
	System.out.println(stu.getName() + "---" + stu.getAge());
}

System.out.println("==========");

// 方式二：普通for循环遍历集合
for (int i = 0; i < list.size(); i++) {
	Student stu = list.get(i);
	System.out.println(stu.getName() + "---" + stu.getAge());
}

7.Vector的特有功能

7.1 添加功能

• public void addElement(Object obj)：添加元素

7.2 获取功能

• public Object elementAt(int index) ：获取指定索引位置的元素
• public Enumeration elements()
  • boolean hasMoreElements()：判断是否有下一个元素
  • Object nextElement()：获取元素

以上功能的具体用法，参考以下代码：

package com.hw.list;

import java.util.Enumeration;
import java.util.Vector;

/**
 * 添加功能 
 * 		public void addElement(Object obj)
 * 
 * 获取功能
 * 		public Object elementAt(int index) 
 * 		public Enumeration elements()
 * 			boolean hasMoreElements()：判断是否有下一个元素
 * 			Object nextElement():获取元素
 * @author HW
 *
 */
public class VectorDemo {
	public static void main(String[] args) {
		// 创建集合对象
		Vector<String> vector = new Vector<String>();
		
		// 添加元素
		vector.addElement("Fiddler");
		vector.addElement("AirTest");
		vector.addElement("Selenium");
		
		System.out.println("vector集合：" + vector);
		
		// 获取指定位置的元素
		System.out.println("elementAt(1)：" + vector.elementAt(1));

		// 通过集合对象获取枚举对象
		Enumeration<String> enu = vector.elements();
		// 判断是否有下一个元素
		while (enu.hasMoreElements()) {
			// 获取元素
			System.out.println(enu.nextElement());
		}
	}
}

8.LinkedList的特有功能

8.1 添加功能

• public void addFirst(Object e)：在集合的开头插入元素
• public void addLast(Object e)：在集合的结尾插入元素

8.2 获取功能

• public Object getFirst()：获取集合的第一个元素
• public Obejct getLast()：获取集合的最后一个元素

8.3 删除功能

• public Object removeFirst()：移除集合的第一个元素
• public Object removeLast()：移除集合的最后一个元素

// 创建集合对象
LinkedList<String> list = new LinkedList<String>();
		
// 添加元素
list.add("Selenium");
list.add("Jmeter");
list.add("Fiddler");
		
System.out.println("LinkedList集合：" + list);
		
System.out.println("==========在list集合的开头和结尾插入元素==========");
		
// 在list集合的开头插入元素
list.addFirst("AirTest");
// 在list集合的结尾插入元素
list.addLast("Java");
System.out.println("" + list);

System.out.println("返回list集合的第一个元素：" + list.getFirst());
System.out.println("返回list集合的最后一个元素：" + list.getLast());
		
System.out.println("移除list集合的第一个元素：" + list.removeFirst());
System.out.println("移除list集合的最后一个元素：" + list.removeLast());
		
System.out.println("最终元素：" + list);

运行结果如下：

LinkedList集合：[Selenium, Jmeter, Fiddler]
==========在list集合的开头和结尾插入元素==========
[AirTest, Selenium, Jmeter, Fiddler, Java]
返回list集合的第一个元素：AirTest
返回list集合的最后一个元素：Java
移除list集合的第一个元素：AirTest
移除list集合的最后一个元素：Java
最终元素：[Selenium, Jmeter, Fiddler]