Java基础学习——集合框架

1、什么是集合框架？

一类数据的容器，可以存取一类数据，都自己的数据结构（数组、队列、链表、图、树）。

2、系统的集合框架

Collection 接口<E>、Map接口<K,V>

3、Collection 接口<E>

3.1、Java.util.List 接口<E>: 1.有序的（谁先加，谁先遍历）2.可以重复

a、java.util.ArrayList<E>:基于数组：优点查询，插入麻烦

*ArrayList实现了大小可变的数组。它允许所有元素，包括null。ArrayList没有同步性。
*size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

*每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

常用方法:add(E e)：将指定的元素添加到此列表的尾部。

get (int index):返回此列表中指定位置上的元素。

size():返回此列表中的元素数(注：其实就是该ArrayList数组的长度). 

set (int index,E element):用指定的元素替代此列表中指定位置上的元素。

contains(Object o):如果此列表中包含指定的元素，则返回true.

[java]  view plain  copy

1. package 集合框架;  
2.   
3. import java.util.ArrayList;  
4.   
5. public class ArrayListTest {  
6.     public static void main(String[] args) {  
7.         ArrayList<Object> arraylist=new ArrayList<Object>();  
8.         //添加元素  
9.         arraylist.add(1);  
10.         arraylist.add(2);  
11.         arraylist.add("a");  
12.         arraylist.add("b");  
13.         arraylist.add('+');  
14.         arraylist.add('=');  
15.         //遍历  
16.         System.out.print("添加后的数组:");  
17.         for(int i=0;i<arraylist.size();i++){  
18.             System.out.print(arraylist.get(i)+" ");  
19.         }  
20.         System.out.println();  
21.         //替换指定位置的元素  
22.         arraylist.set(1, 5);  
23.         arraylist.set(5, '-');  
24.         //遍历  
25.         System.out.print("替换后的数组:");  
26.         for(int i=0;i<arraylist.size();i++){  
27.             System.out.print(arraylist.get(i)+" ");  
28.         }  
29.         System.out.println();  
30.         //查看该数组是否包含该元素  
31.         System.out.println("包含有5吗："+arraylist.contains(5));  
32.         System.out.println("包含有c吗："+arraylist.contains('c'));  
33.     }  
34.       
35. }  

结果:

b.java.util.LinkedList<E>:基于：链表：插入容易，访问麻烦
LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步性。如果多个线程同时访问一个LinkedList，则必须自己实现访问同步。

另一种解决方法是在创建List时构造一个同步的List：Listlist = Collections.synchronizedList(new LinkedList(...));

一些常用方法的使用：

[java]  view plain  copy

1. package 集合框架;  
2.   
3. import java.util.LinkedList;  
4.   
5. public class LinkedListTest {  
6.   
7.     public static void main(String[] args) {  
8.         LinkedList<Object> linkelist=new LinkedList<Object>();  
9.         linkelist.add(1);  
10.         linkelist.add(3);  
11.         linkelist.add('+');  
12.         linkelist.add('-');  
13.         linkelist.add("a");  
14.         linkelist.add("b");  
15.         //遍历  
16.         System.out.print("添加后的链表:");  
17.         for(int i=0;i<linkelist.size();i++){  
18.             System.out.print(linkelist.get(i)+" ");  
19.         }  
20.         //把元素插入到开头  
21.         linkelist.addFirst(0);  
22.         //把元素插入到结尾  
23.         linkelist.addLast("c");  
24.         //遍历  
25.         System.out.println();  
26.         System.out.print("插入开头和结尾后的链表:");  
27.         for(int i=0;i<linkelist.size();i++){  
28.             System.out.print(linkelist.get(i)+" ");  
29.         }  
30.         //把元素插入到指定位置  
31.         linkelist.add(2, 2);  
32.         System.out.println();  
33.         System.out.print("插入指定位置的元素后的链表:");  
34.         for(int i=0;i<linkelist.size();i++){  
35.             System.out.print(linkelist.get(i)+" ");  
36.         }  
37.         //移除此表中指定位置的元素  
38.         linkelist.remove(4);  
39.         linkelist.remove(4);  
40.         System.out.println();  
41.         System.out.print("移除后的链表:");  
42.         for(int i=0;i<linkelist.size();i++){  
43.             System.out.print(linkelist.get(i)+" ");  
44.         }  
45.         //将此列表中指定位置的元素替换为指定的元素  
46.         linkelist.set(3,"=");  
47.         System.out.println();  
48.         System.out.print("替换后的链表:");  
49.         for(int i=0;i<linkelist.size();i++){  
50.             System.out.print(linkelist.get(i)+" ");  
51.         }  
52.     }  
53.   
54. }  

结果:

c.java.util.Vector<E>:基于：基于数组
*ArrayList和Vector 都是基于数组，Vector是基于线程安全，付出了一定性能代价
*Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和 ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了 Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

一些常用方法的使用:

[java]  view plain  copy

1. package 集合框架;  
2.   
3. import java.util.Vector;  
4.   
5. public class VectorTest {  
6.   
7.     public static void main(String[] args) {  
8.         Vector<Object> vector=new Vector<Object>();  
9.         vector.add(1);  
10.         vector.add(2);  
11.         vector.add(4);  
12.         //遍历  
13.         System.out.print("添加后的对象数组:");  
14.         for(int i=0;i<vector.size();i++){  
15.             System.out.print(vector.get(i)+" ");  
16.         }  
17.         System.out.println();  
18.         //在此向量的指定位置插入指定的元素  
19.         vector.add(2,3);  
20.         //遍历  
21.         System.out.print("添加指定位置后的对象数组:");  
22.         for(int i=0;i<vector.size();i++){  
23.             System.out.print(vector.get(i)+" ");  
24.         }  
25.         System.out.println();  
26.         //移除此向量中指定位置的元素  
27.         vector.remove(2);  
28.         System.out.print("移除后的对象数组:");  
29.         for(int i=0;i<vector.size();i++){  
30.             System.out.print(vector.get(i)+" ");  
31.         }  
32.     }  
33.   
34. }  

结果：

3.2.Vector、ArrayList和LinkedList比较
a.Vector是线程同步的，所以它也是线程安全的，而ArrayList和LinkedList是非线程安全的。如果不考虑到线程的安全因素，一般用ArrayList和LinkedList效率比较高。
b.ArrayList和Vector是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
c.如果集合中的元素的数目大于目前集合数组的长度时，Vector增长率为目前数组长度的100%,而ArrayList增长率为目前数组长度的50%.如果在集合中使用数据量比较大的数据，用vector有一定的优势；反之，用ArrayList有优势。
d.如果查找一个指定位置的数据，Vector和ArrayList使用的时间是相同的，花费时间为O(1)，而LinkedList需要遍历查找，花费时间为O(i)，效率不如前两者。
e.而如果移动、删除一个指定位置的数据花费的时间为0(n-i)n为总长度，这个时候就应该考虑使用LinkedList,因为它移动一个指定位置的数据所花费的时间为0(1)。
f.对于在指定位置插入数据，LinedList比较占优势，因为ArrayList要移动数据。

3.3.Set接口<E>：1.乱序（自己有一套排序规则）2.不能重复
a.HashSet
b.LinkedHashSet

[java]  view plain  copy

1. Iterator<Shape> iterator = hashSet.iterator();  
2.                 while (iterator.hasNext()) {  
3.                         Shape s = iterator.next();  
4.                         System.out.println(s);  
5.                     }  

 *Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
*很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
*请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
4.Map<Key,Value>: 也是乱序的 
4.1HahMap<键，值>：

4.2.LinkedHashMap：
请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。


Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。