一、List接口

1，List接口：存储有序的，可以重复的元素.---相当于“动态”数组

2，方法：删除remove(int index) 修改set(int index,Object obj) 获取get(int index)插入add(int index,Object obj)

3，添加进List集合中的元素（或对象）所在的类一定要重写equals()方法

ArrayList（主要的实现类）

LinkedList（更适用于频繁的插入、删除操作）

Vector（古老的实现类、线程安全的，但效率要低于ArrayList）

二、ArraList

1，ArrayList类支持3个构造方法。

//1，Arraylist() 这个构造方法构造了一个空的链表

List list1 =new ArrayList();

// 2，ArrayList(Collection<? extends E> c) 这个构造方法构造了一个包含指定元素集合的链表,字符E表示集合中元素的类型。

ArrayList list2 =new ArrayList();

//3,ArrayList(int initialCapacity) 构造了一个指定大小但内容为空的链表。initialCapacity参数就是初始容量大小。

ArrayList list3 =new ArrayList(7);

注意：ArrayList类只支持对象类型，不支持 基础数据类型。就是说ArrayList对象只能存放对象，不能存放基础数据类型的数据。

2，ArrayList常用方法

增加元素到链表中

boolean add(Element e)  // 增加指定元素到链表尾部.

void add(int index, Element e) // 第一位是0  增加指定元素到链表指定位置.

从链表中删除元素

void clear()  //从链表中删除所有元素.

E remove(int index)  // 删除链表中指定位置的元素.

protected void removeRange(int start, int end) // 删除链表中从某一个位置开始到某一个位置结束的元素。

获取链表中的元素

E get(int index)

获取链表中指定位置处的元素.

Object[] toArray()

获取一个数组，数组中所有元素是链表中的元素.（即将链表转换为一个数组）

修改某个元素

E set(int index, E element)

将链表中指定位置上的元素替换成新元素。

搜索元素

boolean contains(Object o)

如果链表包含指定元素，返回true.

int indexOf(Object o)

返回元素在链表中第一次出现的位置，如果返回-1，表示链表中没有这个元素。

int lastIndexOf(Object o)

返回元素在链表中最后一次出现的位置，如果返回-1，表示链表中没有这个元素。

检查链表是否为空

boolean isEmpty()

返回true表示链表中没有任何元素.

获取链表大小

int size()

返回链表长度（链表包含元素的个数）.

3，循环遍历数组

ArrayList list =new ArrayList();

// 遍历arraylist中的元素

// 第1种方法: 循环使用元素的索引和链表的大小

for (int i =0; i < list.size(); i++) {

System.out.println("Index: " + i +" - Item: " + list.get(i));

}

// 第2种方法:使用foreach循环

for (String str : list) {

System.out.println("Item is: " + str);

}

// 第3种方法:使用迭代器

// hasNext(): 返回true表示链表链表中还有元素

// next(): 返回下一个元素

for (Iterator it = list.iterator(); it.hasNext();) {

System.out.println("Item is: " + it.next());

}

三、LinkedList

1,LinkedList简介

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

LinkedList 实现 List 接口，能对它进行队列操作。

LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。

LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

2，构造函数

// 默认构造函数

LinkedList()

// 创建一个LinkedList，保护Collection中的全部元素。

LinkedList(Collection collection)

3，基本方法

boolean      add(E object)

void          add(int location, E object)  在指定位置插入一个元素。

boolean      addAll(Collection<? extends E> collection)

boolean      addAll(int location, Collection<? extends E> collection)

void          addFirst(E object)  在链表头部插入一个元素。

void          addLast(E object)  在链表尾部添加一个元素。

void          clear()

Object        clone()

boolean      contains(Object object)

Iterator<E>  descendingIterator()

E            element()

E            get(int location)  从当前链表中获取指定位置的元素。

E            getFirst()  从当前链表中获取第一个元素。

E            getLast()  从当前链表中获取最后一个元素。

int          indexOf(Object object)

int          lastIndexOf(Object object)

ListIterator<E>    listIterator(int location)

boolean      offer(E o)

boolean      offerFirst(E e)

boolean      offerLast(E e)

E            peek()

E            peekFirst()

E            peekLast()

E            poll()

E            pollFirst()

E            pollLast()

E            pop()

void          push(E e)

E            remove()  从当前链表中移除指定的元素。

E            remove(int location) 从当前链表中移除指定位置的元素。

boolean      remove(Object object)

E            removeFirst()

boolean      removeFirstOccurrence(Object o)

E            removeLast()

boolean      removeLastOccurrence(Object o)

E            set(int location, E object)

int          size()

<T> T[]      toArray(T[] contents)

Object[]    toArray()

4、遍历

// 默认构造函数LinkedList()

List list =new LinkedList<>();

list.add("1");

list.add("2");

//第一种，通过迭代器遍历。即通过Iterator去遍历。

for(Iterator iter = list.iterator(); iter.hasNext();){

String t= (String) iter.next();

}

//第二种 通过快速随机访问遍历LinkedList

int size = list.size();

for (int i=0; i

String t =(String)list.get(i);

}

//第三种 通过另外一种for循环来遍历LinkedList

for (String t:list){

System.out.println(t);

}

四、Vector

1，简介

Vector 可实现自动增长的对象数组。

java.util.vector提供了向量类(Vector)以实现类似动态数组的功能。

创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。

对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况，可以考虑使用向量类。

2，构造方法： 

public vector() 

publicvector(intinitialcapacity,int capacityIncrement) 

publicvector(intinitialcapacity)

使用第一种方法系统会自动对向量进行管理，若使用后两种方法，则系统将根据参数，initialcapacity设定向量对象的容量（即向量对象可存储数据的大小），当真正存放的数据个数超过容量时。系统会扩充向量对象存储容量。

参数capacityincrement给定了每次扩充的扩充值。当capacityincrement为0的时候，则每次扩充一倍，利用这个功能可以优化存储。

3，基本方法

插入功能

（1）adddElement(Object obj)  将obj插入向量的尾部。obj可以是任何类型的对象。对同一个向量对象，亦可以在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数组转换成相应的对象。

例如：要插入整数1时，不要直接调用v1.addElement(1),正确的方法为：

Vector v1 =new Vector();

Integer integer1 =newInteger(1);

v1.addElement(integer1);

（2）setElementAt(Object obj,int index)    将index处的对象设置成obj，原来的对象将被覆盖。 

（3） insertElementAt(Object obj,int index)    在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。

删除功能： 

(1) void removeElement(Object obj)

从向量中删除obj,若有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。

(2)  void removeAllElement(); 删除向量所有的对象

(3)  void removeElementAt(int index)  删除index所指的地方的对象

查询搜索功能： 

(1)int indexOf(Object obj) 从向量头开始搜索obj,返回所遇到的第一个obj对应的下标，若不存在此obj,返回-1.

(2) int indexOf(Object obj,int index)  从index所表示的下标处开始搜索obj.

(3) int lastindexOf(Object obj) 从向量尾部开始逆向搜索obj.

(4) int lastIndex(Object obj,int index) 从index所表示的下标处由尾至头逆向搜索obj.

(5)synchornized firstElement()  获取向量对象中的首个obj

(6)Object lastElement()  获取向量对象的最后一个obj

4，遍历

Vector hs =new Vector();

hs.add("aa");

hs.add("bb");

//第一种方法

Iterator iterator = hs.iterator();

while (iterator.hasNext()) {

System.out.println(iterator.next());

}

//第二种方法

Enumeration elements = hs.elements();

while (elements.hasMoreElements()) {

System.out.println(elements.nextElement());

}