2. 程式人生 > >java類集

java類集

阿新 • • 發佈：2018-11-13

在java中必須掌握的知識點，會開發的：
1.面向物件
2.java的類集
3.java IO
4.JDBC

本章目標：
*掌握java設定類集框架的目的
*掌握類集中的各個主要的介面
*掌握Collection介面的作用

類集的作用
類集實際上就是一個動態的物件陣列，與一般的物件陣列不同，類集上的物件內容可以任意擴充
類集的特徵：
*這種框架是高效能的
*框架必須允許不是同類型的類集一相同的方式和高度互相操作方式工作
*類集必須是容易擴充套件和修改的

物件陣列中包含一組物件，但是物件陣列的使用的時候存在一個長度的限制，那麼類集是專門解決這種限制的，使用類集可以方便的向陣列中增加任意多個數據
物件陣列的操作中基本上都要保證物件型別的一致性，對於類集而言其本身內部的元素也應該保持一致，不管是何種型別的資料，所有的操作方式都應該是一樣的

類集框架的主要介面
在這裡插入圖片描述
以上的介面必須全部掌握，並且掌握各個介面的主要特點。

介面的繼承關係
在這裡插入圖片描述

Collection介面的使用注意
在一般的開發中，往往很少直接使用Connection介面進行開發，而基本上都是使用期子介面，子介面主要有：List、Set、Queue、SortedSet

Collection子介面的定義
在這裡插入圖片描述

1.1 List介面
Connection下分為很多的子介面，其中有一個List介面，List介面中可以存放任意的資料，而且在List介面中內容是允許重複的。
List介面的功能要比Collection介面強太多，因為大量擴充了Collection介面的操作
public interface List extends Collection

List介面的擴充套件方法
在這裡插入圖片描述

List介面的常用子類——ArrayList
在這裡插入圖片描述
如果想用介面，則肯定要使用物件的多型性進行例項化的操作，那麼對於List介面本身也是一樣的
ArrayList是List中最常用的子類

package Listdemo;

import java.util.ArrayList;
import java.util.List;

 public class ArrayListDemo01 {
public static void main(String[] args) {
	
	List<String> allList = new ArrayList<String>();		//制定操作的泛型為String
	allList.add("hello");		//此方法由Collection介面而來
	allList.add("world");		//預設情況下向最後加入
	System.out.println(allList);
	
}

}
執行結果：
[hello，world]

在指定位置新增，新增的方法是List介面擴充的方法
package Listdemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ArrayListDemo01 {
public static void main(String[] args) {
	
	List<String> allList = null;		
	Collection<String> allCollection = null;
	
	allList = new ArrayList<String>();		//制定操作的泛型為String
	allCollection = new ArrayList<String>();		//指定一個集合
	
	allList.add("hello");		//此方法由Collection介面而來
	allList.add(0,"world");		//在第一個位置新增world
	System.out.println(allList);
	
	allCollection.add("CZK");
	allCollection.add("www.baidu.com");
	
	allList.addAll(allCollection);
	
	System.out.println(allList);
	
}

}
執行結果：
[world, hello]
[world, hello, CZK, www.baidu.com]

package Listdemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ArrayListDemo01 {
public static void main(String[] args) {
	
	List<String> allList = null;		
	Collection<String> allCollection = null;
	
	allList = new ArrayList<String>();		//制定操作的泛型為String
	allCollection = new ArrayList<String>();		//指定一個集合
	
	allList.add("hello");		//此方法由Collection介面而來
	allList.add(0,"world");		//在第一個位置新增world
	System.out.println(allList);
	
	allCollection.add("CZK");
	allCollection.add("www.baidu.com");
	
	allList.addAll(allCollection);
	allList.addAll(0,allCollection);
	
	System.out.println(allList);
	
}

}
執行結果：
[world, hello]
[CZK, www.baidu.com, world, hello, CZK, www.baidu.com]

既然可以增加資料，那麼也可以刪除資料
*List中存在兩種刪除：根據物件內容，根據物件的編號

package Listdemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ArrayListDemo02 {
public static void main(String[] args) {
	List<String> allList = new ArrayList<String>();		//指定操作的泛型為String
	
	allList.add("Hello");		//此方法由Collection介面而來
	allList.add(0,"world");		//在第一個位置新增新的內容
	allList.add("MLDN");		//向Collection中加入內容
	allList.add("www.baidu.com");		
	
	allList.remove(0);	//刪除第一個元素，刪除指定的位置
	allList.remove("Hello");	//此方法由Collection介面繼承而來
	
	System.out.println(allList);
}

}
執行結果：
[MLDN, www.baidu.com]

集合中的內容可以新增可以刪除，那麼實際上最重要的就是輸出
*在List介面中提供了get()方法，利用此方法就可以完成輸出
*通過迴圈完成輸出，迴圈的次數由size()方法取得

package Listdemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ArrayListDemo03 {
public static void main(String[] args) {
	List<String> allList = new ArrayList<String>();		//指定操作的泛型為String
	
	allList.add("Hello");		//此方法由Collection介面而來
	allList.add("Hello");
	allList.add(0,"world");		//在第一個位置新增新的內容
	allList.add("MLDN");		//向Collection中加入內容
	allList.add("www.baidu.com");		
	
	System.out.print("由前向後輸出：" );
	for(int i = 0;i < allList.size();i++) {
		System.out.print(allList.get(i) + "、");
	}
	
	System.out.println();
	
	System.out.print("由後向前和輸出：");
	for(int i = allList.size() - 1;i >= 0;i--) {
		System.out.print(allList.get(i) + "、");
	}
}

}
執行結果：
由前向後輸出：world、Hello、Hello、MLDN、www.baidu.com、
由後向前和輸出：www.baidu.com、MLDN、Hello、Hello、world、
此種輸出方式是List介面所獨有的，而其他介面是沒有的，尤其是Collection中是沒有根據索引取來內容的操作的。

package Listdemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ArrayListDemo04 {
public static void main(String[] args) {
	List<String> allList = new ArrayList<String>();		//指定操作的泛型為String
	
	allList.add("Hello");		//此方法由Collection介面而來
	allList.add(0,"world");		//在第一個位置新增新的內容
	allList.add("MLDN");		//向Collection中加入內容
	allList.add("www.baidu.com");		
	
	String str[] = allList.toArray(new String[] {} );		//指定好型別
	
	System.out.print("指定陣列型別：" );
	for(int i = 0;i < str.length;i++) {
		System.out.print(str[i]+ "、");
	}
	
	System.out.print("\n返回物件陣列：");
	Object obj[] = allList.toArray();		//返回Object型別
	for(int i = 0;i < obj.length;i++) {
		String temp = (String)obj[i];
		System.out.print(temp + "、");
	}
}

}
既然已經完成基本的輸出功能，集合還有以下幾種操作：
*判斷集合是否為空：boolean isEmpty();
*擷取部分集合：List subList(int fromIndex,int toIndex) List介面擴充
*查詢指定的物件是否存在：int indexOf(Object o)，如果查詢到則返回位置，否則返回-1；
*查詢是否存在：boolean contains(Object o)

package Listdemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ArrayListDemo05 {
public static void main(String[] args) { 
	List<String> allList = new ArrayList<String>();		//指定操作的泛型為String
	
	System.out.println("集合操作前是否為空？" + allList.isEmpty());
	
	allList.add("Hello");		//此方法由Collection介面而來
	allList.add(0,"world");		//在第一個位置新增新的內容
	allList.add("MLDN");		//向Collection中加入內容
	allList.add("www.baidu.com");		
	
	System.out.println(allList.contains("Hello") ?"\"Hello\"字串存在!" : "\"Hello\"字串不存在");
	
	List<String> allsub = allList.subList(2,3);
	System.out.println("集合擷取：");
	for(int i = 0;i <allsub.size();i++) {
		System.out.println(allsub.get(i));
	}
	
	System.out.println("MLDN字串的位置：" +allList.indexOf("MLDN"));
	System.out.println("集合操作前是否為空？" + allList.isEmpty());
}

}
執行結果：
集合操作前是否為空？true
"Hello"字串存在!
集合擷取：
MLDN
MLDN字串的位置：2
集合操作前是否為空？false

1.2、LinkedList類
本章目標：
*掌握LinkedList與List介面的關係
*掌握Queue介面的作用

LinkedList子類與Queue介面
在這裡插入圖片描述

Queue介面定義的方法
在這裡插入圖片描述

LinkedList中操作連結串列的部分方法
在這裡插入圖片描述

本身帶來那個擴充了Queue介面和List介面的操作。所以，在使用時最好直接使用LinkedList類完成操作。
為連結串列的開發和結尾增加資料

package linkedlistdemo;

import java.util.LinkedList;

public class LinkedListDemo01 {
public static void main(String[] args) {
	LinkedList<String> link = new LinkedList<String>();
	
	link.add("a");
	link.add("b");
	link.add("c");
	
	System.out.println("初始化連結串列：" +link);
	
	link.addFirst("X");		//在開頭增加資料
	link.addLast("Y");		//在結尾增加資料
	System.out.println("增加開頭和結尾之後的連結串列：" + link);
}

}
執行結果：
初始化連結串列：[a, b, c]
增加開頭和結尾之後的連結串列：[X, a, b, c, Y]

對於連結串列也可以找到表頭

package linkedlistdemo;

import java.util.LinkedList;

public class LinkedListDemo02 {
public static void main(String[] args) {
	LinkedList<String> link = new LinkedList<String>();
	
	link.add("a");
	link.add("b");
	link.add("c");
	
	System.out.println("1-1、element()方法找到表頭：" +link.element());
	System.out.println("1-2、找完之後的連結串列內容：" + link);
	
	System.out.println("2-1、peek()方法找到表頭：" +link.peek());
	System.out.println("2-2、找完之後的連結串列內容：：" +link);
	
	System.out.println("3-1、poll()方法找到表頭：" +link.poll());
	System.out.println("3-2、找完之後的連結串列內容：" +link);
	
}

}
執行結果：
1-1、element()方法找到表頭：a
1-2、找完之後的連結串列內容：[a, b, c]
2-1、peek()方法找到表頭：a
2-2、找完之後的連結串列內容：：[a, b, c]
3-1、poll()方法找到表頭：a
3-2、找完之後的連結串列內容：[b, c]

既然此類實現可Queue介面，那麼來說就可以按照佇列的方法進行先進先出的操作

package linkedlistdemo;

import java.util.LinkedList;

public class LinkedListDemo03 {
public static void main(String[] args) {
	LinkedList<String> link = new LinkedList<String>();
	
	link.add("a");
	link.add("b");
	link.add("c");
	
	System.out.print("以先進先出（FIFO）的方式輸出：");
	for(int i = 0;i<=link.size() + 1;i++) {
		System.out.print(link.poll() + "、");
	}
}

}
執行結果：
以先進先出（FIFO）的方式輸出：a、b、c、

1.3、Set介面
掌握Set介面與Collection介面的關係
掌握Set介面的常用子類：TreeSet、HashSet

Set介面的定義
在這裡插入圖片描述

HashSet：使用雜湊的方式存放內容，本身沒有順序

package setdemo;

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo01 {
public static void main(String[] args) {
	Set<String> allSet = new HashSet<String>();
	allSet.add("A");	//增加內容
	allSet.add("B");	//增加內容
	allSet.add("C");	//增加內容
	allSet.add("C");	//重複內容
	allSet.add("C");	//重複內容
	allSet.add("D");	//增加內容
	allSet.add("E");	//增加內容
	
	System.out.println(allSet);
}

}
是無序排列的，而List介面的內容插入的順序就是其儲存的順序。
如果現在希望所有的內容是可以自動進行排列的操作，則可以使用Set中的第二個子類 TreeSet

package setdemo;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo02 {
public static void main(String[] args) {
	Set<String> allSet = new TreeSet<String>();
	allSet.add("C");	//增加內容
	allSet.add("C");	//重複內容
	allSet.add("C");	//重複內容
	allSet.add("D");	//增加內容
	allSet.add("B");	//增加內容
	allSet.add("A");	//增加內容
	allSet.add("E");	//增加內容
	
	System.out.println(allSet);
}

}
執行結果：[A, B, C, D, E]
TreeSet子類是可以排序的

