程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 基於Java回想之聚集的總結概述

基於Java回想之聚集的總結概述

編輯:關於JAVA

基於Java回想之聚集的總結概述。本站提示廣大學習愛好者:(基於Java回想之聚集的總結概述)文章只能為提供參考,不一定能成為您想要的結果。以下是基於Java回想之聚集的總結概述正文


Java中的聚集重要集中在2部門,一部門是java.util包中,一部門是java.util.concurrent中,後者是在前者的基本上,界說了一些完成了同步功效的聚集。

這篇文章重要存眷java.util下的各類聚集對象。Java中的聚集對象可以粗略的分為3類:List、Set和Map。對應的UML圖以下(包含了java.util下年夜部門的聚集對象):

Collection概述

Java聚集中的List和Set都從Collection出來,它是一個進修聚集很不錯的進口,它包括了聚集中平日須要有的操作:

    添加元素:add/addAll
    清空聚集:clear
    刪除元素:remove/removeAll
    斷定聚集中能否包括某元素:contains/containsAll
    斷定聚集能否為空:isEmpty
    盤算聚集中元素的個數:size
    將聚集轉換為數組:toArray
    獲得迭代器:iterator

我們來看一個簡略的例子,上面的代碼會前往一個聚集,聚集中的元素是隨機生成的整數:

private static Collection initCollection()
 {
     Collection<Integer> collection = new ArrayList<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         collection.add(new Integer(r.nextInt(100)));
     }

     return collection;
 }

在對聚集停止操作的進程中,遍歷是一個常常應用的操作,我們可使用兩種方法對聚集停止遍歷:

1) 應用迭代器對聚集停止遍歷。正如下面描寫Collection接口時所說,一切聚集都邑有一個迭代器,我們可以用它來遍歷聚集。

private static void accessCollectionByIterator(Collection<Integer> collection)
 {
     Iterator<Integer> iterator = collection.iterator();
     System.out.println("The value in the list:");
     while(iterator.hasNext())
     {
         System.out.println(iterator.next());
     }
 }

2)應用foreach遍歷聚集。

private static void accessCollectionByFor(Collection<Integer> collection)
 {
     System.out.println("The value in the list:");
     for(Integer value : collection)
     {
         System.out.println(value);
     }
 }

List

Java中的List是對數組的有用擴大,它是如許一種構造,假如不應用泛型,它可以包容任何類型的元素,假如應用泛型,那末它只能包容泛型指定的類型的元素。和數組比擬,List的容量是可以靜態擴大的。

List中的元素是可以反復的,外面的元素是“有序”的,這裡的“有序”,其實不是排序的意思,而是說我們可以對某個元素在聚集中的地位停止指定。

List中經常使用的聚集對象包含:ArrayList、Vector和LinkedList,個中前二者是基於數組來停止存儲,後者是基於鏈表停止存儲。個中Vector是線程平安的,其他兩個不是線程平安的。

List中是可以包含null的,即便是應用了泛型。

ArrayList能夠是我們日常平凡用到的最多的聚集對象了,在上述的示例代碼中,我們也是應用它來實例化一個Collection對象,在此不再贅述。
Vector

Vector的示例以下,起首我們看若何生成和輸入Vector:

private static void vectorTest1()
 {
     List<Integer> list = new Vector<Integer>();
     for (int i = 0 ; i < 5; i++)
     {
         list.add(new Integer(100));
     }
     list.add(null);
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
 }

它的元素中,既包含了反復元素,也包含了null,輸入成果以下:

size of vector is 6
[100, 100, 100, 100, 100, null]

上面的示例,演示了Vector中的一些經常使用辦法:

private static void vectorTest2()
 {
     Vector<Integer> list = new Vector<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 10; i++)
     {
         list.add(new Integer(r.nextInt(100)));
     }
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
     System.out.println(list.firstElement());
     System.out.println(list.lastElement());
     System.out.println(list.subList(3, 8));
     List<Integer> temp = new ArrayList<Integer>();
     for(int i = 4; i < 7; i++)
     {
         temp.add(list.get(i));
     }
     list.retainAll(temp);
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
 }

它的輸入成果以下:

size of vector is 10
[39, 41, 20, 9, 29, 32, 54, 12, 94, 82]


[9, 29, 32, 54, 12]
size of vector is 3
[29, 32, 54]

LinkedList

LinkedList應用鏈表來存儲數據,它的示例代碼以下:

