List集合代表一个存放元素对象为有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引。
8.4.1 List接口和ListIterator接口
List作为Collection接口的子接口，可以使用Collection接口里的全部方法。由于List又是一个有序的集合，所以List集合中又增加了一些根据索引来操作集合元素的方法。
? void add(int index,Object element)：将元素element插入到List集合的index处。如果当前索引位置有元素对象，则将此元素对象及后面所有元素对象都向后移动一个索引位置。
? Boolean addAll(int index,Collection c)：将集合c所包含的所有元素都插入到List集合中的index索引位置。如果当前索引位置有元素对象，则将此元素对象及后面所有元素对象都向后移动一个索引位置。
? Object get(int index)：返回集合index索引位置的元素。
? Int indexOf(Object o)：返回对象o在List集合中第一次出现的位置索引。
? Int lastIndexOf(Object o)：返回对象o在List集合中最后一次出现的位置索引。
? Object remove(int index)：删除index索引位置的元素，并将此对象返回。同时此元素后面的所有元素索引向前前进一位。
? Object set(int index,Object element)：将index索引处的元素替换成element对象，并将被替换的元素返回。
? List subList(int fromIndex,int toIndex)：返回从元素索引fromIndex到索引toIndex处所有集合元素组成的子集合。左闭右开。
举例1：
Public static void main(String[] args) throws Exception{
List list = new ArrayList();
list.add("123");
list.add("456");
list.add(1, "789");
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println("=================");
System.out.println(list.indexOf("456"));
System.out.println("=================");
Object obj = list.remove(1);
System.out.println(obj);
System.out.println(list.size());
System.out.println("=================");
obj = list.set(1,"abc");
System.out.println(list.get(1));
List list1 = list.subList(0, 2);
System.out.println(list1.size());
}
ListIterator接口：List提供了一个listIterator()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，还提供了专门操作List的方法。方法如下：
? Boolean hasPrevious()：返回该迭代器关联的集合是否含有上一个元素。
? Object previous()：返回迭代器的上一个元素。
? void add()：在指定位置插入一个元素。
ListIterator与普通的Iterator进行对比，ListIterator增加向前迭代的功能，而且还通过add方法向List集合中添加元素。
举例1：
Public static void main(String[] args) throws Exception{
List list = new ArrayList();
list.add("123");
list.add("456");
list.add("789");
ListIterator iter = list.listIterator();
while(iter.hasNext()){
System.out.println(iter.next());
iter.add("abc");
}
System.out.println("===================");
while(iter.hasPrevious()){
System.out.println(iter.previous());
}
}
这里如果我在使用迭代器来迭代元素的时候，是不能通过集合来修改元素的，如果进行了修改，会抛出一个异常，并发修改异常。因为迭代器是依赖于集合而存在的，在判断成功后，如果你往集合中添加了新的元素，而这时迭代器是不知道的，它并不能跟着识别你新添加的元素，所以报并发修改异常。
那怎么解决这个问题：一是使用迭代修改。二是不使用迭代器遍历，而是使用普通循环遍历。而我们的普通 Iterator是无法完成添加操作的，只有ListIterator接口才能够实现添加操作。
8.4. ArrayList和Vector实现类
8.4.1ArrayList
ArrayList和Vector是List接口的典型实现，都是基于数组实现的List类。ArrayList和Vector都封装了一个动态的允许再分配的Object[]数组。
ArrayList和Vector的用法几乎完全一样，但是Vector与ArrayList相比较而言是属于古董级别，在JDK1.0时就已经存在。那时Java还没有提供系统的集合框架，Vector中提供了很多方法名很长的方法。从JDK1.2以后，Java提出系统集合框架之后，将Vector改为实现List接口，作为List的实现类之一，从而导致了Vector中存在了一些功能重复的方法。
因此尽量少用Vector，因为能用Vector的地方就能用ArrayList来代替。除此之外，ArrayList与Vector的显著区别是：ArrayList是线程不安全的，Vector是线程安全，所以Vector的性能要比ArrayList要低一些。即使是为了保证List集合的线程安全，同样不推荐使用Vector实现类，后面会介绍Collections工具类，它会使ArrayList变成线程安全的。
举例1：
package com.langsin.test;
public class Product {
//商品名称
private String p_name;
//商品编码
private String p_code;
//商品名称
private String p_price;
/**
* @return商品名称
*/
public String getP_name() {
return p_name;
}
/**
* @param商品名称
*/
public void setP_name(String p_name) {
this.p_name = p_name;
}
/**
* @return商品编码
*/
public String getP_code() {
return p_code;
}
/**
* @param商品编码
*/
public void setP_code(String p_code) {
this.p_code = p_code;
}
/**
* @return商品价格
*/
public String getP_price() {
return p_price;
}
/**
* @param商品价格
*/
public void setP_price(String p_price) {
this.p_price = p_price;
}
}
public static void main(String[] args) throws Exception{
List<Product> list = new ArrayList<Product>();
Product p1 = new Product();
p1.setP_code("JD001");
p1.setP_name("康佳32吋");
p1.setP_price("1900");
list.add(p1);
Product p2 = new Product();
p2.setP_code("JD002");
p2.setP_name("康佳32吋");
p2.setP_price("1900");
list.add(p2);
Product p3 = new Product();
p3.setP_code("JD003");
p3.setP_name("康佳32吋");
p3.setP_price("1900");
list.add(p3);
System.out.println("============================");
System.out.println("| 商品名称 | 商品编码 | 商品价格 |");
System.out.println("============================");
for(Product pt : list){
System.out.println("| "+pt.getP_name()+" | "+pt.getP_code()+" | "+pt.getP_price()+" |");
System.out.println("============================");
}
}
举例2：
这里做一个小练习，去除一个ArrayList集合（存放的是字符串）中的重复元素，将其存放在一个新的集合当中。
做法：1.循环遍历，不相同的放在新的集合中。
while(it.hasNext){
String s = (String)it.next();
if(!newArry.contains(s)){
newArry.add(s);
}
}
2.使用普通的for循环，拿当前索引的值与下一索引的值进行比较，如果相同，则删除下一索引的值。(只需要知道第一个就行了，第二个自己理解。
for(int i=0;i<arr.size()-1;i++){
for(int j=i+1;j<arr.size();j++){
if(arr.get(i).equals(arr.get(j))){
arr.remove(j);
//j--;
}
}
}
举例3：
这里做一个去除ArrayList集合当中重复对象，将不重复对象放在一个新的数组当中。怎么做呢。
while(it.hasNext){
Student s = (Student)it.next();
if(!newArry.contains(s)){
newArry.add(s);
}
}
我们会发现这么一个情况，发现所有的对象还都是在新的数组当中。因为contains()的底层中equals()方法，而我们并没有重写Student对象的equals()方法，所以我们默认使用的是Object当中的equals()方法。而Object当中的equals()方法默认比较的是地址值，所以，全部存放了。因为new出来的东西地址值都不一样，所以我们就要重写equals方法了。而我们通过之前的set集合我们知道了，我们不用自己写，我们自动生成就可以了。
这里说一个问题，我们要遍历一个集合有几种方式呢。
（1） for
（2） 增强for
（3） Iterator
最后带你们看一下ArrayList的toString()方法的原码。这里还是重复一个问题，如果你在一个类中没有找到你想要的方法，那你就到它的父类里边去找。
8.4.2Vector集合
Vector还提供了一个Stack子类，用于模拟“栈”数据结构。“栈”也是一种容器，遵循先进后出，后进先出的规范。
提供了如下常用方法：
? Object peek()：返回“栈”的第一个元素，并不将元素弹出“栈”，仍在“栈”中存放。
? Object pop()：返回“栈”的第一个元素，同时将元素对象弹出“栈”。
? Void push(Object item)：将元素对象加入到“栈”中。
举例1：
public static void main(String[] args) throws Exception{
Stack stack = new Stack();
stack.push("123");
stack.push("456");
stack.push("789");
Object obj = stack.peek(); //返回最后一个对象，对象仍然保存在栈中
System.out.println(obj);
System.out.println(stack.size()); //所以长度不发生变化
obj = stack.pop(); //返回最后一个对象，并将对象在栈中剔除
System.out.println(obj);
System.out.println(stack.size());//所以长度减一
}