1.4 排序以及重複元素說明
掌握TreeSet的排序原理
掌握Set介面中重複元素的定義

舉例：
import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo02 {
public static void main(String[] args) {

	Set<Person> allSet = new TreeSet<Person>();
	
	allSet.add(new Person("張三",30));
	allSet.add(new Person("李四",31));
	allSet.add(new Person("王五",32));
	allSet.add(new Person("王五",32));
	allSet.add(new Person("王五",32));
	allSet.add(new Person("趙六",33));
	allSet.add(new Person("孫七",33));
	
	System.out.println(allSet);
}

}

class Person {
private String name;
private int age;

public Person(String name,int age) {
	this.name = name;
	this.age = age;
}

public String getString() {
	return "姓名" + this.name + "年齡：" +this.age;
}

}
執行結果卻出了錯誤：Exception in thread “main” java.lang.ClassCastException: setdemo02.Person cannot be cast to java.lang.Comparable
at java.util.TreeMap.compare(Unknown Source)
at java.util.TreeMap.put(Unknown Source)
at java.util.TreeSet.add(Unknown Source)
at setdemo02.TreeSetDemo02.main(TreeSetDemo02.java:11)

comparable主要是進行排序的操作介面，一個物件陣列要想排序，則依靠comparable介面完成。那麼對於TreeSet也一樣，如果想要使用TreeSet進行排序的操作，則物件所在的類也必須實現comparable介面

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo03 {	
public static void main(String[] args) {
	
	Set<Person01> allSet = new TreeSet<Person01>();
	
	allSet.add(new Person01("張三",30));
	allSet.add(new Person01("李四",31));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("趙六",33));
	allSet.add(new Person01("孫七",33));
	
	System.out.println(allSet);
}

}

class Person01 implements Comparable<Person01>{
private String name;
private int age;

public Person01(String name,int age) {
	this.name = name;
	this.age = age;
}

public String toString() {
	return "姓名:" + this.name + ";年齡：" +this.age;
}

public int compareTo(Person01 per) { 
	if(this.age > per.age) {
		return 1;
	}else if(this.age < per.age){
		return -1;
	}else {
		return 0;
	}
}

}
執行結果：
[姓名:張三;年齡：30, 姓名:李四;年齡：31, 姓名:王五;年齡：32, 姓名:趙六;年齡：33]

String類既然可以使用TreeSet排序，則String中肯定已經實現了comparable介面。但是結果有問題。發現此時去掉了重複的元素，但是依靠的是comparable完成的。孫七沒有加入進來，因為孫七和趙六的年齡是一樣的。comparable介面比較的只是年齡，所以為了保證正確，所有的屬性都應該進行比較。

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo03 {
public static void main(String[] args) {

	Set<Person01> allSet = new TreeSet<Person01>();
	
	allSet.add(new Person01("張三",30));
	allSet.add(new Person01("李四",31));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("趙六",33));
	allSet.add(new Person01("孫七",33));
	
	System.out.println(allSet);
}

}

class Person01 implements Comparable{
private String name;
private int age;

public Person01(String name,int age) {
	this.name = name;
	this.age = age;
}

public String toString() {
	return "姓名:" + this.name + ";年齡：" +this.age;
}

public int compareTo(Person01 per) {
	if(this.age > per.age) {
		return 1;
	}else if(this.age < per.age){
		return -1;
	}else {
		return this.name.compareTo(per.name);
	}
}

}
執行結果：[姓名:張三;年齡：30, 姓名:李四;年齡：31, 姓名:王五;年齡：32, 姓名:孫七;年齡：33, 姓名:趙六;年齡：33]

此時去掉的重複元素並不是真正意義上的重複元素取消。

import java.util.HashSet;
import java.util.Set;

public class TreeSetDemo03 {
public static void main(String[] args) {
	
	Set<Person01> allSet = new HashSet<Person01>();
	
	allSet.add(new Person01("張三",30));
	allSet.add(new Person01("李四",31));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("趙六",33));
	allSet.add(new Person01("孫七",33));
	
	System.out.println(allSet);
}

}

class Person01{
private String name;
private int age;

public Person01(String name,int age) {
	this.name = name;
	this.age = age;
}

public String toString() {
	return "姓名:" + this.name + ";年齡：" +this.age;
}

}
此時並沒去掉重複的元素，那麼重複的元素該如何取消呢？
如果取消重複的元素，則需要Object類中的兩個方法幫助。
*hashcode：表示一個唯一的編碼，一般通過計算表示。
*equal：進行物件的比較操作。

import java.util.HashSet;
import java.util.Set;

public class TreeSetDemo03 {
public static void main(String[] args) {
	
	Set<Person01> allSet = new HashSet<Person01>();
	
	allSet.add(new Person01("張三",30));
	allSet.add(new Person01("李四",31));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("王五",32));
	allSet.add(new Person01("趙六",33));
	allSet.add(new Person01("孫七",33));
	
	System.out.println(allSet);
}

}

class Person01{
private String name;
private int age;

public Person01(String name,int age) {
	this.name = name;
	this.age = age;
} 

public String toString() {
	return "姓名:" + this.name + ";年齡：" +this.age;
}

public boolean equals(Object obj) {
	if(this == obj) {
		return true;
	}
	if(!(obj instanceof Person01)) {
		return false;
	}
	Person01 p = (Person01)obj;
	if(this.name.equals(p.name) && this.age == p.age) {
		return true;
	}else {
		return false;
	}
}
public int hashCode() {
	return this.name.hashCode() * this.age;
}

}
執行結果：[姓名:趙六;年齡：33, 姓名:王五;年齡：32, 姓名:張三;年齡：30, 姓名:李四;年齡：31, 姓名:孫七;年齡：33]

1.5 SortedSet介面
掌握SortedSet介面與Set介面的關係
掌握SortedSet介面的常用操作方法

