List接口

Collection有两个子接口:List，Set.都可以用迭代器:Iterator iterator() ;进行遍历

        List集合的特点:

        有序的 (存储和取出一致),可以允许重复元素

        Set集合的特点:（以后讲，这次先讲List集合）

        无序性(不能保证迭代的顺序,基于hashMap),并且元素不能重复

List集合的特有功能:
添加功能
void add(int index,Object element):在指定位置处添加指定元素
获取功能
Object get(int index)返回列表中指定位置的元素。
ListIterator listIterator():列表迭代器
删除功能
Object remove(int index):删除指定位置处的元素
        修改功能

Object set(int index, Object element):用指定element元素替换掉指定位置处的元素

List有自己专属的迭代遍历方法，列表迭代器：ListIterator listIterator():列表迭代器

ListIterator接口中:
boolean hasNext()  :判断是否有下一个可以迭代的元素(正向遍历)
Object next():获取下一个元素
boolean hasPrevious():判断是否有上一个可以迭代 元素(逆向遍历)
Object previous():返回上一个元素

逆向迭代(遍历),单独使用没意义,前提,要先正向遍历

下面我们通过代码来体会一下：

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

public class ListDemo {
	
	public static void main(String[] args) {
		//创建集合对象
		List list = new ArrayList();
		
		//添加元素
		list.add("hello") ;
		list.add("world") ;
		list.add("hello") ;
		list.add("java") ;
		list.add("javaee") ;
		list.add("javaee") ;
		list.add("android") ;
		list.add("android") ;
		
		System.out.println("list:"+list);
		
		//void add(int index,Object element):在指定位置处添加指定元素
		list.add(1, "javaee");

		//Object get(int index)返回列表中指定位置的元素。
		System.out.println("get():"+list.get(2));

		//Object remove(int index):删除指定位置处的元素
		System.out.println("remove():"+list.remove(3));
		
		//Object set(int index, Object element):用指定element元素替换掉指定位置处的元素
		System.out.println("set():"+list.set(2, "android"));
		System.out.println("list:"+list);
		System.out.println("-------------------------");
		
		//获取迭代器
		/*Iterator it = list.iterator() ;
		//遍历元素
		while(it.hasNext()) {
			String s = (String)it.next() ;
			System.out.println(s+"---"+s.length());
		}*/
		
		//ListIterator listIterator():列表迭代器，List的专属迭代方式
		ListIterator it2 = list.listIterator() ;
		//正向遍历
		while(it2.hasNext()) {
			String s = (String)it2.next() ;
			System.out.println(s+"---"+s.length());
		}
		System.out.println("--------------------------");
		//逆向遍历，必须得以正向遍历为前提，否则没有意义
		while(it2.hasPrevious()) {
			String s = (String)it2.previous() ;
			System.out.println(s+"---"+s.length());
		}
	}
}

运行结果：

list:[hello, world, hello, java, javaee, javaee, android, android]
get():world
remove():hello
set():world
list:[hello, javaee, android, java, javaee, javaee, android, android]
-------------------------
hello---5
javaee---6
android---7
java---4
javaee---6
javaee---6
android---7
android---7
--------------------------
android---7
android---7
javaee---6
javaee---6
java---4
android---7
javaee---6

hello---5

可以看出，List是有序的 (存储和取出一致),并且可以允许重复元素，并且可以用ListIterator来逆序遍历，但这是以正向遍历为前提的。在实际的开发过程中，我们还是主要使用Iterator迭代器来遍历，不太使用ListIterator

接下来我们来使用List存储自定义对象并遍历。这里遍历有两种方式：

1）Iterator iterator（）；

2）size（）和get（）相结合；

Student类：

public class Student {
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

测试类：

public class ListTest {
	
	public static void main(String[] args) {
		
		//创建集合对象
		List list = new ArrayList()	 ;
		
		//创建4个学生对象
		Student s1 = new Student("高圆圆", 27) ;
		Student s2 = new Student("赵又廷", 30) ;
		Student s3 = new Student("文章", 29) ;
		Student s4 = new Student("马伊琍", 39) ;
		
		list.add(s1) ;
		list.add(s2) ;
		list.add(s3) ;
		list.add(s4) ;
		
		//方式1:获取迭代器的方式
		Iterator it = list.iterator() ;
		while(it.hasNext()) {
			Student s = (Student)it.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
		System.out.println("--------------------------");
		
		//方式2:size()和get(int index)结合: 普通for循环
		for(int x =0 ;x < list.size() ; x ++) {
			Student s = (Student)list.get(x) ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

需求:

我有一个集合，如下List，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。假设:List集合 的元素:"hello","world","java"
按照正常的思路:
            Iterator it = list.iterator() ;
while(it.hasNext()) {
String s = (String)it.next() ;
//判断集合是否有"world"元素,有就添加一个新的元素
if("world".equals(s)) {
//添加元素
list.add("javaee") ;
}
}
完成了需求后发现出现异常: java.util.ConcurrentModificationException：当方法检测到对象的 并发修改，但不允许这种修改时，抛出此异常。

产生的原因:按照正常的需求,给集合添加元素,遍历,遍历同时,判断集合中是否有需要的元素,有就添加新元素,
遍历的时候,使用迭代器遍历,但是添加元素,使用集合添加元素.

集合添加了一个新的元素,迭代器不知道...

使用迭代器遍历元素,不能使用集合添加元素!

解决方案:
方式1:要么使用迭代器遍历,使用迭代器添加元素!

方式2:要么使用集合遍历,使用集合添加元素!

最终代码如下：

public class ListTest {
	
	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() ;
			//判断集合是否有"world"元素,有就添加一个新的元素
			if("world".equals(s)) {
				//添加元素
				list.add("javaee") ;
			}
		}*/
		
		//方式1:使用迭代器遍历,迭代器添加元素解决并发修改异常
		//ListIterator:列表迭代器中有add(object e):方法
	    /*ListIterator it = list.listIterator() ;
		while(it.hasNext()) {
			String s = (String)it.next() ;
			if("world".equals(s)) {
				//迭代器添加
				it.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") ;
			}
		}
		
		System.out.println("list:"+list);
		
	}
}

List集合有三个子实现类:

ArrayList
底层数据结构式数组结构,查询块,增删慢
从内存角度考虑:线程不安全的,不同步的,执行效率高

多线程:synchronized :同步的意思 解决线程安全问题
sychronized(锁对象){ 同步代码 
共享数据;
}
解决线程安全问题,通过同步可以解决,但是效率低了...

LinkedList
:底层数据结构式链表结构,查询慢,增删块
从内存角度考虑:线程不安全,不同步,执行效率高

Vector:
这是一个线程安全的类,
底层数据结构是数组:查询快,增删慢

线程安全的,同步,执行效率低!

这个我们下次再具体讲，List集合的基础部分就先到这里。