java 集合collection set list map 泛型

集合類的由來：

對象用於封裝特有數據，對象多了須要存儲，若是對象的個數不肯定，就使用集合容器進行存儲。

集合特色：

1，用於存儲對象的容器。

2，集合的長度是可變的。

3，集合中不能夠存儲基本數據類型值。 

集合容器由於內部的數據結構不一樣，有多種具體容器。不斷的向上抽取，就造成了集合框架。

框架的頂層Collection接口：

|--List：有序(存入和取出的順序一致),元素都有索引(角標)，元素能夠重複。

|--Set：元素不能重複,無序。

Collection的常見方法：

1，添加。

boolean add(Object obj):

boolean addAll(Collection coll):

2，刪除。

boolean remove(object obj):

boolean removeAll(Collection coll);

void clear();

3，判斷：

boolean contains(object obj):

boolean containsAll(Colllection coll);

boolean isEmpty():判斷集合中是否有元素。 

4，獲取：

int size():

Iterator iterator():取出元素的方式：迭代器。

該對象必須依賴於具體容器，由於每個容器的數據結構都不一樣。

因此該迭代器對象是在容器中進行內部實現的。

對於使用容器者而言，具體的實現不重要，只要經過容器獲取到該實現的迭代器的對象便可，

也就是iterator方法。

Iterator接口就是對全部的Collection容器進行元素取出的公共接口。

5，其餘：

boolean retainAll(Collection coll);取交集。

Object[] toArray():將集合轉成數組。 

-------------------------------

Collection coll = new ArrayList();

1,添加元素。add.
coll.add("abc1");
coll.add("abc2");
System.out.println(coll);
		
2，刪除元素。remove
coll.remove("abc2");//會改變集合的長度 

清空集合.
coll.clear();

使用了Collection中的iterator()方法。 

調用集合中的迭代器方法，是爲了獲取集合中的迭代器對象。遍歷集合數據

Iterator it = coll.iterator();		
while(it.hasNext()){
    System.out.println(it.next());
}

ListIterator it = list.listIterator();//獲取列表迭代器對象 它能夠實如今迭代過程當中完成對元素的增刪改查。Iterator不能夠

List: 

|--Vector:內部是數組數據結構，是同步的。增刪，查詢都很慢！

|--ArrayList:內部是數組數據結構，是不一樣步的。替代了Vector。查詢的速度快。

|--LinkedList:內部是鏈表數據結構，是不一樣步的。增刪元素的速度很快。

Arraylist增刪改查。

ArrayList:特有的常見方法：有一個共性特色就是均可以操做角標。

1，添加

void add(index,element);

void add(index,collection);

2，刪除；

Object remove(index):

3，修改：

Object set(index,element);

4，獲取：

Object get(index);

int indexOf(object);

int lastIndexOf(object);

List subList(from,to);

List list = new ArrayList();

添加元素
list.add("abc1");
System.out.println(list);
		
插入元素。		
list.add(1,"abc9");
		
刪除元素。
System.out.println("remove:"+list.remove(1));
		
修改元素。
System.out.println("set:"+list.set(1, "abc8"));
		
獲取元素。
System.out.println("get:"+list.get(0));
		
獲取子列表。
System.out.println("sublist:"+list.subList(1, 2));

LinkedList特有方法:

 addFirst(E o);
 addLast(E o):
 jdk1.6
 offerFirst(E o);
 offetLast(E o);

 getFirst();.//獲取但不移除，若是鏈表爲空，拋出NoSuchElementException.
 getLast();
 jdk1.6
 peekFirst();//獲取但不移除，若是鏈表爲空，返回null.
 peekLast():
 
 removeFirst();//獲取並移除，若是鏈表爲空，拋出NoSuchElementException.
 removeLast();
 jdk1.6
 pollFirst();//獲取並移除，若是鏈表爲空，返回null.
 pollLast();

Set:元素不能夠重複，是無序。

Set接口中的方法和Collection一致。

|--HashSet: 內部數據結構是哈希表 ，是不一樣步的。

如何保證該集合的元素惟一性呢？

是經過對象的hashCode和equals方法來完成對象惟一性的。

若是對象的hashCode值不一樣，那麼不用判斷equals方法，就直接存儲到哈希表中。 

若是對象的hashCode值相同，那麼要再次判斷對象的equals方法是否爲true。

若是爲true，視爲相同元素，不存。若是爲false，那麼視爲不一樣元素，就進行存儲。

 若是元素要存儲到HashSet集合中，必須覆蓋hashCode方法和equals方法。

通常狀況下，若是定義的類會產生不少對象，好比人，學生，書，一般都須要覆蓋equals，hashCode方法。

創建對象判斷是否相同的依據。

 |--linkedHashSet：鏈式HashSet能夠在不重複的狀況下，進行鏈式排序

|--TreeSet:能夠對Set集合中的元素進行排序。是不一樣步的。 

判斷元素惟一性的方式：就是根據比較方法的返回結果是不是0，是0，就是相同元素，不存。 

TreeSet對元素進行排序的方式一：