SortedSet介面定義
在這裡插入圖片描述

SortedSet介面中定義的方法
在這裡插入圖片描述

1.6、Iterator介面
*掌握集合輸出的標準操作
*掌握Iterator介面的主要作用以及使用注意事項

在集合的操作中支援一下集中方式：
*Iterator
*ListIterator
*foreach輸出
*Enumeration輸出
Iterator介面簡介
在這裡插入圖片描述
對於Iterator而言，因為其本身就是一個介面，所以想例項化必須依靠Collection介面完成。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class InteratorDemo01 {
public static void main(String[] args) {
	List<String> all = new ArrayList<String>();
	all.add("hello");
	all.add("_");
	all.add("world");
	
	Iterator<String> iter = all.iterator();  //為Interator介面例項化
	while(iter.hasNext()) {    //判斷是否有內容
		System.out.println(iter.next());	//輸出內容
	}
	
}

}
以上的操作程式碼屬於Iterator的標準做法。
在Iterator介面中提供了remove方法，此方式是刪除當前物件

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class InteratorDemo02 {
public static void main(String[] args) {
	List<String> all = new ArrayList<String>();
	all.add("hello");
	all.add("_");
	all.add("world");
	
	Iterator<String> iter = all.iterator();  //為Interator介面例項化
	while(iter.hasNext()) {		//判斷是否有內容
		String str = iter.next();
		if("_".equals(str)) {
			iter.remove();
		}else {
			System.out.println(str);	//輸出內容
		}
	}
	System.out.println("刪除之後的集合：" + all);
}

}
執行結果：
hello
world
刪除之後的集合：[hello, world]

在實際中Iterator是很少呼叫刪除操作的，因為其本身的功能就是輸出內容。當然，對於刪除內容有一下注意點：
*List本身有刪除操作
如果在使用迭代輸出的過程中使用了List中的remove執行刪除操作，則程式碼將出現問題。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class InteratorDemo03 {
public static void main(String[] args) {
	List<String> all = new ArrayList<String>();
	all.add("hello");
	all.add("_");
	all.add("world");
	
	Iterator<String> iter = all.iterator();  //為Interator介面例項化
	while(iter.hasNext()) {		//判斷是否有內容
		String str = iter.next();
		if("_".equals(str)) {
			all.remove(str);
		}else {
			System.out.println(str);	//輸出內容
		}
	}
	System.out.println("刪除之後的集合：" + all);
}

}
執行結果：
hello
刪除之後的集合：[hello, world]

在使用Iterator輸出時，不要使用集合類中的remove方法，只能使用Iterator介面中的remove方法

總結：
*Iterator介面的功能是從前向後輸出，屬於單項輸出
*Iterator的主要功能是完成迭代輸出操作的
*在使用Iterator的時候最好不要刪除資料

1.7、ListIterator介面
在這裡插入圖片描述

雖然此介面可以雙向輸出，但是Collection介面中並沒有定義為此例項化的操作，只有List介面中才存在了ListIterator介面的例項化

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorDemo01 {
public static void main(String[] args) {
	List<String> all = new ArrayList<String>();
	
	all.add("Hello");
	all.add("_");
	all.add("world");
	
	ListIterator<String> iter = all.listIterator();
	System.out.print("由前向後輸出：");
	while(iter.hasNext()) {
		String str = iter.next();
		System.out.print(str + "、");
	}
	System.out.println();
	System.out.print("由後向前輸出：");
	while(iter.hasPrevious()) {
		String str = iter.previous();
		System.out.print(str + "、");
	}
}

}
執行結果：
由前向後輸出：Hello、、world、
由後向前輸出：world、、Hello、

此時已經完成了雙向輸出，但是在使用此操作一定要注意一點：一定要先進行由前向後輸出，之後才能進行由後向前輸出。
使用ListIterator還可以進行增加和替換元素
*add()
*set()

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorDemo01 {
public static void main(String[] args) {
	List<String> all = new ArrayList<String>();
	
	all.add("Hello");
	all.add("_");
	all.add("world");
	
	ListIterator<String> iter = all.listIterator();
	System.out.print("由前向後輸出：");
	while(iter.hasNext()) {
		String str = iter.next();
		System.out.print(str + "、");
		iter.set("LI - " + str);
	}
	System.out.println();
	System.out.print("由後向前輸出：");
	iter.add("CZK");
	while(iter.hasPrevious()) {
		String str = iter.previous();
		System.out.print(str + "、");
	}
}

}
執行結果：
由前向後輸出：Hello、_、world、
由後向前輸出：CZK、LI - world、LI - _、LI - Hello、

總結：
1.如果想要使用ListIterator則只能依靠List介面完成
2.如果想要進行由後向前輸出，則只能先進性右前向後輸出
3.對於此介面中的增加及修改操作了解即可

1.7、foreach和Enumeration介面
掌握foteach對集合的輸出支援
掌握Enumeration介面以及使用要求

import java.util.ArrayList;
import java.util.List;

public class ForeachDemo01 {
public static void main(String[] args) {
List all = new ArrayList();

	all.add("hello");
	all.add("_");
	all.add("world");
	
	for(String str:all) {
		System.out.println(str);
	}
}

}
執行結果：
hello
_
world

實際上Iterator屬於一個新的輸出口，在最早java剛出來的時候想法要輸出的話，使用Enumeration介面完成輸出
但是在java中因為存在發展的歷史問題，所以有些地方好會使用Enumeration輸出。而且必須注意的是，在使用Enumeration輸出的時候一般都是直接操作Vector類完成的。

import java.util.Enumeration;
import java.util.Vector;

public class EnumerationDemo01 {
public static void main(String[] args) {
	Vector<String> all = new Vector<String>();
	
	all.add("hello");
	all.add("_");
	all.add("world");
	
	Enumeration<String> enu = all.elements();
	while(enu.hasMoreElements()) {   //判斷是否有內容
		System.out.println(enu.nextElement());
	}
}

}
執行結果：
hello
_
world

總結：
1.在所有的輸出操作中，以Iterator為最標準的輸出操作，這一點始終要記住
2.在部分舊的操作中Enumeration仍然存在

