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());//所以长度减一

}