讓元素自身具有比較功能，元就須要實現Comparable接口。覆蓋compareTo方法。

若是不要按照對象中具有的天然順序進行排序。若是對象中不具有天然順序。怎麼辦？

可使用TreeSet集合第二種排序方式二：

讓集合自身具有比較功能，定義一個類實現Comparator接口，覆蓋compare方法。

將該類對象做爲參數傳遞給TreeSet集合的構造函數。

if(this.hashCode()== obj.hashCode() && this.equals(obj))

哈希表肯定元素是否相同

1，判斷的是兩個元素的哈希值是否相同。

若是相同，在判斷兩個對象的內容是否相同。

2，判斷哈希值相同，其實判斷的是對象的hashCode的方法。判斷內容相同，用的是equals方法。

注意：若是哈希值不一樣，是不須要判斷equals。

泛型：jdk1.5出現的安全機制。

好處：

1，將運行時期的問題ClassCastException轉到了編譯時期。

2，避免了強制轉換的麻煩。

<>:何時用？當操做的引用數據類型不肯定的時候。就使用<>。將要操做的引用數據類型傳入便可，其實<>就是一個用於接收具體引用數據類型的參數範圍。

在程序中，只要用到了帶有<>的類或者接口，就要明確傳入的具體引用數據類型 。

泛型技術是給編譯器使用的技術,用於編譯時期。確保了類型的安全。

運行時，會將泛型去掉，生成的class文件中是不帶泛型的,這個稱爲泛型的擦除。

爲何擦除呢？由於爲了兼容運行的類加載器。

泛型的補償：在運行時，經過獲取元素的類型進行轉換動做。不用使用者在強制轉換了。

泛型的通配符：? 未知類型。 

泛型的限定：

? extends E: 接收E類型或者E的子類型對象。上限

通常存儲對象的時候用。好比 添加元素 addAll.

? super E: 接收E類型或者E的父類型對象。 下限。

通常取出對象的時候用。好比比較器。

選擇集合的一些技巧：

須要惟一嗎？

須要：Set

須要制定順序： 

須要： TreeSet

不須要：HashSet

可是想要一個和存儲一致的順序(有序):LinkedHashSet

不須要：List

須要頻繁增刪嗎？

須要：LinkedList

不須要：ArrayList

如何記錄每個容器的結構和所屬體系呢？

看名字！

List

|--ArrayList

|--LinkedList

Set

|--HashSet

|--TreeSet

後綴名就是該集合所屬的體系。

前綴名就是該集合的數據結構。

看到array：就要想到數組，就要想到查詢快，有角標.

看到link：就要想到鏈表，就要想到增刪快，就要想要 add get remove+frist last的方法 

看到hash:就要想到哈希表，就要想到惟一性，就要想到元素須要覆蓋hashcode方法和equals方法。 

看到tree：就要想到二叉樹，就要想要排序，就要想到兩個接口Comparable，Comparator 。

並且一般這些經常使用的集合容器都是不一樣步的。 

Map：鍵值對

Map：一次添加一對元素。

Collection 一次添加一個元素。

Map也稱爲雙列集合，Collection集合稱爲單列集合。

其實map集合中存儲的就是鍵值對。 

map集合中必須保證鍵的惟一性。 

經常使用方法：

1，添加。

value put(key,value):返回前一個和key關聯的值，若是沒有返回null.

2，刪除。

void  clear():清空map集合。

value remove(key):根據指定的key翻出這個鍵值對。 

3，判斷。

boolean containsKey(key):

boolean containsValue(value):

boolean isEmpty();

4，獲取。 

value get(key):經過鍵獲取值，若是沒有該鍵返回null。固然能夠經過返回null，來判斷是否包含指定鍵。 

int size(): 獲取鍵值對的個數。 

Map經常使用的子類：

|--Hashtable :內部結構是哈希表，是同步的。不容許null做爲鍵，null做爲值。

|--Properties：用來存儲鍵值對型的配置文件的信息，能夠和IO技術相結合。

|--HashMap : 內部結構是哈希表，不是同步的。容許null做爲鍵，null做爲值。

|--TreeMap : 內部結構是二叉樹，不是同步的。能夠對Map集合中的鍵進行排序。 

非同步Arraylist加鎖方法

List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一個同步的list.
給非同步的集合加鎖。
class MyCollections{
     public static  List synList(List list){ 
     return new MyList(list);
     }
     private class MyList implements List{
         private List list;
         private static final Object lock = new Object();
 
         MyList(List list){ 
             this.list = list; 
         }
         public boolean add(Object obj){
             synchronized(lock)
             {
                 return list.add(obj);
             }
         } 
         public boolean remove(Object obj){
             synchronized(lock)
             {
             return list.remove(obj);
             }
         }
      }
}

list轉String[]數組

List list = new ArrayList();
list.add("1");
list.add("2");
final int size =　list.size();
String[] arr = (String[])list.toArray(new String[size]);    //這個就是轉換的

string 轉 list

String[] arr = new String[] {"1", "2"};

List list = Arrays.asList(arr);