1.8、Map介面
在這裡插入圖片描述

Collection的操作中之前發現，每次儲存的物件都是一個物件，但是Map中儲存的是一對物件，物件的形式是以：key-value的形式儲存的
就好像電話本：張三->123456

Map介面
在這裡插入圖片描述

Map.Entry介面
在這裡插入圖片描述

Map.Entry介面的常用方法
在這裡插入圖片描述

Map與Map.Entry
在這裡插入圖片描述

Map介面的常用子類
在這裡插入圖片描述

以HashMap為例，說明Map的基本方法的操作：
import java.util.HashMap;
import java.util.Map;

public class HashMapDemo01 {
public static void main(String[] args) {
	Map<String,String> map = null;		//宣告Map物件，其中key和value的型別為String
	map = new HashMap<String,String>();
	
	map.put("mldn", "www.mldn.com");
	map.put("chenzikang", "dashazi");
	map.put("mldnjava", "www.mldnjava.com");
	
	String val = map.get("mldn");		//根據key取出值
	System.out.println("取出的內容是:" + val);
}

}
執行結果：取出的內容是:www.mldn.com

在Map中也可以使用containsXxx()方法判斷制定的key或者value存在

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo02 {
public static void main(String[] args) {
	Map<String,String> map = null;		//宣告Map物件，其中key和value的型別為String
	map = new HashMap<String,String>();
	
	map.put("mldn", "www.mldn.com");
	map.put("chenzikang", "dashazi");
	map.put("mldnjava", "www.mldnjava.com");
	
	if(map.containsKey("mldn")) {
		System.out.println("搜尋的key存在！");
	}else {
		System.out.println("搜尋的key不存在");
	}
	
	if(map.containsValue("www.mldn.com")) {
		System.out.println("搜尋的value存在！");
	}else {
		System.out.println("搜尋的value不存在");
	}
}

}
執行結果：
搜尋的key存在！
搜尋的value存在！

如果現在想輸出全部的key，則使用如下方法：
Set keySet()

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashMapDemo03 {
public static void main(String[] args) {
	Map<String,String> map = null;		//宣告Map物件，其中key和value的型別為String
	map = new HashMap<String,String>();
	
	map.put("mldn", "www.mldn.com");
	map.put("chenzikang", "dashazi");
	map.put("mldnjava", "www.mldnjava.com");
	 
	Set<String> keys = map.keySet();
	Iterator<String> iter = keys.iterator();
	while(iter.hasNext()) {
		String str = iter.next();
		System.out.println(str);
	}
}

}
執行結果：
mldn
chenzikang
mldnjava

既然可以輸出全部的key，那麼也可以輸出全部的value。
Collection values()

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMapDemo04 {
public static void main(String[] args) {
Map<String,String> map = null; //宣告Map物件，其中key和value的型別為String
map = new HashMap<String,String>();

	map.put("mldn", "www.mldn.com");
	map.put("chenzikang", "dashazi");
	map.put("mldnjava", "www.mldnjava.com");
	 
	Collection<String> values = map.values();
	Iterator<String> iter = values.iterator();
	while(iter.hasNext()) {
		String str = iter.next();
		System.out.println(str);
	}
}

}
執行結果：
www.mldn.com
dashazi
www.mldnjava.com

在Map中也存在一個Hashtable子類，實際上這個子類的退出時間與Vector是一樣的，都屬於舊類

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashtableDemo01 {
public static void main(String[] args) {
	Map<String,String> map = null;		//宣告Map物件，其中key和value的型別為String
	map = new HashMap<String,String>();
	
	map.put("mldn", "www.mldn.com");
	map.put("chenzikang", "dashazi");
	map.put("mldnjava", "www.mldnjava.com");
	
	Set<String> keys = map.keySet();
	Iterator<String> iter = keys.iterator();
	while(iter.hasNext()) {
		String str = iter.next();
		System.out.print(str + "、");
	}
	System.out.println();
	
	Collection<String> values = map.values();
	Iterator<String> iter01 = values.iterator();
	while(iter01.hasNext()) {
		String str = iter01.next();
		System.out.print(str + "、");
	}
}

}
執行結果：
mldn、chenzikang、mldnjava、
www.mldn.com、dashazi、www.mldnjava.com、

HashMap與Hashtable的區別
在這裡插入圖片描述

在Map中還存在一個TreeMap的子類，此類也屬於排序類，按key排序

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapDemo01 {
public static void main(String[] args) {
	Map<String,String> map = null;
	map = new TreeMap<String,String>();
	
	map.put("A、mldn", "www.mldn.com");
	map.put("C、chenzikang", "dashazi");
	map.put("B、liuyadan", "xiaolanzhu");
	
	Set<String> keys = map.keySet();
	Iterator<String> iter = keys.iterator();
	while(iter.hasNext()) {
		String str = iter.next();
		System.out.println(str + "-->" + map.get(str));
	}
	
}

}
執行結果：
A、mldn–>www.mldn.com
B、liuyadan–>xiaolanzhu
C、chenzikang–>dashazi

使用TreeMap可以方便的完成排序的操作，如果自定義的類想要作為key的話，則肯定實現Comparable介面，指定比較的規則。

弱引用類：WeakHashMap
在這裡插入圖片描述
如果假設一個Map中的某些內容長時間不適用的話，按照之前的方法是不會刪除的，如果希望可以自動刪除，可以使用弱引用類。當裡面 的某些內容不適用時，可以自動刪除

import java.util.Map;
import java.util.WeakHashMap;

public class WeakHashMapDemo01 {
public static void main(String[] args) {
Map<String,String> map = null;
map = new WeakHashMap<String,String>();

	map.put(new String("mldn"),new String("www.mldn.com"));
	map.put(new String("czk"),new String("dsz"));
	map.put(new String("lyd"),new String("xlz"));
	
	System.gc();		//強制進行垃圾的收集操作
	System.out.println(map);
}

}

總結：
1.介紹了Map的特點及其基本操作
2.Map與Map.Entry的關係
3.Map的子類：HashMap、Hashtable、TreeMap、WeakHashMap
4.主要功能就是根據key找到value

