JAVA基础知识之List集合

• List接口和ListIterator接口介绍

1. List集合新增方法
2. List集合判断元素重复的标准
3. ListIterator

• List.ArrayList和List.Vector
• 固定长度的List

List接口和ListIterator接口介绍

List是一种元素有序，可重复的集合。默认是按元素插入顺序排序。可以像数组一样按照索引来访问元素。因此List接口提供了除Collection接口方法之外的额外方法，它们都是按索引来访问元素，

List集合新增方法

void add(int index, Object element)

boolean addAll(int index, Colection c); 将集合C的所有元素都插入到List集合的index索引处。

void get(int index)

int indexOf(Object o); 返回对象O在集合第一次出现的索引

int lastOf(Object o);

Object remove(int index):删除并返回集合在index索引处的元素

Object set(int index, Object element)：替换元素

List subList(int fromIndex, in toIndex); 返回从索引fromInddex到toIndex的子集合，这是List集合独有的方法。

void replaceAll(UnaryOperator operator):这个看不懂。。。

voidd sort(Comparator c)：根据Comparator规则对集合元素排序

List集合判断元素重复的标准

List判断两个元素相等的方法是，只要equals返回true即相等，下面是一个例子。

package collection.List;

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

class A {
	public boolean equals(Object obj) {
		return true;
	}
}

public class Lists {
	public static void main(String[] args) {
		List books = new ArrayList();
		books.add("book1");
		books.add("book2");
		books.add("book3");
		System.out.println(books);
		books.remove(new A());
		System.out.println(books);
		books.remove(new A());
		System.out.println(books);
	}
}

可以看到，每次执行books.remove(new A());的时候，都调用A类重写额equals，每次都返回true,因此每次在遍历books集合第一个元素的时候做对比的时候就返回了true，因此每次都会删除books集合第一个元素，执行结果如下，

[book1, book2, book3]
[book2, book3]
[book3]

ListIterator

ListIterator是List集合特有的方法， ListIterator接口是Iterator的子接口，除了提供基本的hasNext, next, remove方法外，还提供了额外的向前迭代和添加元素的方法，值得注意的是，必须先向后迭代之后，再向前迭代才有意义，否则就不会有结果输出。

boolean hasPrevious():是否有上一个元素。 （对应 hasNext方法）

Object previous(); 返回上一个元素（对应next方法）

void add(Object o) 添加一个元素（对应remove方法）

下面举例说明ListIterator的用法

package collection.List;

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

public class ListIterators {
	public static void main(String[] args) {
		String[] books = {"book1","book2","book3","book4"};
		List bookList = new ArrayList();
		for(int i=0; i<books.length; i++) {
			bookList.add(books[i]);
		}

		ListIterator lit = bookList.listIterator();
		while(lit.hasNext()) {
			System.out.println(lit.next());
			System.out.println("------------------------");
		}

		System.out.println("开始反向迭代");
		while(lit.hasPrevious()) {
			System.out.println(lit.previous());
			System.out.println("------------------------");
		}

	}
}

执行结果，

book1
------------------------
book2
------------------------
book3
------------------------
book4
------------------------
开始反向迭代
book4
------------------------
book3
------------------------
book2
------------------------
book1
------------------------

List.ArrayList和List.Vector

List.ArrayList和List.Vector是List接口的两个典型的实现类。ListArray底层其实就是封装了一个数组来保存元素，这个数组的容量允许扩展。这个数组的有一个初始容量initialCapacity（默认为10），当新元素插入ArrayList时，此数组容量会自动增加；而当需要插入大量元素时候，可以通过ensureCapacity(int i)这个方法增加足够的容量，从而减少多次分配内存空间的次数。下面是JDK1.7源码中，ArrayList的代码，

//JDK源码， ArrayList
...
    public boolean add(Object obj)
    {
        ensureCapacityInternal(size + 1);
        elementData[size++] = obj;
        return true;
    }
...
private transient Object elementData[];

可见一个ArrayList底层其实就是封装了一个Object类型的数组elementData。

Vector和ArrayList的功能大体相同，只是ArrayList是线程非安全，而Vector是线程安全的，而且Vector非常古老，在JAVA集合框架出来之前就有了，所以从多方面来说，Vector的性能是比不上ArraryList的，因此通常情况下推荐用ArrayList.

ArrayList和Vector提供了两个重新分配Object数组的方法，即ensureCapacity(int i)，扩展i个空间。   void trimToSize(), 清理集合多占用的空间（即将容量减小到实际元素的个数）

Vector还提供了一个子类Stack, 即一个遵循LIFO的栈容器。提供了以下方法：Object peek(), 获取栈顶元素。  Object pop() 出栈， void push(Object item) 入栈。

固定长度的List (Arrays类中的内部类ArrayList)

上面介绍的ArrayList是List接口的一个实现类， 此外，通过数组工具Arrays的asList()方法，可以返回一个Arrays工具内部类ArrayList的实例对象。而这个ArrayList是一个固定长度的List集合，程序只能遍历数组，不能增加，删除数组元素，否则会抛出异常。下面是JDK 1.7源码Arrays中ArrayList的源码

public class Arrays
{
    private static class ArrayList extends AbstractList
        implements RandomAccess, Serializable
    {

        public int size()
        {
            return a.length;
        }

......

从JDK源码中可以看到，根本就没有定义成动态数组，即Arrays工具类中的ArrayList长度是不可变的，即不可用添加(add)元素，也不可以删除(remove)元素，如下例子，

package collection.List;

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

public class FixeSizeList {
    public static void main(String[] args) {
        Integer[] varI = new Integer[] {9,5,5,-3,2};
        List fixeList = Arrays.asList(varI);
        System.out.println(fixeList.getClass());
        
        //会按照插入顺序打印出来
        System.out.println(fixeList);
        
        ListIterator lit = fixeList.listIterator();
        while(lit.hasNext()) {
            System.out.print(lit.next()+",");
        }
        System.out.println("\n==================");
        
        for(int i=0; i<varI.length; i++) {
            System.out.print(fixeList.get(i)+",");
        }
        System.out.println("\n==================");
        lit.hasNext();
        //lit.remove();
        lit.hasPrevious();
        //lit.add(new Integer(2));
        //fixeList.remove(new Integer(2));
        //fixeList.add(new Integer(2));
        
    }
}

如果取消上面的注释，将会抛出错误，如下面的结果。

class java.util.Arrays$ArrayList
[9, 5, 5, -3, 2]
9,5,5,-3,2,
==================
9,5,5,-3,2,
==================
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.remove(Unknown Source)
	at java.util.AbstractList$Itr.remove(Unknown Source)
	at collection.List.FixeSizeList.main(FixeSizeList.java:28)