Java2 JDK5.0 教 學 手 冊 第 三 版 洪 維 恩 編 著 博 碩 文 化 出 版 書 號 pg20210 本 章 學 習 目 標 第 十 六 章 Java collection 集 合 物 件 認 識 collection 架 構 認 識 並 學 習 如 何 建 立 各 種 集 合 物 件 學 習 利 用 Iterator 介 面 的 method 走 訪 元 素 學 習 利 用 ListIterator 介 面 的 method 走 訪 元 素
Java collection 集 合 物 件 16-2 16.1 認 識 集 合 物 件 集 合 物 件 是 指 一 群 相 關 聯 的 資 料, 集 合 在 一 起 組 成 一 個 物 件 集 合 物 件 裡 的 資 料, 稱 為 元 素 16.1.1 認 識 collection 架 構 Java Collections Framework, 包 括 了 三 個 部 分 : (a) 介 面 (Interface) (b) 演 算 法 (Algorithms) (c) 實 作 (Implementations)
Java collection 集 合 物 件 16-3 下 圖 是 各 種 collection 介 面 的 繼 承 關 係 圖 Collection Set SortedSet TreeSet HashSet List LinkedList ArrayList Map SortedMap TreeMap 繼 承 的 介 面 實 作 的 類 別 HashMap
Java collection 集 合 物 件 16-4 16.1.2 泛 型 與 collection 泛 型 (generic) 在 編 譯 時 期 即 會 檢 查 集 合 物 件 的 型 態 想 要 在 TreeSet 類 別 的 集 合 物 件 裡 儲 存 整 數 int 型 態 的 資 料, 可 以 做 出 如 下 的 宣 告 : TreeSet<Integer> tset=new TreeSet<Integer>(); 小 於 及 大 於 符 號 (< >) 所 含 括 起 來 的 型 態, 就 是 泛 型 型 態
Java collection 集 合 物 件 16-5 16.2 實 作 Set 介 面 集 合 中 的 元 素 並 沒 有 特 定 的 順 序, 但 是 元 素 不 能 重 覆 出 現 下 表 列 出 了 Set 介 面 較 常 用 的 method: 表 16.2.1 Set 介 面 常 用 的 method method boolean add(e o) 主 要 功 能 將 物 件 o 新 增 為 元 素, 成 功 時 傳 回 true boolean addall(collection<? extends E> c) 將 Collection 的 元 素 新 增 為 此 集 合 的 元 素, 成 功 時 傳 回 true void clear() boolean contains(object o) 從 集 合 中 移 除 所 有 的 元 素 當 集 合 物 件 裡 包 含 元 素 o 時, 傳 回 true boolean containsall(collection<?> c) 當 集 合 物 件 裡 包 含 Collection 的 元 素 c 時, 傳 回 true boolean isempty() boolean remove(object o) boolean removeall(collection<?> c) 集 合 物 件 若 沒 有 任 何 元 素, 傳 回 true 從 集 合 物 件 中 刪 除 物 件 o, 成 功 時 傳 回 true 從 集 合 物 件 中 刪 除 Collection 的 元 素 c, 成
Java collection 集 合 物 件 16-6 method boolean retainall(collection<?> c) int size() Iterator<E> iterator() 主 要 功 能 功 時 傳 回 true 從 集 合 物 件 中 保 留 Collection 的 元 素 c, 其 餘 刪 除, 成 功 時 傳 回 true 傳 回 集 合 物 件 的 元 素 個 數 取 得 集 合 物 件
Java collection 集 合 物 件 16-7 16.2.1 實 作 Set 介 面 HashSet 類 別 HashSet 類 別 是 實 作 Set 介 面 的 類 別, 利 用 雜 湊 表 (hash table) 演 算 法 來 改 進 執 行 的 效 率 下 表 列 出 常 用 的 HashSet 建 構 元 : 表 16.2.2 建 構 元 java.util.hashset<e> 類 別 的 建 構 元 主 要 功 能 HashSet() HashSet(Collection<? extends E> c) 建 立 一 個 全 新 空 的 HashSet 物 件, 預 設 的 元 素 個 數 為 16 個 建 立 一 個 新 的 且 包 含 特 定 的 Collection 物 件 c 之 HashSet 物 件
Java collection 集 合 物 件 16-8 下 面 是 一 個 簡 單 的 範 例, 說 明 如 何 利 用 HashSet 類 別 01 // app16_1, 簡 單 的 HashSet 範 例 02 import java.util.*; 03 public class app16_1 04 { 05 public static void main(string args[]) 06 { 07 HashSet<String> hset=new HashSet<String>(); 08 09 String str1="puppy"; 10 String str2="kitten"; 11 System.out.println("Hash empty: "+hset.isempty()); 12 hset.add("moneky"); // 增 加 元 素 13 hset.add("bunny"); // 增 加 元 素 14 hset.add(str1); // 增 加 元 素 15 hset.add(str2); // 增 加 元 素 16 17 System.out.println("Hash size="+hset.size());// 顯 示 元 素 個 數 18 System.out.println("Hash empty: "+hset.isempty()); 19 System.out.println("HashSet 內 容 :"+hset);// 顯 示 集 合 物 件 的 內 容 20 21 hset.remove(str2); 22 System.out.println(" 清 除 Kitten..., Hash size="+hset.size()); 23 24 System.out.println("Hash 中 是 否 有 "+str2+"? "+hset.contains(str2)); 25 System.out.println("Hash 中 是 否 有 fish? "+hset.contains("fish"));
Java collection 集 合 物 件 16-9 26 System.out.println("Hash 中 是 否 有 Puppy? "+hset.contains("puppy")); 27 hset.remove("bunny"); 28 System.out.println(" 清 除 Bunny..., Hash size="+hset.size()); 29 30 System.out.println("HashSet 內 容 :"+hset); 31 hset.clear(); 32 System.out.println(" 清 除 Hash 中 所 有 的 物 件..."); 33 System.out.println("Hash empty: "+hset.isempty()); 34 } 35 } /* app16_1 OUTPUT------------------------- Hash empty: true Hash size=4 Hash empty: false HashSet 內 容 :[Moneky, Kitten, Bunny, Puppy] 清 除 Kitten..., Hash size=3 Hash 中 是 否 有 Kitten? false Hash 中 是 否 有 fish? false Hash 中 是 否 有 Puppy? true 清 除 Bunny..., Hash size=2 HashSet 內 容 :[Moneky, Puppy] 清 除 Hash 中 所 有 的 物 件... Hash empty: true -------------------------------------------*/
Java collection 集 合 物 件 16-10 16.2.2 實 作 SortedSet 介 面 TreeSet 類 別 SortedSet 中 的 資 料 會 由 小 而 大 排 列, 為 一 種 排 序 集 合 物 件 (sorted collection) 實 作 SortedSet 介 面 的 是 TreeSet 類 別, 其 常 用 的 建 構 元 如 下 表 所 示 : 表 16.2.3 建 構 元 java.util.treeset<e> 類 別 的 建 構 元 主 要 功 能 TreeSet() TreeSet(Collection<? extends E> c) 建 立 一 個 全 新 空 的 TreeSet 物 件 建 立 一 個 新 的 且 包 含 特 定 的 Collection 物 件 c 之 TreeSet 物 件
Java collection 集 合 物 件 16-11 下 表 為 SortedSet 介 面 的 method: 表 16.2.4 SortedSet 介 面 的 method method E first() SortedSet<E> headset(e toelm) E last() SortedSet<E> subset(e fromelm, E toelm) SortedSet<E> tailset(e fromelm) 主 要 功 能 取 得 集 合 物 件 中 的 第 一 個 元 素 取 得 小 於 toelm 的 TreeSet 物 件 取 得 集 合 物 件 中 的 最 後 一 個 元 素 取 得 大 於 等 於 fromelm, 且 小 於 toelm 的 TreeSet 物 件 取 得 大 於 等 於 fromelm 的 TreeSet 物 件 app16_2 是 一 個 簡 單 的 TreeSet 範 例 01 // app16_2, 簡 單 的 TreeSet 範 例 02 import java.util.*; 03 public class app16_2 04 { 05 public static void main(string args[]) 06 { 07 TreeSet<Integer> tset=new TreeSet<Integer>();
Java collection 集 合 物 件 16-12 08 09 for(int i=20;i>=2;i-=2) // 增 加 元 素 10 tset.add(i); 11 12 System.out.println(" 元 素 個 數 ="+tset.size()); 13 System.out.println(" 集 合 內 容 ="+tset); // 顯 示 集 合 物 件 的 內 容 14 15 System.out.println(" 第 一 個 元 素 ="+tset.first()); 16 System.out.println(" 最 後 一 個 元 素 ="+tset.last()); 17 System.out.println(" 介 於 6 和 14 之 間 的 集 合 ="+tset.subset(6,14)); 18 System.out.println(" 大 於 等 於 10 的 集 合 ="+tset.tailset(10)); 19 System.out.println(" 小 於 8 的 集 合 ="+tset.headset(8)); 20 } 21 } /* app16_2 OUTPUT------------------------- 元 素 個 數 =10 集 合 內 容 =[2, 4, 6, 8, 10, 12, 14, 16, 18, 20] 第 一 個 元 素 =2 最 後 一 個 元 素 =20 介 於 6 和 14 之 間 的 集 合 =[6, 8, 10, 12] 大 於 等 於 10 的 集 合 =[10, 12, 14, 16, 18, 20] 小 於 8 的 集 合 =[2, 4, 6] -------------------------------------------*/
Java collection 集 合 物 件 16-13 16.3 實 作 List 介 面 List 屬 於 有 序 集 合 物 件 (ordered collection), 會 依 照 特 定 的 順 序 排 列 List 中 的 資 料 可 以 重 覆, 且 元 素 有 索 引 值 (index) 下 表 列 出 了 List 介 面 裡 常 用 的 method: 表 16.3.1 List 介 面 常 用 的 method method void add(int index, E element) boolean addall(int index, Collection<? extends E> c) E get(int index) int indexof(object o) 主 要 功 能 在 index 位 置 加 入 element 元 素,List 的 索 引 值 從 0 開 始 在 index 位 置 加 入 Collection 的 所 有 元 素, 成 功 時 傳 回 true 從 集 合 中 取 得 並 傳 回 索 引 值 為 index 的 元 素 搜 尋 集 合 中 是 否 有 與 o 相 同 的 元 素, 傳 回 第 一 個 搜 尋 到 的 索 引 值, 找 不 到 則 傳 回 -1
Java collection 集 合 物 件 16-14 method Iterator iterator() int lastindexof(object o) 主 要 功 能 取 得 集 合 物 件 搜 尋 集 合 中 是 否 有 與 o 相 同 的 元 素, 傳 回 最 後 一 個 搜 尋 到 的 索 引 值, 找 不 到 則 傳 回 -1 ListIterator<E> listiterator() 取 得 實 作 ListIterator<E> 介 面 的 集 合 物 件, 即 listiterator(0), 第 一 個 元 素 的 索 引 值 為 0 ListIterator<E> listiterator(int index) 取 得 實 作 ListIterator<E> 介 面 的 集 合 物 件, 第 一 個 元 素 的 索 引 值 為 index E remove(int index) E set(int index, E element) 從 集 合 物 件 中 刪 除 index 位 置 的 元 素 將 集 合 中 index 位 置 的 元 素 置 換 成 element List<E> sublist(int fromindex, int toindex) 傳 回 索 引 值 fromindex( 含 ) 到 toindex( 不 含 ) 位 置 的 子 集 合
Java collection 集 合 物 件 16-15 16.3.1 實 作 List 介 面 LinkedList 類 別 鏈 結 串 列 (linked list) 的 節 點 (node), 分 為 2 個 欄 位, 分 別 是 資 料 欄 及 鏈 結 欄 : first 節 點 資 料 欄 鏈 結 欄 a b c d 節 點 儲 存 的 資 料 指 向 下 一 個 節 點 的 位 址 null 上 圖 可 改 寫 成 另 一 種 表 示 方 式 : 元 素 元 素 值 索 引 值 index a 0 b 1 c 2 d 3 first last
Java collection 集 合 物 件 16-16 下 圖 是 將 e 加 到 圖 16.3.2 中 的 LinkedList 物 件 起 始 處 之 後 的 情 形 : 索 引 值 會 自 動 重 新 排 列 元 素 值 索 引 值 index e 0 first a 1 b 2 c 3 d 4 last 下 表 列 出 LinkedList 建 構 元 與 常 用 的 method: 表 16.3.2 java.util.linkedlist<e> 類 別 的 建 構 元 與 method 建 構 元 LinkedList() LinkedList(Collection<? extends E> c) 主 要 功 能 建 立 一 個 空 的 LinkedList 物 件 建 立 一 個 包 含 特 定 的 Collection 物 件 c 之 LinkedList 物 件
Java collection 集 合 物 件 16-17 method void addfirst(e o) void addlast (E o) E getfirst() E getlast() E removefirst() E removelast() 主 要 功 能 將 元 素 o 加 入 LinkedList 物 件 的 起 始 處 將 元 素 o 加 入 LinkedList 物 件 的 結 尾 處 取 得 LinkedList 物 件 中 的 第 一 個 元 素 取 得 LinkedList 物 件 中 的 最 後 一 個 元 素 刪 除 並 傳 回 LinkedList 物 件 中 的 第 一 個 元 素 刪 除 並 傳 回 LinkedList 物 件 中 的 最 後 一 個 元 素 範 例 app16_3 是 LinkedList 的 簡 單 範 例 01 // app16_3, LinkedList 範 例 02 import java.util.*; 03 public class app16_3 04 { 05 public static void main(string args[]) 06 { 07 LinkedList<Integer> llist=new LinkedList<Integer>(); 08 09 for(int i=10;i<=30;i+=10) // 增 加 元 素 10 llist.add(i); 11 llist.addfirst(100);
Java collection 集 合 物 件 16-18 12 llist.addlast(200); 13 llist.addfirst(300); 14 15 System.out.println(" 元 素 個 數 ="+llist.size()); 16 System.out.print("LinkedList 的 元 素 :"); 17 for(int i=0;i<llist.size();i++) // 顯 示 集 合 物 件 的 內 容 18 System.out.print(llist.get(i)+" "); 19 20 System.out.print("\n 刪 除 最 後 一 個 元 素 "); 21 System.out.println(llist.removeLast()+"..."); 22 23 System.out.println(" 第 一 個 元 素 ="+llist.getfirst()); 24 System.out.println(" 最 後 一 個 元 素 ="+llist.getlast()); 25 System.out.println(" 元 素 值 為 200 的 索 引 值 ="+llist.indexof(200)); 26 } 27 } /* app16_3 OUTPUT------------------------- 元 素 個 數 =6 LinkedList 的 元 素 :300 100 10 20 30 200 刪 除 最 後 一 個 元 素 200... 第 一 個 元 素 =300 最 後 一 個 元 素 =30 元 素 值 為 200 的 索 引 值 =-1 -------------------------------------------*/
Java collection 集 合 物 件 16-19 16.3.2 實 作 List 介 面 ArrayList 類 別 元 素 加 入 ArrayList 物 件 時, 是 用 索 引 值 (index) 依 序 儲 存 ArrayList 類 別 的 建 構 元 如 下 表 所 示 : 表 16.3.3 java.util.arraylist<e> 類 別 的 建 構 元 建 構 元 ArrayList() ArrayList(Collection<? extends E> c) ArrayList(int initialcapacity) 主 要 功 能 建 立 一 個 空 的 ArrayList 物 件, 預 設 的 元 素 個 數 為 10 個 建 立 一 個 包 含 特 定 的 Collection 物 件 c 之 ArrayList 物 件 建 立 一 個 空 的 ArrayList 物 件, 指 定 的 元 素 個 數 為 initialcapacity 個
Java collection 集 合 物 件 16-20 ArrayList 類 別 除 了 實 作 List 介 面 的 method, 新 增 加 的 method 如 下 : 表 16.3.4 java.util.arraylist 類 別 的 method method void ensurecapacity(int mincapacity) void trimtosize() 主 要 功 能 設 定 ArrayList 物 件 的 容 量, 元 素 的 個 數 至 少 有 mincapacity 個 將 ArrayList 物 件 的 容 量 剪 裁 成 目 前 元 素 的 數 量
Java collection 集 合 物 件 16-21 app16_4 是 ArrayList 的 範 例 01 // app16_4, ArrayList 範 例 02 import java.util.*; 03 public class app16_4 04 { 05 public static void main(string args[]) 06 { 07 ArrayList<Integer> alist=new ArrayList<Integer>(); 08 09 for(int i=10;i<=50;i+=10) // 增 加 元 素 10 alist.add(i); 11 alist.add(3,200); 12 alist.add(0,300); 13 alist.add(400); 14 15 System.out.println(" 元 素 個 數 ="+alist.size()); 16 System.out.println("ArrayList 的 元 素 :"+alist); 17 System.out.println(" 將 索 引 值 1 的 元 素 以 200 取 代..."); 18 alist.set(1,200); 19 System.out.println("ArrayList 的 元 素 :"+alist); 20 System.out.print(" 第 一 個 元 素 值 為 200 的 索 引 值 ="); 21 System.out.println(alist.indexOf(200));
Java collection 集 合 物 件 16-22 22 System.out.print(" 最 後 一 個 元 素 值 為 200 的 索 引 值 ="); 23 System.out.println(alist.lastIndexOf(200)); 24 } 25 } /* app16_4 OUTPUT----------------------------------- 元 素 個 數 =8 ArrayList 的 元 素 :[300, 10, 20, 30, 200, 40, 50, 400] 將 索 引 值 1 的 元 素 以 200 取 代... ArrayList 的 元 素 :[300, 200, 20, 30, 200, 40, 50, 400] 第 一 個 元 素 值 為 200 的 索 引 值 =1 最 後 一 個 元 素 值 為 200 的 索 引 值 =4 ----------------------------------------------------*/
Java collection 集 合 物 件 16-23 16.4 實 作 Map 介 面 Map 要 以 關 鍵 值 (key) 儲 存 關 鍵 值 會 對 應 到 指 定 的 資 料, 即 對 應 值 (value) 下 表 為 Map 介 面 常 用 的 method: 表 16.4.1 Map<K,V> 介 面 常 用 的 method method void clear() boolean containskey(object key) boolean containsvalue(object value) V get(object key) boolean isempty() Set<K> keyset() V put(k key, V value) 主 要 功 能 從 集 合 中 移 除 所 有 的 元 素 當 集 合 物 件 裡 包 含 關 鍵 值 key, 即 傳 回 true 當 集 合 物 件 裡 包 含 對 應 值 value, 即 傳 回 true 傳 回 集 合 物 件 中 關 鍵 值 key 的 對 應 值 集 合 物 件 若 沒 有 任 何 元 素, 傳 回 true 將 關 鍵 值 轉 換 成 實 作 Set 介 面 的 物 件 將 關 鍵 值 key 新 增 至 集 合 物 件 中, 若 key 值 相 同, 則 將 對 應 值 value 取 代 舊 有 的 資 料
Java collection 集 合 物 件 16-24 method V remove(object key) int size() Collection<V> values() 主 要 功 能 從 集 合 物 件 中 刪 除 關 鍵 值 key 的 元 素, 成 功 時 傳 回 被 刪 除 的 value 值, 否 則 傳 回 null 傳 回 集 合 物 件 的 元 素 個 數 將 對 應 值 轉 換 成 實 作 Collection 介 面 的 物 件
Java collection 集 合 物 件 16-25 16.4.1 實 作 Map 介 面 HashMap 類 別 下 表 列 出 HashMap 類 別 的 建 構 元 : 表 16.4.2 java.util.hashmap<k,v> 類 別 的 建 構 元 建 構 元 HashMap() HashMap(int initialcapacity) HashMap(Map<? extends K,? extends V> m) 主 要 功 能 建 立 一 個 空 的 HashMap 物 件, 預 設 的 元 素 個 數 為 16 個 建 立 一 個 空 的 HashMap 物 件, 指 定 的 元 素 個 數 為 initialcapacity 個 建 立 一 個 包 含 特 定 的 Map 物 件 m 之 HashMap 物 件
Java collection 集 合 物 件 16-26 下 面 的 程 式 是 將 物 件 加 入 HashMap 之 範 例 01 // app16_5, HashMap 範 例 02 import java.util.*; 03 public class app16_5 04 { 05 public static void main(string args[]) 06 { 07 HashMap<Integer,String> hmap=new HashMap<Integer,String>(); 08 09 hmap.put(94001,"fiona"); 10 hmap.put(94003,"ariel"); 11 hmap.put(94002,"ryan"); 12 13 System.out.println(" 元 素 個 數 ="+hmap.size()); 14 System.out.println("HashMap 的 元 素 :"+hmap); 15 System.out.print("HashMap 中 是 否 有 關 鍵 值 94002? "); 16 System.out.println(hmap.containsKey(94002)); 17 System.out.print("HashMap 中 是 否 有 對 應 值 Kevin? "); 18 System.out.println(hmap.containsValue("Kevin")); 19 hmap.remove(94001); 20 System.out.print(" 清 除 關 鍵 值 94001 的 資 料..., ");
Java collection 集 合 物 件 16-27 21 System.out.println(" 元 素 個 數 ="+hmap.size()); 22 System.out.println("HashMap 的 元 素 :"+hmap); 23 System.out.println(" 關 鍵 值 94003 的 對 應 值 ="+hmap.get(94003)); 24 } 25 } /* app16_5 OUTPUT---------------------------------- 元 素 個 數 =3 HashMap 的 元 素 :{94001=Fiona, 94003=Ariel, 94002=Ryan} HashMap 中 是 否 有 關 鍵 值 94002? true HashMap 中 是 否 有 對 應 值 Kevin? false 清 除 關 鍵 值 94001 的 資 料..., 元 素 個 數 =2 HashMap 的 元 素 :{94003=Ariel, 94002=Ryan} 關 鍵 值 94003 的 對 應 值 =Ariel ---------------------------------------------------*/
Java collection 集 合 物 件 16-28 16.4.2 實 作 SortedMap 介 面 TreeMap 類 別 TreeMap 類 別 儲 存 的 元 素 分 為 關 鍵 值 key 與 對 應 值 value, 元 素 會 依 關 鍵 值 由 小 至 大 排 序 下 表 列 出 SortedMap 類 別 的 建 構 元 及 method: 表 16.4.3 java.util.treemap<k,v> 類 別 的 建 構 元 與 method 建 構 元 TreeMap() TreeMap(Map<? extends K,? extends V> m) TreeMap(SortedMap<K,? extends V> m) 主 要 功 能 建 立 一 個 空 的 TreeMap 物 件, 依 關 鍵 值 由 小 至 大 排 序 建 立 一 個 包 含 特 定 的 Map 物 件 m 之 TreeMap 物 件 建 立 一 個 包 含 特 定 的 實 作 SortedMap 介 面 物 件 m 之 TreeMap 物 件
Java collection 集 合 物 件 16-29 method K firstkey() K lastkey() SortedMap<E> submap(k fromkey, K tokey) SortedMap<E> tailmap(k fromkey) 主 要 功 能 傳 回 集 合 中 第 一 個 關 鍵 值, 即 最 小 關 鍵 值 傳 回 集 合 中 最 後 一 個 關 鍵 值, 即 最 大 關 鍵 值 取 得 大 於 等 於 fromkey, 且 小 於 tokey 的 TreeMap 物 件 取 得 大 於 等 於 fromkey 的 TreeMap 物 件 app16_6 是 TreeMap 的 簡 單 範 例 01 // app16_6, TreeMap 範 例 02 import java.util.*; 03 public class app16_6 04 { 05 public static void main(string args[]) 06 { 07 int k1=94001,k2=94003,key; 08 TreeMap<Integer,String> tmap=new TreeMap<Integer,String>(); 09 10 tmap.put(94001,"fiona"); 11 tmap.put(94003,"ariel"); 12 tmap.put(94002,"ryan");
Java collection 集 合 物 件 16-30 13 tmap.put(94004,"jack"); 14 15 System.out.println(" 元 素 個 數 ="+tmap.size()); 16 System.out.println("TreeMap 的 元 素 :"+tmap); 17 key=tmap.firstkey(); 18 System.out.println(" 第 一 個 元 素 = "+key+", "+tmap.get(key)); 19 key=tmap.lastkey(); 20 System.out.println(" 最 後 一 個 元 素 = "+key+", "+tmap.get(key)); 21 System.out.print(" 介 於 "+k1+" 和 "+k2+" 之 間 的 TreeMap="); 22 System.out.println(tmap.subMap(k1,k2)); 23 System.out.print(" 大 於 等 於 "+k2+" 的 TreeMap="); 24 System.out.println(tmap.tailMap(k2)); 25 } 26 } /* app16_6 OUTPUT---------------------------------------------- 元 素 個 數 =4 TreeMap 的 元 素 :{94001=Fiona, 94002=Ryan, 94003=Ariel, 94004=Jack} 第 一 個 元 素 = 94001, Fiona 最 後 一 個 元 素 = 94004, Jack 介 於 94001 和 94003 之 間 的 TreeMap={94001=Fiona, 94002=Ryan} 大 於 等 於 94003 的 TreeMap={94003=Ariel, 94004=Jack} ---------------------------------------------------------------*/
Java collection 集 合 物 件 16-31 16.5 走 訪 集 合 物 件 的 元 素 Iterator 與 ListIterator 介 面, 可 用 來 走 訪 或 是 刪 除 集 合 物 件 的 元 素 16.5.1 使 用 Iterator 介 面 走 訪 元 素 Iterator 物 件 的 讀 取 是 單 向 的, 且 只 能 讀 取 一 次 下 表 列 出 Iterator 介 面 的 method: 表 16.5.1 Iterator<E> 的 method method Iterator<E> iterator() boolean hasnext() E next() void remove() 主 要 功 能 取 得 實 作 Iterator<E> 介 面 的 集 合 物 件 集 合 中 若 是 有 下 一 個 元 素, 即 傳 回 true 傳 回 集 合 的 下 一 個 元 素 刪 除 集 合 中 最 後 一 個 取 得 的 元 素
Java collection 集 合 物 件 16-32 想 走 訪 TreeSet<String> 物 件 tset, 程 式 的 敘 述 及 解 釋 如 下 圖 所 示 : 與 實 作 Iterator 介 面 的 集 合 物 件 之 泛 型 型 態 相 同 實 作 Iterator 介 面 的 集 合 物 件 名 稱 Iterator< String > itr = tset. iterator() ; Iterator 介 面 的 iterator() method 取 得 實 作 Iterator<E> 介 面 的 集 合 物 件 名 稱 下 面 是 利 用 Iterator 介 面 的 method 走 訪 物 件 裡 的 元 素 的 範 例 : 01 // app16_7, 以 Iterator 走 訪 TreeSet 元 素 02 import java.util.*; 03 public class app16_7 04 { 05 public static void main(string args[]) 06 { 07 TreeSet<String> tset=new TreeSet<String>(); 08 String str=""; 09 tset.add("moneky"); // 增 加 元 素 10 tset.add("bunny"); // 增 加 元 素
Java collection 集 合 物 件 16-33 11 tset.add("puppy"); // 增 加 元 素 12 tset.add("kitten"); // 增 加 元 素 13 14 Iterator<String> itr=tset.iterator(); 15 System.out.print("TreeSet 內 容 :"); 16 while(itr.hasnext()) // 走 訪 元 素 17 { 18 str=itr.next(); 19 System.out.print(str+" "); // 印 出 元 素 內 容 20 } 21 22 System.out.println("\n 刪 除 最 後 讀 取 的 元 素 "+str+"..."); 23 itr.remove(); // 刪 除 最 後 讀 取 的 元 素 24 System.out.println("TreeSet 內 容 :"+tset); 25 } 26 } /* app16_7 OUTPUT--------------------- TreeSet 內 容 :Bunny Kitten Moneky Puppy 刪 除 最 後 讀 取 的 元 素 Puppy... TreeSet 內 容 :[Bunny, Kitten, Moneky] --------------------------------------*/
Java collection 集 合 物 件 16-34 16.5.2 使 用 ListIterator 介 面 走 訪 元 素 ListIterator 物 件 的 走 訪 可 以 是 雙 向 的 下 表 列 出 ListIterator 介 面 的 method: 表 16.5.2 ListIterator<E> 的 method method ListIterator<E> listiterator() ListIterator<E> listiterator(int index) void add(e o) boolean hasnext() boolean hasprevious() E next() int nextindex() E previous() int previousindex() 主 要 功 能 取 得 實 作 ListIterator<E> 介 面 的 集 合 物 件, 即 listiterator(0), 第 一 個 元 素 的 索 引 值 為 0 取 得 實 作 ListIterator<E> 介 面 的 集 合 物 件, 第 一 個 元 素 的 索 引 值 為 index 在 下 一 個 元 素 前 加 入 o 集 合 中 若 是 有 下 一 個 元 素, 即 傳 回 true 集 合 中 若 是 有 前 一 個 元 素, 即 傳 回 true 傳 回 集 合 的 下 一 個 元 素 傳 回 集 合 的 下 一 個 元 素 之 索 引 值 傳 回 集 合 的 前 一 個 元 素 傳 回 集 合 的 前 一 個 元 素 之 索 引 值
Java collection 集 合 物 件 16-35 method void remove() void set(e o) 主 要 功 能 刪 除 集 合 中 最 後 一 個 取 得 的 元 素 將 集 合 中 的 最 後 一 個 元 素 以 o 取 代 下 圖 為 listiterator() method 的 使 用 說 明 : 與 實 作 ListIterator 介 面 的 集 合 物 件 之 泛 型 型 態 相 同 實 作 ListIterator 介 面 的 集 合 物 件 名 稱 ListIterator< Integer > litr = llist. listiterator() ; 取 得 實 作 ListIterator<E> 介 面 的 集 合 物 件 名 稱 ListIterator 介 面 的 listiterator() method
Java collection 集 合 物 件 16-36 listiterator() method 的 使 用 方 法 如 下 : 01 // app16_8, 以 ListIterator 走 訪 LinkedList 元 素 02 import java.util.*; 03 public class app16_8 04 { 05 public static void main(string args[]) 06 { 07 LinkedList<Integer> llist=new LinkedList<Integer>(); 08 09 for(int i=10;i<=100;i+=10) // 增 加 元 素 10 llist.add(i); 11 12 ListIterator<Integer> litr1=llist.listiterator(); 13 14 System.out.print(" 正 向 列 出 LinkedList 內 容 :"); 15 while(litr1.hasnext()) // 正 向 走 訪 元 素 16 System.out.print(litr1.next()+" "); // 印 出 元 素 內 容 17 System.out.println(); 18 19 ListIterator<Integer> litr2=llist.listiterator(llist.size()); 20 System.out.print(" 反 向 列 出 LinkedList 內 容 :"); 21 while(litr2.hasprevious()) // 反 向 走 訪 元 素
Java collection 集 合 物 件 16-37 22 System.out.print(litr2.previous()+" "); // 印 出 元 素 內 容 23 System.out.println(); 24 } 25 } /* app16_8 OUTPUT----------------------------------- 正 向 列 出 LinkedList 內 容 :10 20 30 40 50 60 70 80 90 100 反 向 列 出 LinkedList 內 容 :100 90 80 70 60 50 40 30 20 10 ----------------------------------------------------*/
Java collection 集 合 物 件 16-38