1.9、Map介面的使用的注意事項
掌握Map介面的輸出操作
掌握Map介面中key類的定義標準

Map介面輸出
在這裡插入圖片描述
但是在操作前必須說明：Map介面一般只作為查詢使用，輸出的操作畢竟屬於少數

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class IteratorDemo04 {
public static void main(String[] args) {
	Map<String,String> map = null;
	map = new HashMap<String,String>();
	
	map.put("mldn", "www.mldn.com");
	map.put("czk", "dashazi");
	map.put("lyd", "xiaolanzhu");
	
	Set<Map.Entry<String, String>> allset = null;
	allset = map.entrySet();
	
	Iterator<Map.Entry<String,String>> iter = null;
	iter = allset.iterator();
	
	while(iter.hasNext()) {
		Map.Entry<String, String> me = iter.next();
		System.out.println(me.getKey() + "-->" + me.getValue());
	}
}

}
執行結果：
czk–>dashazi
lyd–>xiaolanzhu
mldn–>www.mldn.com

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class ForeachDemo02 {
public static void main(String[] args) {
	Map<String,String> map = null;
	map = new HashMap<String,String>();
	
	map.put("mldn", "www.mldn.com");
	map.put("czk", "dashazi");
	map.put("lyd", "xiaolanzhu");
	
	for(Map.Entry<String, String> me:map.entrySet()) {
		System.out.println(me.getKey() + "-->" + me.getValue());
	}
}

}

這兩種輸出形式最終實際上還是以Collection的形式輸出，只是以Map.Entry作為內容的操作型別

注意事項二：

在這裡插入圖片描述

在Map中，可以使用任意的型別作為key和value，那麼使用非系統類可以

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo05 {
public static void main(String[] args) {
	Map<String,Person> map = null;
	map = new HashMap<String,Person>();
	map.put("czk", new Person ("陳子康",21));
	System.out.println(map.get("czk"));
}

}

class Person{
private String name;
private int age;
public Person(String name,int age) {
	this.name = name;
	this.age = age;
}

public String toString() {
	return "姓名:" + this.name + ";年齡:" + this.age;
}

}
執行結果：姓名:陳子康;年齡:21

如果現在以String為key是可以取出內容的

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo05 {
public static void main(String[] args) {
	Map<Person,String> map = null;
	map = new HashMap<Person,String>();
	map.put( new Person ("陳子康",21),"CZK");
	System.out.println(map.get( new Person ("陳子康",21)));
}

}

class Person{
private String name;
private int age;
public Person(String name,int age) {
	this.name = name;
	this.age = age;
}

public String toString() {
	return "姓名:" + this.name + ";年齡:" + this.age;
}

}
此時將自定義的型別為key，但是在取值的時候發現取不了，返回的結果是null。那麼為什麼之前的String可以但是自定義的類不存在呢？
實際上對於匹配的過程來講，有一個特點，即：物件要一樣才可以將內容查詢出來。

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo07 {
public static void main(String[] args) {
	Map<Person01,String> map = null;
	map = new HashMap<Person01,String>();
	Person01 per = new Person01("陳子康",21);
	map.put(per,"CZK");
	System.out.println(map.get(per));
}

}

class Person01{
private String name;
private int age;
public Person01(String name,int age) {
	this.name = name;
	this.age = age;
}

public String toString() {
	return "姓名:" + this.name + ";年齡:" + this.age;
}

}
這樣可以取出內容
可是這樣並不是解決問題的方法，因為不可能將Person的per物件帶著到處走，應該像String一樣，可以使用匿名物件的形式找到內容。那麼此時實際上就需要與Set介面中判斷重複元素的方式一樣，進行方法的覆寫。

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo07 {
public static void main(String[] args) {
	Map<Person02,String> map = null;
	map = new HashMap<Person02,String>();
	map.put(new Person02("陳子康",21),"CZK");
	System.out.println(map.get(new Person02("陳子康",21)));
}

}

class Person02{
private String name;
private int age;
public Person02(String name,int age) {
	this.name = name;
	this.age = age;
}

public String toString() {
	return "姓名:" + this.name + ";年齡:" + this.age;
}
public boolean equals(Object obj) {
	if(this == obj) {
		return true;
	}
	if(obj instanceof Person) {
		return false;
	}
	Person02 p = (Person02)obj;
	if(this.name.equals(p.name) && this.age == p.age) {
		return true;
	}else {
		return false;
	}
}
public int hashCodee.hashCode() * this.age;
}

}
執行結果：CZK

作為key，或者更準確的說是作為物件的時候，實際上是依靠hashCode()和equals()來判斷兩個匿名的物件是否相等，這一點由系統內部自動完成。

總結
1.Map可以使用迭代輸出
*map -> entrySet -> Set -> Iterator ->Map.Entry -> key和value
2.如果使用非系統類作為key，則一定保證覆寫equals和hashCode方法，否則無效

2.0、IdentityHashMap類
瞭解IdentityHashMap的作用

具體內容
在正常的Map操作中，key本身不能夠重複的

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
class Person11{
private String name;
private int age;

public Person11(String name,int age){
	this.name = name;
	this.age = age;
}

public boolean equals(Object obj) {
	if(this == obj) {
		return true;
	}
	if(!(obj instanceof Person11) ) {
		return false;
	}
	Person11 P = (Person11)obj;
	if(this.name.equals(P.name) && this.age == P.age) {
		return true;
	}else{
		return false;
	}
	
}

public int hashCode() {
	return this.name.hashCode() * this.age;
}

public String toString() {
	return "姓名：" + this.name + ";年齡：" + this.age;
}

}

public class IdentityHashMapDemo01 {
public static void main(String[] args) {
	Map<Person11,String> map= null;
	map = new HashMap<Person11,String>();
	map.put(new Person11("張三",30),"zhangsan01");
	map.put(new Person11("張三",30),"zhangsan02");
	map.put(new Person11("李四",31),"lisi");
	
	Set<Map.Entry<Person11,String>> allset = null;
	allset = map.entrySet();
	
	Iterator<Map.Entry<Person11,String>> iter = null;
	iter = allset.iterator();
	while(iter.hasNext()) {
		Map.Entry<Person11, String> me = iter.next();
		System.out.println(me.getKey() + "-->" + me.getValue());
	}
}

}
執行結果：
姓名：張三;年齡：30–>zhangsan02
姓名：李四;年齡：31–>lisi

使用HashMap操作的時候，key內容是不能重複的，如果現在希望key的內容可以重複，（指的重複是指兩個物件的地址不一樣key1 == key2）則要使用IdentityHashMap類。

import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
class Person11{
private String name;
private int age;

public Person11(String name,int age){
	this.name = name;
	this.age = age;
}

public boolean equals(Object obj) {
	if(this == obj) {
		return true;
	}
	if(!(obj instanceof Person11) ) {
		return false;
	}
	Person11 P = (Person11)obj;
	if(this.name.equals(P.name) && this.age == P.age) {
		return true;
	}else{
		return false;
	}
	
}

public int hashCode() {
	return this.name.hashCode() * this.age;
}

public String toString() {
	return "姓名：" + this.name + ";年齡：" + this.age;
}

}

public class IdentityHashMapDemo01 {
public static void main(String[] args) {
	Map<Person11,String> map= null;
	map = new IdentityHashMap<Person11,String>();
	map.put(new Person11("張三",30),"zhangsan01");
	map.put(new Person11("張三",30),"zhangsan02");
	map.put(new Person11("李四",31),"lisi");
	
	Set<Map.Entry<Person11,String>> allset = null;
	allset = map.entrySet();
	
	Iterator<Map.Entry<Person11,String>> iter = null;
	iter = allset.iterator();
	while(iter.hasNext()) {
		Map.Entry<Person11, String> me = iter.next();
		System.out.println(me.getKey() + "-->" + me.getValue());
	}
}

}
執行結果：
姓名：張三;年齡：30–>zhangsan01
姓名：張三;年齡：30–>zhangsan02
姓名：李四;年齡：31–>lisi

就算是兩個物件的內容相等，但是因為都使用了new關鍵字，所以地址肯定不相等，那麼就可以加入進去，key是可以重複的

總結
1.瞭解一下IdentityMap類的作用即可，在此類實際上是使用非常少的

2.1、SortedMap類
掌握SortedMap介面的作用

具體內容
回顧：SortedSet，是TreeSet的實現介面，那麼此介面是可以排序的。
SortedMap也是排序的操作，之前學習過TreeMap類，此類是可以排序的。

SortedMap介面擴充套件的方法
在這裡插入圖片描述

import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

public class SortedMapDemo01 {
public static void main(String[] args) {
SortedMap<String,String> map = null;
map = new TreeMap<String,String>();

	map.put("D、chenzikang", "http://www.baidu.com");
	map.put("A、mldn", "http://www.mldn.com");
	map.put("C、liuyadan","http://www.asdfghjlk.com" );
	map.put("B、lanzhu", "http://www.lanzhu.com");
	System.out.print("第一個元素的內容的key：" + map.firstKey() );
	System.out.println(":對應的值：" + map.get(map.firstKey()));
	
	System.out.print("最後元素的內容的key：" + map.lastKey() );
	System.out.println(":對應的值：" + map.get(map.lastKey()));
	
	System.out.println("返回小於指定範圍的集合：");
	for(Map.Entry<String,String> me : map.headMap("B、lanzhu").entrySet()) {
		System.out.println("\t |-" + me.getKey() +"-->" + me.getValue());
	}
	
	System.out.println("返回大於指定範圍的集合：");
	for(Map.Entry<String,String> me : map.tailMap("B、lanzhu").entrySet()) {
		System.out.println("\t |-" + me.getKey() +"-->" + me.getValue());
	}
	
	System.out.println("部分集合：");
	for(Map.Entry<String, String> me: map.subMap("A、mldn","C、liuyadan").entrySet()) {
		System.out.println("\t|-" + me.getKey() + "-->" + me.getValue());
	}
}

}
執行結果：
第一個元素的內容的key：A、mldn:對應的值：http://www.mldn.com
最後元素的內容的key：D、chenzikang:對應的值：http://www.baidu.com
返回小於指定範圍的集合：
|-A、mldn–>http://www.mldn.com
返回大於指定範圍的集合：
|-B、lanzhu–>http://www.lanzhu.com
|-C、liuyadan–>http://www.asdfghjlk.com
|-D、chenzikang–>http://www.baidu.com
部分集合：
|-A、mldn–>http://www.mldn.com
|-B、lanzhu–>http://www.lanzhu.com

總結：
1.認識Map介面的子介面，SortedMap介面的基本概念。
2.此介面還有很多的操作方法
3.在實際中還是以Map介面為操作的標準。

2.2、Collection.wmv
掌握Collection與Collection介面的區別
掌握Collections類中提供的主要方法

具體內容：
在面試題中可能會有這樣一個問題，請回答，Collection和Collections的關係
Collections與Collection沒有直接的關係，但是與集合中的各個介面都有操作的方法支援。

Collections類的常用方法以及常量
在這裡插入圖片描述

驗證：空集合的操作
*public static final List emptyList()
*public static final ListemptySet()

public class CollectionsDemo {
public static void main(String[] args) {
	List<String> alllist = Collections.emptyList();
	Set<String> allset = Collections.emptySet();
	
	alllist.add("Hello");
}

}
執行結果：Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.AbstractList.add(Unknown Source)
at java.util.AbstractList.add(Unknown Source)
at collectionsdemo.CollectionsDemo.main(CollectionsDemo.java:12)
如果想要為集合中增加內容，則肯定使用add方法，在Collections中也提供了專門的增加操作。
public static boolean allAll(Collections<?super T>)
使用了可變引數，所以，可以任意輸入各種型別的資料。

public class CollectionsDemo01 {
public static void main(String[] args) {
List alllist = new ArrayList();
Collections.addAll(alllist, “MLDN”,“CZK”,“MLDNJAVA”);
Iterator iter = alllist.iterator();

	while(iter.hasNext()) {
		System.out.print(iter.next() + "、");
	}
}

}
執行結果：
MLDN、CZK、MLDNJAVA、

相關推薦

Java類集總結之二

iter return lib 標準 value next() private 叠代 方法 1）Map接口 關系：Map（接口） HashMap（非抽象子類）、TreeMap（非抽象子類） 在開發中，Map集合的內容多用來查詢，全部輸出的操作較少；而Collection接口

Java類集 1 List， Set基本使用

.com list span iterator next() oracle開發 java pri jsp開發 首先看下繼承結構： ArrayList（常用）： 1 /** 2 * List接口繼承Collection接口 3

java類集

在java中必須掌握的知識點，會開發的： 1.面向物件 2.java的類集 3.java IO 4.JDBC 本章目標： *掌握java設定類集框架的目的 *掌握類集中的各個主要的介面 *掌握Collection介面的作用 類集的作用 類集實際上就是一個動態的物件陣列，與一般的物件陣

java類集——Interator

在集合的操作中支援一下幾種方式： 1.Interator 2.ListIterator 3.foreach 4.Enumeration Interator介面簡介 集合輸出的標準操作： 在使用集合輸出的時候必須形成以下的一個思路：只要是碰到了集合輸出的操作，就一定使用Interator介面，

JAVA類集框架筆記（二）

三、集合的輸出     在類集中提供了以下4種常見的輸出方式 ：          （1）Iterator : 迭代輸出，是使用最多的輸出方式          （2）

JAVA類集框架筆記（一）

一、基本概念 ：         1、所謂類集就是一個動態的物件陣列，是對一些實現好的資料結構和演算法進行包裝，方便使用。而且類集框架本身不受物件陣列的長度限制。         2、為了實現類集容易擴充套件和修

Java類集框架（六）：Stack及Properties子類、Collections工具類

Stack子類 在java.util包內可以利用stack類實現棧的功能。此類定義如下： public class Stack<E> extends Vector<E> Stack類常用方法： 方法 型別

Java類集框架（五）：偶物件儲存：Map介面

Map集合可以儲存一對關聯資料（按照“key = value”的形式）。 Map介面的常用方法 方法 型別 描述 public V put(K key, V value) 普通

Java類集框架（四）：集合輸出

集合輸出的4種形式：Iterator輸出、ListIterator輸出、foreach（加強型for迴圈）輸出、Enumeration輸出。 迭代輸出：Iterator Iterator（迭代器）是集合輸出操作的一個介面，Collection介面中提供了直接為Iterator介面例項

Java類集框架（三）：Set子介面

Set子介面只是簡單地繼承了Collection介面，並沒有擴充其他的方法。Set集合中不允許儲存重複的資料。在Set介面下有兩個常用的子類：HashSet、TreeSet。HashSet是雜湊存放資料，而TreeSet是有序存放的子類，預設按照字母的升序排列。在實際開發中如果沒有排序要求，

Java類集框架（二）：List子介面

List子介面最大的功能是裡面儲存的資料可以存在重複的內容。List介面在對Collection介面擴充的方法如下： - public E get(int index)：普通，取得索引編號的內容 - public E set(int index, E element)：普通，修改指定索引

Java類集框架（一）：簡介及Collection介面

簡介 在實際專案中，涉及到儲存多個物件的操作往往會用到陣列。然而傳統的陣列存在一個問題：長度是固定的。Java 2提供了一個專門實現資料結構的開發框架——類集框架，框架的程式介面和類都儲存在java.util包中，其最為核心的用處就在於實現了動態物件陣列的操作，定義了大量的操作標準，核心

JAVA 類集一對多多對多的例項

package petshop; import java.util.Iterator; import java.util.Set; import java.util.List; import java.util.ArrayList; class Stude

Java基礎（五十九）-集合工具類（Java類集框架）

1:Stack棧 棧是一種先進後出的資料結構。例如：在文字編輯器上都有撤銷功能，那麼每次使用的時候，最後一次的編輯操作永遠是最先撤銷的，那麼這個功能就是利用棧來實現的，棧的基本操作形式如下。 案例：實現棧的操作 import java.util.Stack;

Java基礎（六十）-Stream資料流（Java類集框架）

Stream資料流 從JDK1.8開始，由於已經進入到了大資料的時代，所以在類集裡面也支援有資料的流式分析處理操作，為我們專門提供了一個Stream的介面，同時在Collection接口裡面也提供有為此介面例項化的方法。 import java.util.

Java類集 _範例講解：多對多關係

例項要求 一個學生可以選多門課程， 門課程可以有多個學生參加，那麼這就是一個典型的多對多關係。 要完成本程式，首先應該定義兩個類：學生資訊類Student、課程資訊類Course，在一個學生類中存在一個集合，儲存全部的課程，而在課程類中也要存在一個集合，儲存全部的學生。 例

Java基礎複習筆記--Iterator和ListIterator 迭代器的使用（遍歷集合） Java類集框架——Iterator和ListIterator 迭代器的使用（遍歷集合）

Java類集框架——Iterator和ListIterator 迭代器的使用（遍歷集合） 學習目標： 掌握集合輸出的標準操作。 掌握Iterator介面的主要作用及使用注意事項。 掌握ListIterator與Iterator介面的關係及區別。

Java類集框架——Iterator和ListIterator 迭代器的使用（遍歷集合）

學習目標： 掌握集合輸出的標準操作。 掌握Iterator介面的主要作用及使用注意事項。 掌握ListIterator與Iterator介面的關係及區別。 掌握ListIterator介面的使用限制。

JAVA 類集框架

</pre>什麼是類集框架<p></p><p><img src="https://img-blog.csdn.net/20150316092953342?watermark/2/text/aHR0cDovL2Jsb2c

Java類集框架

類集框架圖解： 前言： 資料結構對程式設計有著深遠的影響，在面向過程的c語言中，資料庫結構用struct來描述，而在面向物件的程式設計中，資料結構是用類來描述的，並且包含對該資料結構操作的方法。 在Java語言中，Java語言的設計者對常用的資料結構和