LinkedList示例
 private static void linkedListTest1()
 {
     LinkedList<Integer> list = new LinkedList<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 10; i++)
     {
         list.add(new Integer(r.nextInt(100)));
     }
     list.add(null);
     System.out.println("size of linked list is " + list.size());
     System.out.println(list);
     System.out.println(list.element());
     System.out.println(list.getFirst());
     System.out.println(list.getLast());
     System.out.println(list.peek());
     System.out.println(list.peekFirst());
     System.out.println(list.peekLast());
     System.out.println(list.poll());
     System.out.println(list.pollFirst());
     System.out.println(list.pollLast());
     System.out.println(list.pop());
     list.push(new Integer(100));
     System.out.println("size of linked list is " + list.size());
     System.out.println(list);
 }

這裡列出了LinkedList經常使用的各個辦法,從辦法名可以看出,LinkedList也能夠用來完成棧和隊列。

輸入成果以下:

size of linked list is 11
[17, 21, 5, 84, 19, 57, 68, 26, 27, 47, null]


null


null


null

size of linked list is 8
[100, 84, 19, 57, 68, 26, 27, 47]

Set

Set 和List相似,都是用來存儲單個元素,單個元素的數目不肯定。但Set不克不及包括反復元素,假如向Set中拔出兩個雷同元素,那末後一個元素不會被拔出。

Set可以年夜致分為兩類:不排序Set和排序Set,不排序Set包含HashSet和LinkedHashSet,排序Set重要指TreeSet。個中HashSet和LinkedHashSet可以包括null。
HashSet

HashSet是由Hash表支撐的一種聚集,它不是線程平安的。

我們來看上面的示例,它和Vector的第一個示例根本上是雷同的:

private static void hashSetTest1()
 {
     Set<Integer> set = new HashSet<Integer>();

     for (int i = 0; i < 3; i++)
     {
         set.add(new Integer(100));
     }
     set.add(null);

     System.out.println("size of set is " + set.size());
     System.out.println(set);
 }

這裡,HashSet中既包括了反復元素,又包括了null,和Vector分歧,這裡的輸入成果以下:

size of set is 2
[null, 100]

關於HashSet是若何斷定兩個元素能否是反復的,我們可以深刻考核一下。Object中也界說了equals辦法,關於HashSet中的元素,它是依據equals辦法來斷定元素能否相等的,為了證實這一點,我們可以界說個“不正常”的類型:

界說MyInteger對象

class MyInteger
{
    private Integer value;

    public MyInteger(Integer value)
    {
        this.value = value;
    }

    public String toString()
    {
        return String.valueOf(value);
    }

    public int hashCode()
    {
        return 1;
    }

    public boolean equals(Object obj)
    {
        return true;
    }
}

可以看到,關於MyInteger來講,關於隨意率性兩個實例,我們都以為它是不相等的。

上面是對應的測試辦法:

private static void hashSetTest2()
 {
     Set<MyInteger> set = new HashSet<MyInteger>();

     for (int i = 0; i < 3; i++)
     {
         set.add(new MyInteger(100));
     }

     System.out.println("size of set is " + set.size());
     System.out.println(set);
 }

它的輸入成果以下:

size of set is 3
[100, 100, 100]

可以看到,如今HashSet裡有“反復”元素了,但關於MyInteger來講,它們不是“雷同”的。
TreeSet

TreeSet是支撐排序的一種Set,它的父接口是SortedSet。

我們起首來看一下TreeSet都有哪些根本操作:

private static void treeSetTest1()
 {
     TreeSet<Integer> set = new TreeSet<Integer>();

     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         set.add(new Integer(r.nextInt(100)));
     }

     System.out.println(set);
     System.out.println(set.first());
     System.out.println(set.last());
     System.out.println(set.descendingSet());
     System.out.println(set.headSet(new Integer(50)));
     System.out.println(set.tailSet(new Integer(50)));
     System.out.println(set.subSet(30, 60));
     System.out.println(set.floor(50));
     System.out.println(set.ceiling(50));
 }

它的輸入成果以下:

[8, 42, 48, 49, 53]


[53, 49, 48, 42, 8]
[8, 42, 48, 49]
[53]
[42, 48, 49, 53]

TreeSet中的元素,普通都完成了Comparable接口,默許情形下,關於Integer來講,SortedList是采取升序來存儲的,我們也能夠自界說Compare方法,例如以降序的方法來存儲。

上面,我們起首從新界說Integer:

界說MyInteger2對象
 class MyInteger2 implements Comparable
 {
     public int value;

     public MyInteger2(int value)
     {
         this.value = value;
     }

     public int compareTo(Object arg0)
     {
         MyInteger2 temp = (MyInteger2)arg0;
         if (temp == null) return -1;
         if (temp.value > this.value)
         {
             return 1;
         }
         else if (temp.value < this.value)
         {
             return -1;
         }
         return 0;
     }

     public boolean equals(Object obj)
     {
         return compareTo(obj) == 0;
     }

     public String toString()
     {
         return String.valueOf(value);
     }
 }

