Java上機實驗報告（3）

一、任務簡要描述

1、集合類的使用舉例

Collection接口

　　Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）。一些 Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的“子接口”如List和Set。

　　所有實作Collection接口的類都必須提供兩個标準的構造函數：無參數的構造函數用于建立一個空的Collection，有一個 Collection參數的構造函數用于建立一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。後一個構造函數允許使用者複制一個Collection。

　　如何周遊Collection中的每一個元素？不論Collection的實際類型如何，它都支援一個iterator()的方法，該方法傳回一個疊代子，使用該疊代子即可逐一通路Collection中每一個元素。典型的用法如下：

1 　Iterator it = collection.iterator(); // 獲得一個疊代子
2  　　　　while(it.hasNext()) {
3 　　　　　　Object obj = it.next(); // 得到下一個元素

　　由Collection接口派生的兩個接口是List和Set。

List接口

　　List是有序的Collection，使用此接口能夠精确的控制每個元素插入的位置。使用者能夠使用索引（元素在List中的位置，類似于數組下标）來通路List中的元素，這類似于Java的數組。

和下面要提到的Set不同，List允許有相同的元素。

　　除了具有Collection接口必備的iterator()方法外，List還提供一個listIterator()方法，傳回一個 ListIterator接口，和标準的Iterator接口相比，ListIterator多了一些add()之類的方法，允許添加，删除，設定元素，還能向前或向後周遊。

　　實作List接口的常用類有LinkedList，ArrayList，Vector和Stack。

LinkedList類

　　LinkedList實作了List接口，允許null元素。此外LinkedList提供額外的get，remove，insert方法在 LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧（stack），隊列（queue）或雙向隊列（deque）。

　　注意LinkedList沒有同步方法。如果多個線程同時通路一個List，則必須自己實作通路同步。一種解決方法是在建立List時構造一個同步的List：

1 List list = Collections.synchronizedList(new LinkedList(...));

ArrayList類

　　ArrayList實作了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步。

size，isEmpty，get，set方法運作時間為常數。但是add方法開銷為分攤的常數，添加n個元素需要O(n)的時間。其他的方法運作時間為線性。

　　每個ArrayList執行個體都有一個容量（Capacity），即用于存儲元素的數組的大小。這個容量可随着不斷添加新元素而自動增加，但是增長算法并沒有定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。

　　和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。

Vector類

　　Vector非常類似ArrayList，但是Vector是同步的。由Vector建立的Iterator，雖然和 ArrayList建立的Iterator是同一接口，但是，因為Vector是同步的，當一個Iterator被建立而且正在被使用，另一個線程改變了 Vector的狀态（例如，添加或删除了一些元素），這時調用Iterator的方法時将抛出 ConcurrentModificationException，是以必須捕獲該異常。

Stack 類

　　Stack繼承自Vector，實作一個後進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用。基本的push和pop 方法，還有peek方法得到棧頂的元素，empty方法測試堆棧是否為空，search方法檢測一個元素在堆棧中的位置。Stack剛建立後是空棧。

Set接口

　　Set是一種不包含重複的元素的Collection，即任意的兩個元素e1和e2都有e1.equals(e2)=false，Set最多有一個null元素。

　　很明顯，Set的構造函數有一個限制條件，傳入的Collection參數不能包含重複的元素。

　　請注意：必須小心操作可變對象（Mutable Object）。如果一個Set中的可變元素改變了自身狀态導緻Object.equals(Object)=true将導緻一些問題。

Map接口

　　請注意，Map沒有繼承Collection接口，Map提供key到value的映射。一個Map中不能包含相同的key，每個key隻能映射一個 value。Map接口提供3種集合的視圖，Map的内容可以被當作一組key集合，一組value集合，或者一組key-value映射。

Hashtable類

　　Hashtable繼承Map接口，實作一個key-value映射的哈希表。任何非空（non-null）的對象都可作為key或者value。

　　添加資料使用put(key, value)，取出資料使用get(key)，這兩個基本操作的時間開銷為常數。

Hashtable通過initial capacity和load factor兩個參數調整性能。通常預設的load factor 0.75較好地實作了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間将增大，這會影響像get和put這樣的操作。

使用Hashtable的簡單示例如下，将1，2，3放到Hashtable中，他們的key分别是”one”，”two”，”three”：

1 Hashtable numbers = new Hashtable();
2 　　　　numbers.put(“one”, new Integer(1));
3 　　　　numbers.put(“two”, new Integer(2));
4 　　　　numbers.put(“three”, new Integer(3));

　　要取出一個數，比如2，用相應的key：

1 Integer n = (Integer)numbers.get(“two”);
2 　　　　System.out.println(“two = ” + n);

　　由于作為key的對象将通過計算其散列函數來确定與之對應的value的位置，是以任何作為key的對象都必須實作hashCode和equals方法。hashCode和equals方法繼承自根類Object，如果你用自定義的類當作key的話，要相當小心，按照散列函數的定義，如果兩個對象相同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個對象不同，則它們的hashCode不一定不同，如果兩個不同對象的hashCode相同，這種現象稱為沖突，沖突會導緻操作哈希表的時間開銷增大，是以盡量定義好的hashCode()方法，能加快哈希表的操作。

　　如果相同的對象有不同的hashCode，對哈希表的操作會出現意想不到的結果（期待的get方法傳回null），要避免這種問題，隻需要牢記一條：要同時複寫equals方法和hashCode方法，而不要隻寫其中一個。

　　Hashtable是同步的。

HashMap類

　　HashMap和Hashtable類似，不同之處在于HashMap是非同步的，并且允許null，即null value和null key。，但是将HashMap視為Collection時（values()方法可傳回Collection），其疊代子操作時間開銷和HashMap 的容量成比例。是以，如果疊代操作的性能相當重要的話，不要将HashMap的初始化容量設得過高，或者load factor過低。

WeakHashMap類

　　WeakHashMap是一種改進的HashMap，它對key實行“弱引用”，如果一個key不再被外部所引用，那麼該key可以被GC回收。

二、問題及解決

Example_1

1 class Cat{
 2     private int age;
 3     public Cat(int age)
 4     {
 5         this.age = age;
 6     }
 7     public int getAge()
 8     {
 9         return this.age;
10     }
11 }
12 public class arraylist {
13     public static void main(String[] args)
14     {
15         List <Cat>cats = new ArrayList<Cat>();
16         for(int i=0; i<10; i++)
17         {
18             cats.add(new Cat(i));
19         }
20         Cat cat = null;
21         Iterator ite = cats.iterator();
22         System.out.println("使用疊代器Iterator周遊ArrayList集合元素：");
23         while(ite.hasNext())
24         {
25             cat = (Cat)ite.next();
26             System.out.println(cat.getAge() + " ");
27         }
28         //限定疊代器中元素的類型
29         Iterator <Cat>ite1 = cats.iterator();
30         System.out.println("\n使用疊代器Iterator元素類型的方式周遊ArrayList集合元素：");
31         while(ite1.hasNext())
32         {
33             cat = ite1.next();
34             System.out.println(cat.getAge() + " ");
35         }
36     }
37 }

輸出結果：

Java上機實驗報告（3）

Example_2

1 package collection_3;
 2 
 3 import java.util.*;
 4 
 5 //使用LinkedList模拟棧
 6 public class linklist1 {
 7     private LinkedList list = new LinkedList();
 8     public void push(Object v)
 9     {
10         list.addFirst(v);
11     }
12     public Object top()
13     {
14         return list.getFirst();
15     }
16     public Object pop()
17     {
18         return list.removeFirst();
19     }
20     
21     public static void main(String[] args)
22     {
23         linklist1 stack = new linklist1();
24         for(int i=0; i<10; i++)
25         {
26             stack.push(new Integer(i));
27         }
28         System.out.println(stack.top());
29         System.out.println(stack.pop());
30         System.out.println(stack.pop());
31         System.out.println(stack.top());
32     }
33 }

輸出結果：

Java上機實驗報告（3）

Example_3

1 package collection_3;
 2 
 3 import java.util.*;
 4 
 5 //使用LinkedList模拟隊列
 6 public class linklist2 {
 7     private LinkedList list = new LinkedList();
 8     public void put(Object v)
 9     {
10         list.addFirst(v);
11     }
12     public Object get()
13     {
14         return list.removeLast();
15     }
16     public boolean isEmpty()
17     {
18         return list.isEmpty();
19     }
20         
21     public static void main(String[] args)
22     {
23         linklist2 queue = new linklist2();
24         for(int i=0; i<10; i++)
25         {
26             queue.put(new Integer(i));
27         }
28         System.out.println("使用LinkedList模拟隊列，隊列中的元素如下：");
29         while(!queue.isEmpty())
30         {
31             System.out.println(queue.get() + " ");
32         }
33     }
34 }

輸出結果：

Java上機實驗報告（3）

Example_5

1 package vector;
 2 
 3 public class Cat {
 4     private String name;
 5     private int age;
 6     
 7     public Cat(String name, int age)
 8     {
 9         this.name = name;
10         this.age = age;
11     }
12     
13     public String getName()
14     {
15         return this.name;
16     }
17     public int getAge()
18     {
19         return this.age;
20     }
21     public String toString()
22     {
23         return getName() + "," + getAge();
24     }
25 }
26 
27 public class vector {
28     public static void main(String args[])
29     {
30         Vector <Cat>cats = new Vector<Cat>();
31         cats.add(new Cat("Jetty", 1));
32         cats.add(new Cat("Carr", 3));
33         for(int i=cats.size()-1; i>=0; i--)
34         {
35             System.out.println(cats.get(i));
36         }
37     }
38 }

輸出結果：

Java上機實驗報告（3）

Example_6

1 package map;
 2 
 3 class Cat {
 4     private String name;
 5     private int age;
 6     
 7     public Cat(String name, int age)
 8     {
 9         this.name = name;
10         this.age = age;
11     }
12     
13     public String getName()
14     {
15         return this.name;
16     }
17     public int getAge()
18     {
19         return this.age;
20     }
21     public String toString()
22     {
23         return getName() + "," + getAge();
24     }
25 }
26 package map;
27 
28 import java.util.*;
29 
30 public class example_6 {
31     public static void main(String[] args)
32     {
33         Map <String, Cat>cats = new HashMap <String, Cat>();
34         cats.put("Jetty", new Cat("Jetty", 1));
35         cats.put("Carr", new Cat("Carr", 3));
36         Cat cat = cats.get("Carr");
37         System.out.println(cat);
38         
39         Set <String>keys = cats.keySet();
40         Iterator <String>ite = keys.iterator();
41         while(ite.hasNext())
42         {
43             System.out.println(cats.get(ite.next()));
44         }
45     }
46 }

輸出結果：

Java上機實驗報告（3）

總結：如果涉及到堆棧，隊列等操作，應該考慮用List，對于需要快速插入，删除元素，應該使用LinkedList，如果需要快速随機通路元素，應該使用ArrayList。

　　如果程式在單線程環境中，或者通路僅僅在一個線程中進行，考慮非同步的類，其效率較高，如果多個線程可能同時操作一個類，應該使用同步的類。

　　要特别注意對哈希表的操作，作為key的對象要正确複寫equals和hashCode方法。

　　盡量傳回接口而非實際的類型，如傳回List而非ArrayList，這樣如果以後需要将ArrayList換成LinkedList時，用戶端代碼不用改變。這就是針對抽象程式設計。

轉載于:https://www.cnblogs.com/ku1274755259/p/11108715.html

Java上機實驗報告（3）

一、任務簡要描述

二、問題及解決

繼續閱讀

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

NOSQL安全攻擊

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

登入plsql 報錯 the account is locked --使用者被鎖

Effective Java 8:通用程式設計

SequoiaDB巨杉資料庫C++驅動概述

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method