Java高級部分--集合（2）

一.集合類

Java中數組與集合的比較
1.數組也是容器，它是定長的，訪問較快，可是數組不會自動擴充
2.數組能夠包含基本數據類型或引用類型的對象，而集合中只能包含引用類型的對象

 

Java中集合框架層次結構

Collection接口

1.一組稱爲元素的對象

2.一個Collection中能夠放不一樣
類型的數據
1.是Set接口和List接口的父類
2.是否有特定的順序以及是否容許重複，取決於它的實現

3.Set － 無序的集合；不容許重複  如：HashSet
4.List － 有序的集合；容許重複  如：ArrayList,LinkedList

Set接口
1.Collection的子接口
2.用來包含一組 無序無重複 的對象
3.無序-----是指元素存入順序和集合內存儲的順序不一樣
4.無重複------兩個對象e1和e2，若是e1.equals(e2)返回true，則認爲e1和e2重複

Set接口的實現類 
1.HashSet-----HashSet的特性在於其內部對象的散列存取，即採用哈希技術
2.TreeSet-----TreeSet存入的順序跟存儲的順序不一樣，可是存儲是按照排序存儲的

List接口

1.Collection的子接口
2.用來包含一組 有序有重複 的對象
3.List中的元素都對應一個整數型的序號，記載其在容器中的位置，能夠根據序號存取容器中的元素
4.List有兩種主要的集合實現類：ArrayList,LinkedList

List接口的實現類
1.ArrayList是線性順序存儲的，是一種線性表
2.它的特性和數組很接近，數組大小是不變的，而ArrayList的大小是能夠動態改變的

3.LinkedList最主要的功能方面的加強是能夠在List的頭部和尾部添加、刪除、取得元素，直接提供了這些方法的實現

ArrayList與LinkedList的比較
　　存儲結構
1.ArrayList是線性順序存儲
2.LinkedList對象間彼此串連起來的一個鏈表
　　操做性能
1.ArrayList適合隨機查詢的場合
2.LinkedList元素的插入和刪除操做性高

Map接口
1.Map內存儲的是鍵/值對這樣以成對的對象組(能夠把一組對象當成一個元素)，經過「鍵」對象來查詢「值」對象
2.Map是不一樣於Collection的另一種集合接口
3.Map中，key值是惟一的(不能重複)，而key對象是與value對象關聯在一塊兒的
　　Map接口有兩個實現：
1.HashMap — key/value對是按照Hash算法存儲的
2.TreeMap — key/value對是排序(按key排序)存儲的

HashMap與TreeMap的比較
1.HashMap基於哈希表實現
2.TreeMap基於樹實現
3.HashMap能夠經過調優初始容量和負載因子，優化HashMap空間的使用
4.TreeMap沒有調優選項，由於該樹總處於平衡狀態
5.HashMap性能優於TreeMap

Iterator接口
1.Iterator對象稱做迭代器，用來方便的實現對容器內的元素進行遍歷操做
2.全部實現了Collection接口的集合類都有一個iterator( )方法，返回一個實現了Iterator接口的對象
3.Iterator對象實現了統一的一個用來遍歷Collection中對象的方法
4.Iterator是爲遍歷而設計，可以從集合中取出元素和刪除元素，可是沒有添加元素的功能
5.Iterator的功能上比較簡單，使用中，只能單向移動

hasNext方法

用來判斷指針右邊是否還有數據

Next方法

將指針向右移動一次，將劃過的數據取出來

Iterator<String>    iter=hs1.iterator();
           while(iter.hasNext()){
       System.out.println( iter.next());
　　}

如何選擇集合類
1.Set內存放的元素不容許重複，List存放的元素有必定的順序
2.Map的應用主要在利用鍵/值對進行快速查詢
3.ArrayList和LinkedList的區別在於隨機查詢性能上ArrayList要好，但LinkedList的中間元素的插入與刪除性能好 
4.HashSet和TreeSet的區別在於集合內元素是否排序 

 

 

collection接口

 1 package util1;
 2 
 3 import java.util.Collection;
 4 import java.util.HashSet;
 5 
 6 public class Collection1 {
 7 
 8     /**
 9      * @param args
10      */
11     public static void main(String[] args) {
12         
13         //實例化對象
14         Collection   c1=new HashSet();   //向上轉型---  聲明成接口類型，調用實現類的構造方法
15         Collection   c2=new HashSet(); 
16          //添加數據
17         c1.add(1);
18         c1.add("你");
19         c1.add(new  A());  
20         
21         System.out.println(c1);    //總體取出數據：直接輸出集合名稱  
22         
23         c2.addAll(c1);   //添加其餘集合
24         System.out.println(c2.size());    //取集合長度
25         System.out.println(c2.contains("sgtht"));   //判斷是否包含某些數據
26         
27         System.out.println("///////////////");   
28        Object  o[]    =c2.toArray();    //將集合轉換成數組
29        /*for(int i=0;i<o.length;i++){
30            System.out.println(o[i]);
31        }*/
32        
33          System.out.println(o[0]);
34          System.out.println(o[1]);
35          System.out.println(o[2]);
36        
37         
38     }
39 
40 }

set集合

