【Java基础】-【集合：List接口】

一、List

1.List接口概述

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。

2.List接口成员方法

①添加功能

void add(int index,E element)
在指定位置添加元素。

	// 创建集合对象
	List list = new ArrayList(); 
	// 添加元素
	list.add("hello");
	list.add("world");
	list.add("java");

	// void add(int index,Object element):在指定位置添加元素，非覆盖
	// list.add(1, "android");//没有问题
	// list.add(11, "javaee");//有问题 IndexOutOfBoundsException
	// list.add(3, "javaee"); //没有问题
	// list.add(4, "javaee"); //有问题 IndexOutOfBoundsException

②获取功能

E get(int index)
获取指定位置的元素。

③列表迭代器

ListIterator listIterator()
List集合特有的迭代器。
-特有功能：
boolean hasPrevious()
E previous()
注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。

④删除功能

E remove(int index)
根据索引删除元素,返回被删除的元素。

⑤修改功能

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

并发修改异常

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:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

产生原因：
迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
解决方案：

	// 方式1：迭代器迭代元素，迭代器修改元素
	
	// 而Iterator迭代器却没有添加功能，所以使用其子接口ListIterator
	ListIterator lit = list.listIterator();
	
	while (lit.hasNext()) {
		String s = (String) lit.next();
		if ("world".equals(s)) 
		{
		lit.add("javaee");//限制：元素是跟在刚才迭代的元素后面的。
		}
	}

	// 方式2：集合遍历元素，集合修改元素(普通for)
	
	for (int x = 0; x < list.size(); x++) 
	{
		String s = (String) list.get(x);
		if ("world".equals(s)) 
		{
			list.add("javaee");//限制：元素在最后添加的。
		}
	}

3.List的子类特点

①ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
②Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
③LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
按需求使用：
查询多：ArrayList
增删多：LinkedList

二、ArrayList

1.ArrayList类概述

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

三、Vector

1.Vector类概述

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

2.特有功能

①添加功能

public void addElement(Object obj)

②获取功能

public Object elementAt(int index)**
public Enumeration elements()

public Enumeration elements()	< = > Iterator iterator()
boolean hasMoreElements()	< = > hasNext()
Object nextElement() < = > next()

四、LinkedList

1.LinkedList类概述

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

2.特有功能

①添加功能

public void addFirst(Object e)
public void addLast(Object e)

②获取功能

public Object getFirst()
public Obejct getLast()

③删除功能

public Object removeFirst()
public Object removeLast()

思考

思考1：
ArrayList去除集合中字符串的重复值(字符串的内容相同)

答：

/* 分析：
 * 		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);
		}
	}
}


//新需求：不能创建新的集合，就在以前的集合上做。

	
// 由选择排序思想引入，我们就可以通过这种思想做这个题目
// 拿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--;//避免两个连续相同的字符串在remove之后索引自动前移避开比较
		}
	}
}

	// 遍历集合
	Iterator it = array.iterator();
	while (it.hasNext()) {
		String s = (String) it.next();
		System.out.println(s);
	}

---

思考2：
ArrayList去除集合中重复对象

答：

public class ArrayListDemo {
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)) 
		// contains()方法的底层依赖的是equals()方法。
		//而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法
		//Object()的equals()默认比较的是地址值
		//按照我们自己的需求，比较成员变量的值，重写equals()即可。
		{
			newArray.add(s);
		}
	}

	// 遍历新集合
	for (int x = 0; x < newArray.size(); x++) {
		Student s = (Student) newArray.get(x);
		System.out.println(s.getName() + "---" + s.getAge());
	}
}

---

思考3：
请用LinkedList模拟栈数据结构的集合，并测试。

答：

题目的意思是：
	自己定义一个集合类，在这个集合类内部可以使用LinkedList模拟。
import java.util.LinkedList;

/**
 * 自定义的栈集合
 * 
 * @author 刘织忋
 * @version V1.0
 */
public class MyStack {
	private LinkedList link;

	public MyStack() {
		link = new LinkedList();
	}

	public void add(Object obj) {
		link.addFirst(obj);
	}

	public Object get() {
		// return link.getFirst();
		return link.removeFirst();
	}

	public boolean isEmpty() {
		return link.isEmpty();
	}
}