List集合

1、java.util.Collection [I]

+--java.util.List [I]

+--java.util.ArrayList [C]

+--java.util.LinkedList [C]

+--java.util.Vector [C]

+--java.util.Stack [C]

2、集合概念以及集成结构：

Collecation：集合层次中的根接口，JDK没有提供这个接口的实现类。

List：可以包含重复的元素，是一个有序的集合，提供了按索引访问的方式。

Set：不能包含重复的元素，子接口SortedSet是一个按照升序排列的元素的Set。

3、Collection接口：

1、 Collection是最基本的集合接口，

一个Collection代表一组Object的集合，这些Object被称作Collection的元素。

所有实现Collection接口的类都必须提供两个标准的构造函数：

无参数的构造函数用于创建一个空的Collection，

有一个Collection参数的构造函数用于创建一个新的Collection，

这个新的Collection与传入的Collection有相同的元素。

后一个构造函数允许用户复制一个Collection。

如何遍历Collection中的每一个元素？

不论Collection的实际类型如何，

它都支持一个iterator()的方法，该方法返回一个迭代子，

使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

Iterator it = collection.iterator(); // 获得一个迭代子

while(it.hasNext()) {

　　 Object obj = it.next(); // 得到下一个元素

}

4、泛型的使用：

泛型，即“参数化类型”。

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，

类似于方法中的变量参数，

此时类型也定义成参数形式（可以称之为类型形参），

然后在使用/调用时传入具体的类型（类型实参）

Java泛型中的标记符含义：

E - Element (在集合中使用，因为集合中存放的是元素)

T - Type（Java 类）

K - Key（键）

V - Value（值）

N - Number（数值类型）

？ - 表示不确定的java类型

S、U、V - 2nd、3rd、4th types

5、Iterator：

Java中的Iterator功能比较简单，并且只能单向移动：

　　 a、使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，

它返回序列的第一个元素。

注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

　　 b、使用next()获得序列中的下一个元素。

　　 c、 使用hasNext()检查序列中是否还有元素。

　　 d、 使用remove()将迭代器新返回的元素删除。

　　 Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，

它可以从两个方向遍历List，也可以从List中插入和删除元素。

6、List接口：

List继承自Collection接口。

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。

用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，

这类似于Java的数组。

跟Set集合不同的是，List允许有重复元素。

对于满足e1.equals(e2)条件的e1与e2对象元素，

可以同时存在于List集合中。

当然，也有List的实现类不允许重复元素的存在。

除了具有Collection接口必备的iterator()方法外，

List还提供一个listIterator()方法，返回一个 ListIterator接口，

和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，

允许添加，删除，设定元素， 还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

7、Vector：

Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，

虽然和ArrayList创建的 Iterator是同一接口，

但是，因为Vector是同步的，当一个

Iterator被创建而且正在被使用，

另一个线程改变了Vector的状态（例如，添加或删除了一些元素），

这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

8、Stack

Stack继承自Vector，实现一个后进先出的堆栈。

Stack提供5个额外的方法使得Vector得以被当作堆栈使用。

基本的push和pop方法，

还有peek方法得到栈顶的元素，

empty方法测试堆栈是否为空，

search方法检测一个元素在堆栈中的位置。

Stack刚创建后是空栈。

9、ArrayList 和 LinkedList 的区别（通过分别用ArrayList 和LinkedList尾部添加900000个数字所需要的时间来得出的结果，在分别插入1000个元素去所需的时间

在去遍历刚才添加和插入的所以元素得到所用的时间（其中LinkedList遍历的元素为所有数的10分之1），在去删除刚才的元素的200分之1取得时间）：

a、ArrayList尾部添加快，ArrayList,添加元素122 b、LinkedList尾部添加慢，LinkedList,添加元素1651

插入慢，ArrayList,插入元素5940 插入快，LinkedList,插入元素107

遍历快，ArrayList,遍历元素3 遍历慢，LinkedList,遍历元素71852

删除慢；ArrayList,删除元素2734 删除快，LinkedList,删除元素90

public class CoreJavaDay14_2 {

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

ArrayList<String> arrayList = new ArrayList<String>();

LinkedList<String> linkedList = new LinkedList<String>();

//ArrayList添加元素

long time1 = System.currentTimeMillis();

for (int i = 1; i <= 900000; i++) {

arrayList.add(String.valueOf(i));

}

long time2 = System.currentTimeMillis();

System.out.println("ArrayList,添加元素" + (time2 - time1));

//LinkedList 添加元素

long time3 = System.currentTimeMillis();

for (int i = 1; i <= 900000; i++) {

linkedList.add(String.valueOf(i));

}

long time4 = System.currentTimeMillis();

System.out.println("LinkedList,添加元素" + (time4 - time3));

//ArrayList插入元素

long time1_1 = System.currentTimeMillis();

for (int i = 0; i <= 10000; i++) {

arrayList.add(i / 2, String.valueOf(i));

}

long time2_1 = System.currentTimeMillis();

System.out.println("ArrayList,插入元素" + (time2_1 - time1_1));

//LinkedList 插入元素

long time3_1 = System.currentTimeMillis();

for (int i = 0; i <= 10000; i++) {

linkedList.add(i / 2,String.valueOf(i));

}

long time4_1 = System.currentTimeMillis();

System.out.println("LinkedList,插入元素" + (time4_1 - time3_1));

//ArrayList遍历元素

long time1_2 = System.currentTimeMillis();

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

arrayList.get(i);

}

long time2_2 = System.currentTimeMillis();

System.out.println("ArrayList,遍历元素" + (time2_2 - time1_2));

//LinkedList 遍历元素

long time3_2 = System.currentTimeMillis();

for (int i = 0; i < linkedList.size() / 10; i++) {

linkedList.get(i);

}

long time4_2 = System.currentTimeMillis();

System.out.println("LinkedList,遍历元素" + (time4_2 - time3_2));

//ArrayList删除元素

long time1_3 = System.currentTimeMillis();

for (int i = 0; i < arrayList.size() / 200; i++) {

arrayList.remove(i);

}

long time2_3 = System.currentTimeMillis();

System.out.println("ArrayList,删除元素" + (time2_3 - time1_3));

//LinkedList 删除元素

long time3_4 = System.currentTimeMillis();

for (int i = 0; i < linkedList.size() / 200; i++) {

linkedList.remove(i);

}

long time4_4 = System.currentTimeMillis();

System.out.println("LinkedList,删除元素" + (time4_4 - time3_4));

}

}