hashSet,treeSet

 1 package util1;
 2 
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 import java.util.TreeSet;
 6 
 7 public class HashSet1 {
 8 
 9     /**
10      * set接口的特色(集合)
11      *     hashset:   無順序,數據不能重複,長度可擴展
12      *     treeset:  按照天然順序排列數據，數據不能重複,可以比較大小
13      * 
14      */
15     public static void main(String[] args) {
16         
17           HashSet<String>   hs1=new HashSet<String>();
18           hs1.add("a");
19           hs1.add("b");
20           hs1.add("b");
21           hs1.add("c");
22 /*          System.out.println(hs1);  
23           
24           //挨個取出集合中的數據
25          Iterator<String>    iter=hs1.iterator();
26           while(iter.hasNext()){
27              System.out.println( iter.next());
28           }
29           */
30           
31           
32             TreeSet<Integer>   ts1=new TreeSet<Integer>();
33             ts1.add(1);
34             ts1.add(768);
35             ts1.add(43);
36             ts1.add(43);
37             ts1.add(87);
38             System.out.println(ts1); 
39             
40             
41           //類型轉換異常
42             
43             TreeSet  ts2=new TreeSet();
44             ts2.add("adsf");
45             ts2.add("u11");    
46             ts2.add("caa");
47             System.out.println(ts2);  
48     }
49 
50 }

list集合

linkedList

 1 package util1;
 2 
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 import java.util.LinkedList;
 6 
 7 public class List1 {
 8 
 9     /**
10      *    list（列表）:   下標從0開始
11      *        
12      *          linkedList:  方便首尾操做 ，    數據可重複,有順序,長度可擴展
13      *          ArrayList:(數組列表)  :   數據可重複,有順序,長度可擴展
14      * 
15      */
16     public static void main(String[] args) {
17        
18         LinkedList<Integer>   ll=new LinkedList<Integer>();
19         ll.add(1);
20         ll.add(454);
21         ll.add(454);
22         ll.add(454);
23         ll.add(454);
24         ll.add(242);
25         ll.add(0, 88);
26         //ll.add(10, 77);
27         System.out.println(ll);  
28         ll.addFirst(66);
29         System.out.println(ll);
30         System.out.println(ll.get(4));    //按照下標取數據
31         
32         System.out.println("///////////////////");  
33     
34         for(int i=0;i<ll.size();i++){
35             System.out.println(ll.get(i));             
36         }
37         
38         System.out.println("///////////////////");  
39         
40         Iterator<Integer>  it=ll.iterator();
41         while(it.hasNext()){
42             System.out.println(it.next());          
43         }
44         
45         System.out.println("///////////////////");  
46         //foreach循環,加強的for循環------提升效率(封裝了迭代器)
47           for(Integer   in:ll){
48               System.out.println(in);
49           }
50   
51     }
52 
53 }

map接口

hashmap集合

 1 package util1;
 2 
 3 import java.util.HashMap;
 4 import java.util.Iterator;
 5 import java.util.Map;
 6 import java.util.Set;
 7 import java.util.Map.Entry;
 8 
 9 public class Map1 {
10 
11     /**
12      * map:數據成對存放
13      *     HashMap:  無序存放     key值不能重複，若是key值重複，會替換掉原來的鍵值對
14      * 
15      * 
16      */
17     public static void main(String[] args) {
18         //聲明鍵值對容器
19         HashMap  hm1=new HashMap<String, String>();
20        
21         hm1.put("1", "a");  
22         hm1.put("2", "b");
23         hm1.put("2", null);  
24         hm1.put("3", "c");
25       System.out.println(hm1); 
26         
27         Set  keys=hm1.keySet();   //將全部key值取出組合成一個set集合
28       /*   Iterator<String>   it=keys.iterator();
29           while(it.hasNext()){                  //循環全部key值
30         //    System.out.println(hm1.get(it.next()));      //根據key值獲取value值              
31           }*/
32         
33         
34         Map<String, String>  m1=new HashMap<String, String>();   
35         //向上轉型:  節省內存   ,可用接口中的方法，實現類重寫的方法,不能用實現類獨有的方法
36           m1.put("1", "a");  
37           m1.put("2", "b");
38           m1.put("2", "c");  
39           m1.put("3", "c");
40           System.out.println(m1);
41           
42           Set<Map.Entry<String, String>>  ens=m1.entrySet();   
43           for(Entry<String, String>  e:ens){
44                System.out.println(e.getKey());  
45                System.out.println(e.getValue());  
46           }
47           
48     }
49 
50 }

treemap集合

 1 package util1;
 2 
 3 import java.util.TreeMap;
 4 
 5 public class TreeMap1 {
 6 
 7     /**
 8      *   treemap:   按照key值的天然順序排列數據,要求key值能夠比較大小
 9      */
10     public static void main(String[] args) {
11         
12            TreeMap   tm1=new TreeMap<Integer, String>();
13            tm1.put(44, "gf");
14            tm1.put(4654, "gf");
15            tm1.put(42, "gf");
16            tm1.put(4, "gf");
17            System.out.println(tm1);  
18           System.out.println(tm1.floorKey(5));   //獲得小於參數的一個key值
19           System.out.println(tm1.floorEntry(5));  //獲得小於參數的一個鍵值對
20 
21     }
22 
23 }

日期

 1 package util1;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Calendar;
 5 import java.util.Date;   //引包
 6 
 7 public class Date1 {
 8 
 9     
10     public static void main(String[] args) {
11         
12             //當前時間
13             Date   d1=new Date();    //當時的時間
14             System.out.println(d1);  
15             
16             SimpleDateFormat   sdf=new SimpleDateFormat("yyyy年MM月dd日   a hh:mm:ss");
17             String  time1=sdf.format(d1);
18             System.out.println(time1); 
19             
20             
21             //日曆類
22            Calendar   c= Calendar.getInstance();  //反轉得到時間
23            c.set(2011,11,29);  //自定義的時間
24           System.out.println(c.get(Calendar.YEAR)); 
25 
26     }
27 
28 }