上面是測試代碼:

private static void treeSetTest2()
 {
     TreeSet<Integer> set1 = new TreeSet<Integer>();
     TreeSet<MyInteger2> set2 = new TreeSet<MyInteger2>();
     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         int value = r.nextInt(100);
         set1.add(new Integer(value));
         set2.add(new MyInteger2(value));
     }
     System.out.println("Set1 as below:");
     System.out.println(set1);
     System.out.println("Set2 as below:");
     System.out.println(set2);
 }

代碼的運轉成果如我們所預期的那樣,以下所示:

Set1 as below:
[13, 41, 42, 45, 61]
Set2 as below:
[61, 45, 42, 41, 13]

Map

Map中存儲的是“鍵值對”,和Set相似,Java中的Map也有兩種:排序的和不排序的,不排序的包含HashMap、Hashtable和LinkedHashMap,排序的包含TreeMap。
非排序Map

HashMap和Hashtable都是采用Hash表的方法停止存儲,HashMap不是線程平安的,Hashtable是線程平安的,我們可以把HashMap看作是“簡化”版的Hashtable。

HashMap是可以存儲null的,不管是對Key照樣對Value。Hashtable是弗成以存儲null的。

不管HashMap照樣Hashtable,我們不雅察它的結構函數,就會發明它可以有兩個參數:initialCapacity和loadFactor,默許情形下,initialCapacity等於16,loadFactor等於0.75。這和Hash表中可以寄存的元素數量有關系,當元素數量跨越initialCapacity*loadFactor時,會觸發rehash辦法,對hash表停止擴容。假如我們須要向個中拔出過量元素,須要恰當調劑這兩個參數。

我們起首來看HashMap的示例:

private static void hashMapTest1()
 {
     Map<Integer,String> map = new HashMap<Integer, String>();

     map.put(new Integer(1), "a");
     map.put(new Integer(2), "b");
     map.put(new Integer(3), "c");

     System.out.println(map);
     System.out.println(map.entrySet());
     System.out.println(map.keySet());
     System.out.println(map.values());
 }

這會輸入HashMap裡的元素信息,以下所示。

{1=a, 2=b, 3=c}
[1=a, 2=b, 3=c]
[1, 2, 3]
[a, b, c]

上面的示例是對null的演示:

private static void hashMapTest2()
 {
     Map<Integer,String> map = new HashMap<Integer, String>();

     map.put(null, null);
     map.put(null, null);
     map.put(new Integer(4), null);
     map.put(new Integer(5), null);

     System.out.println(map);
     System.out.println(map.entrySet());
     System.out.println(map.keySet());
     System.out.println(map.values());
 }

履行成果以下:

{null=null, 4=null, 5=null}
[null=null, 4=null, 5=null]
[null, 4, 5]
[null, null, null]

接上去我們演示Hashtable,和上述兩個示例根本上完整一樣(代碼不再睜開):

Hashtable示例
 private static void hashTableTest1()
 {
     Map<Integer,String> table = new Hashtable<Integer, String>();

     table.put(new Integer(1), "a");
     table.put(new Integer(2), "b");
     table.put(new Integer(3), "c");

     System.out.println(table);
     System.out.println(table.entrySet());
     System.out.println(table.keySet());
     System.out.println(table.values());
 }

 private static void hashTableTest2()
 {
     Map<Integer,String> table = new Hashtable<Integer, String>();

     table.put(null, null);
     table.put(null, null);
     table.put(new Integer(4), null);
     table.put(new Integer(5), null);

     System.out.println(table);
     System.out.println(table.entrySet());
     System.out.println(table.keySet());
     System.out.println(table.values());
 }

履行成果以下:

{3=c, 2=b, 1=a}
[3=c, 2=b, 1=a]
[3, 2, 1]
[c, b, a]
Exception in thread "main" java.lang.NullPointerException
    at java.util.Hashtable.put(Unknown Source)
    at sample.collections.MapSample.hashTableTest2(MapSample.java:61)
    at sample.collections.MapSample.main(MapSample.java:11)

可以很清晰的看到,當我們試圖將null拔出到hashtable中時,報出了空指針異常。
排序Map

排序Map重要是指TreeMap,它對元素增、刪、查操作時的時光龐雜度都是O(log(n))。它不是線程平安的。

它的特色和TreeSet異常像,這裡不再贅述。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved