JavaSE 軟件工程師
認證考試試卷
筆試
考試時間150分鍾
總分 100分
姓 名_______________________
身份證號_______________________
准考證號_______________________
考試結束后考卷必須收回，否則考試成績無效
尚學堂JavaSE軟件工程師認證考試試卷
一、 填空題（共20個題目，總計20分）
- Java虛擬機就是一個虛擬的用於執行 字節碼文件 的計算機。它是Java最核心的技術，是Java跨平台的基礎。
- 使用Java開發應用程序包括編寫源程序，編譯源程序，解釋並運行三個步驟，其中編譯和解釋分別需要使用javac.exe和 java.exe 實現。
- 一個十進制整數轉換成八進制數后是1234，則它轉為十六進制數后是 29C 。
- Java中浮點數據類型包括float和double兩種類型，其中float類型又被稱作單精度類型，尾數可以精確到7位有效數字，在內存中占用 4 個字節。
- 使用Math.random( )返回帶正號的 double值，該值大於等於0.0且小於1.0。使用該函數生成[30,60]之間的隨機整數的語句是:(int)(Math.random( )*31)+30。
- for循環的語法格式是for (表達式1;表達式2;表達式3) {循環體}，其中在整個循環過程中只執行一次的部分是 表達式1 。
- Java中 構造方法 方法與類名相同，沒有返回值，在創建對象實例時由new運算符自動調用。
- Package 語句作為Java源文件的第一條語句，指明該源文件定義的類所在的包。
- 局部變量的名字與成員變量的名字相同，若想在該方法內使用成員變量，必須使用關鍵字 this 。
- Java異常處理中，如果一個方法中出現了多個Checked異常，可以在方法聲明中使用關鍵字 throws 聲明拋出，各異常類型之間使用逗號分隔。
- 聲明數組僅僅是給出了數組名字和元素的數據類型，要想真正地使用數組還必須為它 分配內存空間 。
- Arrays類的binarySearch( ) 方法使用二分搜索法來搜索指定的數組，以獲得指定的值。必須在進行此調用之前對數組進行 排序 ，否則否則結果是不確定的。
- Object類有一個public方法是 toString() ，一個對象通過調用該方法可以獲得該對象的字符串表示。
- StringBuilder類是StringBuffer類的替代類，兩者的共同點是都是可變長度字符串，其中線程安全的類是 StringBuffer 。
- Java集合框架提供了一套性能優良、使用方便的接口和類，包括Collection和Map兩大類，它們都位於 java.util包中
- Treeset 是一種Collection類型的集合類，其中元素唯一，並采用二叉樹作為存儲結構，元素按照自然順序排列。
- Java IO流可以分為節點流和處理流兩大類，其中前者處於IO操作的第一線，所有操作必須通過他們進行。
- 處於新建狀態的線程被啟動后，將進入線程隊列排隊等待CPU服務，此時它已經具備了運行條件，一旦輪到享用CPU資源時，就可以脫離創建它的主線程獨立開始自己的生命周期。上述線程是處於 就緒 狀態。
- 在線程通信中，調用 wait() 方法可以是當前線程處於等待狀態，而為了喚醒一個等待的線程，需要調用的方法是notify( )。
- 在Socket編程中，IP地址用來標志一台計算機，但是一台計算機上可能提供多種應用程序，使用 端口號 來區分這些應用程序。
二、 選擇題（共25個題目，總計25分）
| 1) |
有一段Java 程序，其中public類名是A1，那么保存它的源文件名可以是（ A ）。（選擇一項） |
|
|
|
|
|
|
|
A |
A1.java |
|
|
B. |
A1.class |
|
|
C. |
A1 |
|
|
D. |
都不對 |
| 2) |
在Java中，byte數據類型的取值范圍是（ A ）。（選擇一項） |
|
|
|
|
|
|
|
A |
-128 ~ 127 |
|
|
B. |
-228 ~128 |
|
|
C. |
-255 ~ 256 |
|
|
D. |
-255 ~ 255 |
| 3) |
有以下方法的定義，請選擇該方法的返回類型（ D ）。（選擇一項） |
|
|
|
method(byte x, double y) { return (short)x/y*2; } |
|
|
|
|
|
|
|
A |
byte |
|
|
B. |
short |
|
|
C. |
int |
|
|
D. |
double |
| 4) |
以下選項中添加到代碼中橫線處會出現錯誤的是（ BD ）。（選擇二項） |
|
|
|
public class Test { public float aMethod(float a, float b) { return 0; }
} |
|
|
|
|
|
|
|
A |
public float aMethod(float a, float b, float c) { return 0; } |
|
|
B. |
public float aMethod(float c, float d) { return 0; } |
|
|
C. |
public int aMethod(int a, int b) { return 0; } |
|
|
D. |
private int aMethod(float a, float b) { return 0; } |
| 5) |
閱讀下列文件定入的Java代碼，其執行結果是（ D ）。（選擇一項） |
|
|
|
public class Test { public static void main(String[] args) { char ch = 'c'; switch (ch) { case 'a': System.out.print("a"); break; case 'b': System.out.print("ab"); case 'c': System.out.print("c"); default: System.out.print("d"); } } } |
|
|
|
|
|
|
|
A |
a |
|
|
B. |
b |
|
|
C. |
c |
|
|
D. |
cd |
| 6) |
下面程序執行的結果是在屏幕上打印（ B ）次Java基礎班。（選擇一項） |
|
|
|
for(int i=1;i<=10;i++){ if (i<5) continue; System.out.println("Java基礎班"); } |
|
|
|
|
|
|
|
A |
5 |
|
|
B. |
6 |
|
|
C. |
7 |
|
|
D. |
8 |
| 7) |
以下四個選項中和下面代碼功能相同的是（ B ）。（選擇一項） |
|
|
|
int i = 1; int sum = 0; while (i <= 100) { if (i % 2 == 0) sum = sum + i; i++; } |
|
|
|
|
|
|
|
A |
for (int x =1; x<=100;x++){ sum=sum+x;} |
|
|
B. |
for (int x =0; x<=100;x+=2){ sum=sum+x;} |
|
|
C. |
for (int x =1; x<=100;x+=2){ sum=sum+x;} |
|
|
D. |
上述全對 |
| 8) |
以下代碼中錯誤的語句是（ D ）。（選擇一項） |
|
|
|
public class Something{ public static void main(String[] args){ final Other o=new Other(); new Something().addOne(o);//1 } public void addOne( Other o){ o.i++;//2 o = new Other();//3 } } class Other{ public int i; } |
|
|
|
|
|
|
|
A |
1 |
|
|
B. |
2 |
|
|
C. |
3 |
|
|
D. |
沒有錯誤 |
| 9) |
在Java中，以下程序編譯運行后的輸出結果為（ D ）。（選擇一項） |
|
|
|
public class Test { int x, y; Test(int x, int y) { this.x = x; this.y = y; } public static void main(String[] args) { Test pt1, pt2; pt1 = new Test(3, 3); pt2 = new Test(4, 4); System.out.print(pt1.x + pt2.x); } } |
|
|
|
|
|
|
|
A |
6 |
|
|
B. |
34 |
|
|
C. |
8 |
|
|
D. |
7 |
| 10) |
下列選項中關於Java中類方法的說法錯誤的是（ A C ）。（選擇二項） |
|
|
|
|
|
|
|
A |
在類方法+中可用this來調用本類的類方法 |
|
|
B. |
在類方法中調用本類的類方法時可直接調用 |
|
|
C. |
在類方法中只能調用本類中的類方法 |
|
|
D. |
在類方法中調用實例方法需要先創建對象 |
| 11) |
下列選項中關於Java中super關鍵字的說法正確的是（ AD ）。（選擇一項） |
|
|
|
|
|
|
|
A |
super關鍵字是在子類對象內部指代其父類對象的引用 |
|
|
B. |
super關鍵字不僅可以指代子類的直接父類，還可以指代父類的父類 |
|
|
C. |
子類通過super關鍵字只能調用父類的方法，而不能調用父類的屬性 |
|
|
D. |
子類通過super關鍵字可以調用父類的構造方法 |
| 12) |
編譯運行如下Java代碼，輸出結果是（ D ）。（選擇一項） |
|
|
|
class Base { public void method(){ System.out.print ("Base method"); } } class Child extends Base{ public void methodB(){ System.out.print ("Child methodB"); } } class Sample { public static void main(String[] args) { Base base= new Child(); base.methodB(); } } |
|
|
|
|
|
|
|
A |
Base method |
|
|
B. |
Child methodB |
|
|
C. |
Base method Child methodB |
|
|
D. |
編譯錯誤 |
| 13) |
在Java中，關於引用數據類型的類型轉換說法正確的是（AB ）。（選擇二項） |
|
|
|
|
|
|
|
A |
引用數據類型的類型轉換有向上轉型和向下轉型 |
|
|
B. |
向下轉型，必須轉換成其真實子類型，而不能隨意轉換 |
|
|
C. |
向下轉型是自動進行的，也稱隱式轉換 |
|
|
D. |
向上轉型可以使用instanceof操作符來判斷轉型的合法性 |
| 14) |
在Java接口中，下列選項中屬於有效的方法聲明是（ AC ）。（選擇二項） |
|
|
|
|
|
|
|
A |
public void aMethod( ); |
|
|
B. |
final void aMethod( ); |
|
|
C. |
void aMethod(){ } |
|
|
D. |
private void aMethod( ); |
| 15) |
以下選項中關於匿名內部類的說法正確的是（ BD ）。（選擇二項） |
||
|
|
|
|
|
|
|
A. |
匿名內部類可以實現多個接口，或者繼承一個父類 |
|
|
|
B. |
匿名內部類不能是抽象類，必須實現它的抽象父類或者接口里包含的所有抽象方法 |
|
|
|
C. |
匿名內部類沒有類名，所以匿名內部類不等定義構造方法 |
|
|
|
D. |
匿名內部類可以直接訪問外部類的所有局部變量 |
|
| 16) |
閱讀如下Java代碼，在控制台輸入"-1",執行結果是（B）。（選擇一項） |
||
|
|
public class Demo { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("請輸入數字："); try { int num = input.nextInt(); if (num < 1 || num > 4) { throw new Exception("必須在1-4之間！"); } } catch (InputMismatchException e) { System.out.println("InputMismatchException"); } catch (Exception e) { System.out.println(e.getMessage()); } } } |
||
|
|
|
|
|
|
|
A |
輸出：InputMismatchException |
|
|
|
B. |
輸出：必須在1-4之間！ |
|
|
|
C. |
什么也沒輸出 |
|
|
|
D. |
編譯錯誤 |
|
| 17) |
關於Integer類中的靜態方法parseInt()方法說法正確的是（ BD ）。（選擇二項） |
|
|
|
|
|
|
|
A |
將小數轉換成整數 |
|
|
B. |
將數字格式的字符串轉成整數 |
|
|
C. |
使用parseInt()方法可能拋出異常 |
|
|
D. |
將單個字符轉成整數 |
| 18) |
以下程序片段中可以正常編譯的是（ C ）。（選擇一項） |
||
|
|
|
|
|
|
|
A |
String s = "Gone with the wind"; String k = s+t; String t = "good"; |
|
|
|
B. |
String s = "Gone with the wind"; String t; t = s[3]+"one"; |
|
|
|
C. |
String s = "Gone with the wind"; String stanfard = s.toUpperCase(); |
|
|
|
D. |
String s = "home directory"; String t = s – "directory"; |
|
| 19) |
以下代碼的執行結果是（ C ）。（選擇一項） |
||
|
|
Set<String> s=new HashSet<String>(); s.add("abc"); s.add("abc"); s.add("abcd"); s.add("ABC"); System.out.println(s.size()); |
||
|
|
|
|
|
|
|
A. |
1 |
|
|
|
B. |
2 |
|
|
|
C. |
3 |
|
|
|
D. |
4 |
|
| 20) |
File類中的isDirectory( )方法的作用是（ BD ）。（選擇二項） |
|
|
|
|
|
|
|
A. |
判斷File對象封裝的是否是文件 |
|
|
B. |
判斷File對象封裝的是否是目錄 |
|
|
C. |
判斷File對象中封裝的是否是根目錄 |
|
|
D. |
返回值類型是boolean |
| 21) |
閱讀下列文件定入的JAVA代碼，共有（ C ）處錯誤。（選擇一項） |
|
|
|
import java.io.*; public class TestIO { public static void main(String []args){ String str ="文件寫入練習"; FileWriter fw = null; //1 try{ fw = new FileWriter("c:\mytext.txt"); //2 fw.writerToEnd(str); //3 }catch(IOException e){ //4 e.printStackTrace(); }finally{ //此處省略關閉流 } } } |
|
|
|
|
|
|
|
A |
0 |
|
|
B. |
1 |
|
|
C. |
2 |
|
|
D. |
3 |
| 22) |
以下選項中關於Java中線程控制方法的說法正確的是（ AD ）。（選擇二項） |
|
|
|
|
|
|
|
A. |
join ( ) 的作用是阻塞指定線程等到另一個線程完成以后再繼續執行 |
|
|
B. |
sleep ( ) 的作用是讓當前正在執行線程暫停，線程將轉入就緒狀態 |
|
|
C. |
yield ( ) 的作用是使線程停止運行一段時間，將處於阻塞狀態 |
|
|
D. |
setDaemon( )的作用是將指定的線程設置成后台線程 |
| 23) |
Java中線程安全問題是通過關鍵字（ C ）解決的?。（選擇一項） |
|
|
|
|
|
|
|
A. |
finally |
|
|
B. |
wait( ) |
|
|
C. |
synchronized |
|
|
D. |
notify( ) |
| 24) |
ServerSocket的監聽方法accept( )方法的返回值類型是（ A ）。（選擇一項） |
|
|
|
|
|
|
|
A. |
Socket |
|
|
B. |
void |
|
|
C. |
Object |
|
|
D. |
DatagramSocket |
| 25) |
以下選項中關於Java中獲取Class對象的方式正確的是（ C D ）。（選擇二項） |
|
|
|
|
|
|
|
A. |
Class c1 = String.getClass( ); |
|
|
B. |
String str = new String(“bjsxt”); Class clazz = str.class; |
|
|
C. |
Class c1 = Integer.TYPE; |
|
|
D. |
Class clazz = Class.forName("java.lang.Object"); |
三、 判斷題（共20個題目，總計10分，正確√，錯誤×）
- 和C++相比，Java取消了指針，不再有多重繼承，不需要手動回收垃圾。（ T）
- Java具有一次編譯，到處運行的特點，其含義是Java的源代碼可以一次性編譯成計算機的機器碼，並在不同的平台上運行。（ F ）
- char 數據類型用來表示在ASCII編碼表中的一個字符，在內存中占用1個字節空間，所以不能表示一個漢字。（ F ）
- 賦值和條件運算符是運算級別最低的兩種運算符，兩者都具有自右向左的結合性。（ T ）
- 多重循環是指一個循環體內又包含另一個完整的循環結構。外層循環變量變化一次，內層循環變量要從頭到尾變化一遍。（ T ）
- 任何可用遞歸解決的問題也能使用循環解決，遞歸既花時間又耗內存，在要求高性能的情況下盡量避免使用遞歸。（ T ）
- 訪問權限是private的變量，只能在本類和與本類同一個包中的其他類使用。（ F ）
- 對於子類創建的一個對象，如果子類繼承了父類的方法，未重寫，則運行時調用子類的方法。（ F ）
- ArithmeticException，ArrayIndexOutOfBoundsException，NullPointerException是運行時異常，而ClassNotFoundException，ClassCastException是Checked異常。（F ）
- 數組的長度是確定的，數組一旦被創建，它的大小就是不可以改變的。但是其元素類型可以是不同類型，允許出現混合類型。（ F ）
- 創建數組后，系統會給每個數組元素一個默認值，如double型元素的默認值是0.0。（ T ）
- JK1.5后提供了自動裝箱和自動拆箱功能，從而可以實現基本數據類型和對應包裝類之間的自動轉換，簡化了操作。（ T ）
- java.sql.Date類和java.util.Date類的關系是前者是后者的父類，其中前者沒有提供無參數構造方法，而后者可以提供無參數構造方法來獲取當前時間。（ F ）
- Collection是Java集合頂級接口，其中的元素無序，唯一。Java平台不提供這個接口任何直接的實現。（ T ）
- Iterator接口可以遍歷任何Collection接口的實現類，可以從一個Collection中使用iterator( )方法來獲取迭代器實例。迭代器取代了Java集合框架中的Enumeration。（T ）
- 序列化是指將字節序列轉換成Java對象，只有實現了Serializable接口的類的對象才可以被序列化。（F ）
- 一個進程可以包括多個線程。兩者的一個主要區別是：線程是資源分配的單位，而進程CPU調度和執行的單位。（ F ）
- 用new關鍵字建立一個線程對象后，該線程對象就處於新生狀態。處於新生狀態的線程有自己的內存空間，通過調用start進入就緒狀態。（ T ）
- TCP協議是一種面向無連接的、可靠的、基於字節流的傳輸層通信協議，該協議占用系統資源多、效率較低。（ F ）
- Java反射技術中，對於一個private修飾的成員變量，可以再設置setAccessible(true)后進行暴力訪問。（ T ）
四、 簡答題（共5個題目，總計25分）
- 面向過程和面向對象的區別。（5分）
- 編程思路不同： 面向過程以實現功能的函數開發為主，而面向對象要首先抽象出類、屬性及其方法，然后通過實例化類、執行方法來完成功能。（1分）
- 封裝性：都具有封裝性，但是面向過程是封裝的是功能，而面向對象封裝的是數據和功能。（1分）
- 面向對象具有繼承性和多態性，而面向過程沒有繼承性和多態性，所以面向對象優勢是明顯。（1分）
- 面向對象耦合性低，更利於修改維護。（蓋澆飯/蛋炒飯）。（1分）
- 面向過程更適合解決簡單問題。面向對象更適合解決復雜問題。（1分）
- Error和Exception的區別。（5分）
- Error類，表示僅靠程序本身無法恢復的嚴重錯誤，比如說內存溢出、動態鏈接異常、虛擬機錯誤。（1分）應用程序不應該拋出這種類型的對象。假如出現這種錯誤，除了盡力使程序安全退出外，在其他方面是無能為力的。（1分）
- Exception類，由Java應用程序拋出和處理的非嚴重錯誤，比如所需文件沒有找到、零作除數，數組下標越界等。（1分）它的各種不同子類分別對應不同類型異常。可分為兩類：Checked異常和Runtime異常。（1分）所以在進行程序設計時，應該更關注Exception類。（1分）
- 列舉常用的字節輸入流和輸出流並說明其特點，至少5對。（5分）
- FileInputStream和FileOutputStream 節點流 以文件為數據源和目的地（1分）
- BufferedInputStream和BufferedOutputStream 處理流 提供了緩沖功能，提高讀寫效率（1分）
- DataInputStream和DataOutputStream 處理流 提供了方便讀寫基本數據類型和String數據的方法（1分）
- ObjectInputStream和ObjectOutputStream 處理流 不僅提供了方便讀寫基本數據類型和String數據的方法，也提供了讀寫引用類型數據的方法（1分）
- ByteArrayInputStream和ByteArrayOutputStream 節點流 以字節數組為數據源和目的地（1分）
- 創建線程的兩種方式分別是什么？各有什么優缺點。（5分）
- 方式1：繼承java.lang.Thread類，並覆蓋run() 方法。（1分）
優勢：編寫簡單；（0.5分）
劣勢：無法繼承其它父類（0.5分）
-
- 方式2：實現java.lang.Runnable接口，並實現run()方法。（1分）
優勢：可繼承其它類，多線程可共享同一個Thread對象；（1分）
劣勢：編程方式稍微復雜，如需訪問當前線程，需調用Thread.currentThread()方法（1分）
- 簡述基於UDP的Socket編程的主要步驟。
提示：分別說明服務器端和客戶端的編程步驟。（5分）
服務器端（server）：
1) 構造DatagramSocket實例。（0.5分）
2) 創建數據包DatagramPacket，存取發送和接收的數據、IP和端口。（0.5分）
3) 通過DatagramSocket實例的receive方法接收客戶端數據。（0.5分）
4) 通過DatagramSocket的send方法向客戶端發出反饋信息。（0.5分）
5) 關閉DatagramSocket。（0.5分）
客戶端（client）：
1) 構造DatagramSocket實例。（0.5分）
2) 創建數據包DatagramPacket，存取發送和接收的數據、IP和端口。（0.5分）
3) 通過DatagramSocket實例的receive方法接收客戶端數據。（0.5分）
4) 通過DatagramSocket的send方法向客戶端發出反饋信息. （0.5分）
關閉DatagramSocket。（0.5
1 五、 編碼題（共3個題目，總計20分） 2 1. 給20塊錢買可樂，每瓶可樂3塊錢，喝完之后退瓶子可以換回1塊錢，問最多可以喝到多少瓶可樂。（5分） 3 public static void main(String[] args) { 4 int a = 20;//當前的錢數 5 int price = 3;//可樂單價 6 int sum = 0;//喝可樂數量 7 int cola = 0;//可樂瓶子換的錢 8 int s = 0;//剩下的錢 9 while(a>price){ 10 cola = a/price;//可樂瓶子數量 11 sum+=cola;//喝可樂數量 12 s=a%price;//剩下的錢 13 a =cola+s;//當前的錢=瓶子換的錢+剩下的錢 14 } 15 System.out.println("最多可以喝到:"+sum+"瓶可樂"); 16 } 17 2. 寫一個方法對任意數據類型數組進行排序。（6分）具體要求如下: 18 1) 方法聲明為public void sortArr(Object arr[]){ } 19 2) 方法中首先輸出排序前數組內容，然后進行排序，最后輸出排序后數組內容。 20 3) 可以是冒泡排序或其他算法實現，不直接調用Java提供的方法實現排序。 21 關鍵點：如何實現不同數據類型數組元素的大小比較 22 23 public class Array_2 { 24 public void sortArr(int arr[]){ 25 int temp = 0; 26 for(int i=0;i<arr.length;i++) { 27 for(int j=i+1;j<arr.length;j++) { 28 if(arr[i]>arr[j]){ 29 temp = arr[i]; 30 arr[i] = arr[j]; 31 arr[j] = temp; 32 } 33 } 34 } 35 System.out.println(Arrays.toString(arr)); 36 } 37 public static void main(String[] args) { 38 int[] arr ={10,25,110,-20,18,-36,65,14,3}; 39 Array_2 a =new Array_2(); 40 a.sortArr(arr); 41 } 42 43 } 44 45 46 3. 實現List和Map數據的轉換。（9分）具體要求如下： 47 功能1：定義方法public void listToMap( ){ }將List中Student元素封裝到Map中 48 1) 使用構造方法Student(int id,String name,int age,String sex )創建多個學生信息並加入List 49 2) 遍歷List，輸出每個Student信息 50 3) 將List中數據放入Map，使用Student的id屬性作為key，使用Student對象信息作為value 51 4) 遍歷Map，輸出每個Entry的key和value 52 功能2：定義方法public void mapToList( ){ }將Map中Student映射信息封裝到List 53 1) 創建實體類StudentEntry，可以存儲Map中每個Entry的信息 54 2) 使用構造方法Student(int id,String name,int age,String sex )創建多個學生信息，並使用Student的id屬性作為key，存入Map 55 3) 創建List對象，每個元素類型是StudentEntry 56 4) 將Map中每個Entry信息放入List對象 57 58 public class Student_3 { 59 /** 60 * 使用構造方法Student(int id,String name,int age,String sex ) 61 */ 62 private int id; 63 private String name; 64 private int age; 65 private String sex; 66 67 public Student_3() { 68 } 69 70 public Student_3(int id, String name, int age, String sex) { 71 this.id = id; 72 this.name = name; 73 this.age = age; 74 this.sex = sex; 75 } 76 77 public int getId() { 78 return id; 79 } 80 81 public String getName() { 82 return name; 83 } 84 85 public int getAge() { 86 return age; 87 } 88 89 public String getSex() { 90 return sex; 91 } 92 93 public void setId(int id) { 94 this.id = id; 95 } 96 97 public void setName(String name) { 98 this.name = name; 99 } 100 101 public void setAge(int age) { 102 this.age = age; 103 } 104 105 public void setSex(String sex) { 106 this.sex = sex; 107 } 108 109 @Override 110 public String toString() { 111 return "["+id +" "+ name +" "+ age +" "+ sex+"]"; 112 } 113 } 114 import java.util.ArrayList; 115 import java.util.HashMap; 116 import java.util.Iterator; 117 import java.util.List; 118 import java.util.Map; 119 import java.util.Map.Entry; 120 import java.util.Set; 121 122 123 public class Test_3 { 124 //List集合轉Map集合 125 public void listToMap(Student_3 s1,Student_3 s2 ){ 126 //1.創建List集合 127 List<Student_3> list = new ArrayList<>(); 128 //2.創建Map集合 129 Map<Integer, Student_3> map = new HashMap<>(); 130 //3.傳入學生對象 131 list.add(s1); 132 list.add(s2); 133 Iterator<Student_3> it = list.iterator(); 134 //4.遍歷List集合 135 while(it.hasNext()){ 136 Student_3 stu = it.next(); 137 //5.將學生id作為Map集合的Key,學生對象作為Map集合的Vaul 138 map.put(stu.getId(), stu); 139 } 140 //6.遍歷Map集合 141 Set<Entry<Integer, Student_3>> entrySet = map.entrySet(); 142 for (Entry<Integer, Student_3> en : entrySet) { 143 System.out.println(en); 144 } 145 146 } 147 148 //Map集合轉List集合 149 public void mapToList(Student_3 s3,Student_3 s4){ 150 //1.創建Map集合 151 Map< Integer, Student_3> map = new HashMap<>(); 152 //2.創建List集合 153 List<Student_3> list = new ArrayList<>(); 154 //3.將學生id作為Map集合的Key,學生對象作為Map集合的Vaul 155 map.put(s3.getId(),s3); 156 map.put(s4.getId(),s4); 157 //4.遍歷Map集合 158 Set<Entry<Integer, Student_3>> entrySet = map.entrySet(); 159 for (Entry<Integer, Student_3> e : entrySet) { 160 //5.將Map集合的值加入到Liat集合中 161 list.add(e.getValue()); 162 } 163 //6.遍歷List集合 164 Iterator<Student_3> it = list.iterator(); 165 while(it.hasNext()){ 166 System.out.println(it.next()); 167 } 168 169 } 170 public static void main(String[] args) { 171 //創建四個學生對象 172 Student_3 s1 = new Student_3(101, "張三", 25, "男"); 173 Student_3 s2 = new Student_3(102, "馬琴", 25, "女"); 174 Student_3 s3 = new Student_3(103, "趙薇", 36, "女"); 175 Student_3 s4 = new Student_3(104, "李小梅", 31, "女"); 176 //創建Test_3的實例 177 Test_3 t = new Test_3(); 178 System.out.println("List集合轉Map集合"); 179 //調用List集合轉Map集合方法並傳入學生對象s1,s2 180 t.listToMap(s1,s2); 181 System.out.println("\n"); 182 System.out.println("Map集合轉List集合"); 183 //調用Map集合轉List集合方法並傳入學生對象s3,s4 184 t.mapToList(s3, s4); 185 } 186 }