目錄
（一）前言
（二）作業介紹
（三）演算法與程式碼
（四）PowerDesigner類圖模型
（五）SourceMonitor程式碼分析
（六）自學內容
（七）總結
一、前言
介紹本篇部落格的大致內容、寫作目的、意義等
本篇部落格介紹如何使用Java語言基礎和演算法來解決題目問題，在此基礎上進行對最近Java程式語言學習的總結
題目的難度為Java入門，主要考察 類的設計、類的繼承與多型、集合（列表）、介面的使用 等一些基礎演算法以及一些自學內容
二、作業介紹
展示作業題目，並梳理演算法思路
題目內容
第四~六次PTA作業共7大題，本篇部落格將挑選其中難度最大的 兩題 進行分析與總結：
題目（1）：
題目（2）：
答題判題程式 題目組共有四題， 家居強電電路模擬程式 題目組共有四題。其中上圖的 * 答題判題程式-4* 是對 答題判題程式 -1~3 的增補和迭代，* 家居強電電路模擬程式-2* 是對 家居強電電路模擬程式 -1 的增補和迭代，下面內容將以這兩題展開分析與總結
三、演算法與程式碼
展示個人解決題目的演算法思路以及答案
演算法大綱
題目（1）：答題判題程式-4
Tips：
1、題目輸入按照一定格式規律，因此可以運用正規表示式來高效處理輸入資料，且處理輸入時運用while( input.hasNextLine() ){ }迴圈，逐行收集輸入資訊，直到該行字串為end時退出迴圈
2、在審閱題目（下兩圖）時，可以發現試卷資訊、答卷資訊格式較其他輸入不同，多個【題目】—【分值】/【答題順序】-【答案】共用一個【試卷編號】/【答卷編號】，即輸入資訊有階級關係，因此需要在試卷類和答卷類中額外建立一個集合來存放和引用輸入資訊。而集合(Linked)Hashmap的特點適合這種格式，因此將會使用 Hashmap 和 LinkedHashMap（相關特點在自學內容中）
3、題目輸出的錯誤提示較多且有優先順序順序輸出，所以做題之前應做好輸出提示的優先順序排序，優先順序越高的程式碼塊 應越靠前/在越外層的迴圈
4、迭代新增填空題、多選題兩種機制，需要實現多選題和填空題的答案核對功能（選項的順序變化、答案部分正確的核分等），需要建立對應函式或方法來實現
本題需要建立：
類
-
題目類class Question，包含：
-
整型—num（題目編號）
-
字串型—content（題目內容）
-
字串型—standardanswer（標準答案）
-
整型—score（題目分值）
-
整型—flag（是否被刪除：true=已被刪除/false=未被刪除）
-
方法—Right_Result()（答題正確輸出）
-
方法—Wrong_Result( String wrong_answer )（答題錯誤輸出）
-
-
試卷類class Exam_paper，包含：
- 整型—paper_num（試卷編號）
- 連結串列LinkedHashMap<Integer,Integer> score_map——存放試卷中的題目及對應分值
- 方法—put_score_map(int num, int score )（score_map新增新元素）
- 方法—Check_total_score()（檢測當前試卷是否滿分為100分）
-
學生類class Student，包含：
- 字串型—ID（學號）
- 字串型—name（姓名）
-
答卷類class Answer，包含：
- 整型—paper_num（答卷編號）
- 字串型—ID（學號）
- 連結串列LinkedHashMap<Integer,String> answer_map——存放答卷中的答題順序及對應答案
- 方法—put_answer_map(int order, String answer )（answer_map新增新元素）
-
刪除題目類class Delete，包含：
- 整型—delete_num（刪除題目編號）
-
比較器類class Comparable，包含：
- 方法—int compare(Answer answer1 , Answer answer2 )
主函式
- 陣列列表List[Question] questionArrayList——存放 題目類 資訊
- 陣列列表List[Exam_paper] exam_paperArrayList——存放 試卷類 資訊
- 陣列列表List[Student] studentsArrayList——存放 學生類 資訊
- 陣列列表List[Answer] answerArrayList——存放 答卷類 資訊
- 陣列列表List[Delete] deleteArrayList——存放 刪除題目類 資訊
- 連結串列LinkedList
score——臨時記錄當前答卷人的各題賦分情況
個人思路：
採用迴圈結構利用正規表示式逐行分析輸入——>判斷試卷分值——>記錄刪除的題目——>試卷賦分——>核對試卷與答卷編號——>按照試卷順序去答卷中查詢試卷題號——>判斷題目是否被刪除——>判斷答題是否正確（多選題和填空題呼叫相應核對答案的函式）並記錄得分——>判斷是否有題目漏答——>查詢學生資訊——>輸出學生答題得分
題目（2）：家居強電電路模擬程式-2
Tips：
1、題目輸入按照一定格式規律，因此可以運用正規表示式來高效處理輸入資料，且處理輸入時運用while( input.hasNextLine() ){ }迴圈，逐行收集輸入資訊，直到該行字串為end時退出迴圈
2、題目用到的類較多，且類與類之間存在繼承與多型的關係，因此需要按優先順序順序做好類的設計。且由於所有的裝置都有共同的屬性：輸入引腳、輸出引腳、電阻（無=0），所以可以設計一個最高父類Device，幷包含以上元素
3、由於串聯和並聯電路同樣也含有上述屬性，因此串並聯電路也可以看作一個元件，繼承Device
4、並聯電路其實是由若干個串聯電路組成，因此並聯電路的屬性可以設計為存放串聯電路物件的列表
5、在審閱題目時，可以發現
1)像例如 [* K1-1] [K1-2 *] 的輸入資訊雖然出現了兩次K1的資訊，但其實只代表當前電路中只有一個K1，因此真正有效的資訊是例如 K1] 的輸入，因此在一次此格式的正規表示式匹配成功後，再實現對應類的建立
2)只有含有輸入資訊 [VCC 的電路是主電路，其他電路為支電路，因此可以建立一個臨時電路類變數存放匹配到的主電路資訊
本題需要建立：
類
-
<抽象>元件類class Device，包含：
-
int—num（編號）
-
double—input_pin1（輸入引腳）
-
double—output_pin2（輸出引腳）
-
double—PD（電壓差）
-
double—resistance（電阻）
-
double—ratio（電壓佔比）
-
方法—Show()（列印輸出）
-
-
<繼承-原件類>開關類class ON_OFF，除繼承屬性外包含：
-
String—status（狀態）
-
方法—void Judging_Output(double input_pin)（根據開關狀態，判斷輸出電壓）
-
-
<繼承-原件類>分檔調速器類class Split_Speeder，除繼承屬性外包含：
-
int—current_gear（當前檔位）
-
連結串列LinkedHashMap<Integer,Float> Gears——存放分檔調速器中的檔位及對應電壓輸出比值
-
方法—Gear_Adjust(String status)（根據狀態，設定當前檔位）
-
方法—Gear_Voltage( double input )（根據檔位，輸出電位）
-
-
<繼承-原件類>連續調速器類class Continuous_Speeder，除繼承屬性外包含：
-
double—parameter（檔位引數）
-
方法—Proportional_calculate()（計算正比電壓差）
-
-
<繼承-原件類>串聯電路類class Series_Circuit，除繼承屬性外包含：
- boolean—running（是否可執行）
- 連結串列ArrayList
device_list——存放當前電路的電子元件
-
<繼承-原件類>並聯電路類class Parallel_Circuit，除繼承屬性外包含：
- boolean—running（是否可執行）
- 連結串列ArrayList<Series_Circuit> SUB_Series_list——存放當前並聯電路中的子串聯電路
-
<繼承-原件類>白熾燈類class Incandescent_Lamp，除繼承屬性外包含：
- double—Brightness_lux（流明值）
- 方法—Brightness_calculate()（根據輸入電壓計算亮度）
-
<繼承-原件類>日光燈類class Fluorescent_Lamp，除繼承屬性外包含：
- double—Brightness_lux（流明值）
- 方法—Brightness_calculate()（根據輸入電壓計算亮度）
-
<繼承-原件類>吊扇類class Ceiling_Fan，除繼承屬性外包含：
- int—Speed（轉速值）
- 方法—Speed_calculate()（根據輸入電壓計算轉速）
-
<繼承-原件類>落地扇類class Ground_Fan，除繼承屬性外包含：
- int—Speed（轉速值）
- 方法—Speed_calculate()（根據輸入電壓計算轉速）
主函式
-
連結串列ArrayList<Series_Circuit> series_circuit_list——存放 串聯電路類 資訊
-
連結串列ArrayList<Parallel_Circuit> parallel_circuit_list——存放 並聯電路類 資訊
個人思路：
採用迴圈結構利用正規表示式逐行收集輸入資訊，並標註主電路資訊——>判斷所有電路開關情況——>根據調速器更新電壓——>計算電路電阻——>根據電阻計算比例ratio——>根據開關情況，主電路流入電流——>輸出結果
程式碼大綱
題目（1）：
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
//題目基本資訊
class Tittle
{
}
//1、題目資訊 "#N:"+題目編號+" "+"#Q:"+題目內容+" "#A:"+標準答案
class Question extends Tittle
{
}
//2、試卷資訊 "#T:"+試卷號+" "+題目編號+"-"+題目分值
class Exam_paper
{
}
//3、學生資訊 "#X:"+學號+" "+姓名+"-"+學號+" "+姓名....+"-"+學號+" "+姓名
class Student
{
}
//4、答卷資訊 **"#S:"+試卷號+" "+"#A:"+答案內容**
class Answer
{
}
class Delete
{
}
class Comparable implements Comparator<Answer>
{
}
public class Main
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String regex_Question = "#N:\\s*(\\d+)\\s*#Q:(.+) #A:(.+)";
Pattern pattern_Question = Pattern.compile(regex_Question);
···
···
···
List<Question> questionArrayList = new ArrayList<>();
···
···
···
//輸入
while( input.hasNextLine() )
{
//當前一行的輸入字串
String inputString = input.nextLine();
Matcher pmatcher_Question = pattern_Question.matcher(inputString);
···
···
···
//輸入字串是end，則輸入完畢退出迴圈
if(inputString.equals("end"))
break;
//inputString==輸入1、題目資訊 "#N:"+題目編號+" "+"#Q:"+題目內容+" "#A:"+標準答案
else if(pmatcher_Question.matches())
{
Question question = new Question(Integer.parseInt(pmatcher_Question.group(1).trim()), pmatcher_Question.group(2).trim(), pmatcher_Question.group(3).trim());
questionArrayList.add(question);
}
else
···
···
···
//輸入資訊只要不符合格式要求，均輸出”wrong format:”+資訊內容 例如：wrong format:2 #Q:2+2=
else
{
System.out.println("wrong format:"+inputString);
}
}//總while結束
//判斷試卷分值是否100
···
···
···
if( exam_paperArrayList.size()==0 )
{
Exam_paper exam_paper = new Exam_paper( 0 );
exam_paper.put_score_map( 0 , 0 );
exam_paperArrayList.add(exam_paper);
}
//刪除題目並記錄
···
···
···
//排序answerArrayList
Comparable comparable = new Comparable();
answerArrayList.sort(comparable);
for( int S=0;S<answerArrayList.size();S++ ) //幾份答卷
{
//搜尋答卷對應試卷號
···
···
···
for( int T=0;T<exam_paperArrayList.size();T++ ) //幾份試卷分則
{
//判斷試卷編號是否相同,搜到了對應試卷號
···
//當前試卷題目賦分值
···
{
//根據#T 搜尋題號
···
//搜到了題號
···
//記錄分數
//LinkedList<Integer> score = new LinkedList<>();
//檢測#A
···
//迴圈查詢題目
···
//搜尋當前題號current_num資訊
···
//找到current_num題目
···
//題目有效
···
//判斷是否答對 計算分數
···
//#S:裡的#A:答了刪除的題目
···
//沒找到
···
}//輸入的#A檢測完
//#S：裡的#A: < #T裡的個數 輸入的答案資訊少於試卷的題目數量
···
//搜尋學生
···
//#S:裡的學號在#X:裡沒有 學號引用錯誤
···
//記錄輸出分數格式
···
//#S:裡的paper_num和#T:裡的papernum不等 試卷號引用錯誤
···
//自定義函式：判斷填選答案情況
public static Boolean Including( String A,String a )
{
if( a.isEmpty() )
return false;
for( int i=0;i<a.length();i++ )
{
char c=a.charAt(i);
if ( !A.contains(String.valueOf(c)) )
{
return false;
}
}
return true;
}
}
題目（2）：
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
abstract class Device
{
}
// K 開關
class ON_OFF extends Device
{
}
// F 分檔調速器
class Split_Speeder extends Device
{
}
// L 連續調速器
class Continuous_Speeder extends Device
{
}
//串聯電路
class Series_Circuit extends Device
{
}
//並聯電路
class Parallel_Circuit extends Device
{
}
// B 白熾燈
//亮度在 0~200lux（流明）之間。
//電位差為 0-9V 時亮度為 0,電位差 10V 對應 50ux，220V 對應200lux
//其他電位差與對應亮度值成正比。
class Incandescent_Lamp extends Device
{
}
// R 日光燈
//亮度為 180lux。
//電位差為 0時亮度為 0，電位差不為 0時亮度為 180。
class Fluorescent_Lamp extends Device
{
}
// D 吊扇
// 工作電壓區間為 80V-150V
// 80V 對應轉速為 80轉/分鐘，150V 對應轉速為 360 轉/分鐘，超過 150V 轉速為 360 轉/分鐘
// 其他電壓值與轉速成正比，輸入輸出電位差為 0 時轉速為 0。
class Ceiling_Fan extends Device
{
}
//落地扇
//工作電壓區間為 80V-150V
//80V-99V 80 轉/分 鍾，100-119V 160 轉/分鐘，120-139V 260 轉/分鐘，超過 140V 轉速 為 360 轉/分鐘
class Ground_Fan extends Device
{
}
class Main
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
//主電路
Series_Circuit main_circuit = new Series_Circuit();
//源電壓
double V = 220.0;//預設VCC
//地電壓
double G = 0.0;//預設接地
ArrayList<Series_Circuit> series_circuit_list = new ArrayList<>();
ArrayList<Parallel_Circuit> parallel_circuit_list = new ArrayList<>();
while (input.hasNextLine())
{
//當前一行的輸入字串
String inputString = input.nextLine();
//#T(*):
Pattern pattern_T = Pattern.compile("#T(\\d+):");
Matcher matcher_T = pattern_T.matcher(inputString);
//#M(*):
Pattern pattern_M = Pattern.compile("#M(\\d+):");
Matcher matcher_M = pattern_M.matcher(inputString);
//串聯或並聯電路資訊
//串聯資訊
if(matcher_T.find())
{
int current_num = Integer.parseInt(matcher_T.group(1));
//建立串聯電路
Series_Circuit series_circuit = new Series_Circuit(current_num);
series_circuit_list.add(series_circuit);
//[* *]
Pattern pattern_information = Pattern.compile("\\[(\\S+)\\s(\\S+)\\]");
Matcher matcher_information = pattern_information.matcher(inputString);
//迴圈提取電路資訊
while(matcher_information.find())
{
···
···
···
}
//【VCC
if(inputString.contains("VCC"))
{
V = 220.0;
series_circuit.input_pin1 = V;
//記錄主電路
main_circuit=series_circuit;
}
}
//並聯資訊
else if(matcher_M.find())
{
···
···
···
}
//串聯或並聯電路資訊錄入結束
//【K*】——調節開關
Pattern pattern_K = Pattern.compile("#(K)(\\d)");
Matcher matcher_K = pattern_K.matcher(inputString);
//【F*+\-】——調節分檔調速器檔位
Pattern pattern_F = Pattern.compile("#(\\w)(\\d)(\\+|\\-)");
Matcher matcher_F = pattern_F.matcher(inputString);
//【L*】——調節連續調速器引數
Pattern pattern_L = Pattern.compile("#(\\w)(\\d):(\\d+\\.?\\d*)");
Matcher matcher_L = pattern_L.matcher(inputString);
//輸入字串是end，則輸入完畢退出迴圈
if (inputString.equals("end"))
break;
//inputString== #K* ——調節開關
else if (matcher_K.matches())
{
//獲取當前開關編號
···
//在series_circuit_list，找到其中編號為current_num的開關
···
//開關狀態反轉
···
}
//inputString== #F*+\- ——調節分檔調速器檔位
else if (matcher_F.matches())
{
···
//獲取當前分檔調速器編號
···
//在series_circuit_list，找到其中編號為current_num的分檔調速器
···
}
//inputString== #L*:*(.*) ——調節連續調速器引數
else if (matcher_L.matches())
{
//獲取當前連續調速器編號
···
//在series_circuit_list，找到其中編號為current_num的連續調速器
···
}
}//總while結束
//判斷所有電路開關情況
···
···
···
//根據調速器更新電壓
for(Device device : main_circuit.device_list)
{
//按照線路處理電器
if (device instanceof Split_Speeder)
{
···
···
···
}
}
//計算電路電阻
double Main_Sum_resistance = 0;
for(Device device : main_circuit.device_list)
{
//進入子並聯電路
if(device instanceof Parallel_Circuit)
{
double Sub_Sum_resistance = 0; //R累和
double Pro_resistance = 1; //R累積
if(((Parallel_Circuit) device).running) //子並聯電路執行
{
int count=0;
···
···
···
//進入子串聯電路
for (Series_Circuit series_circuit : ((Parallel_Circuit) device).SUB_Series_list)
{
···
···
···
}
//子並聯電路有多個子串聯電路，並且電路都執行
···
···
···
}
}
else Main_Sum_resistance += device.resistance;
}
···
···
···
//根據電阻計算比例ratio
···
//根據開關情況，main_circuit流入電流
···
//輸出結果
Show_Device(series_circuit_list);
}
//自定義函式：檢測輸入電器型別，建立對應物件
public static void Check_Device(String input_String, double input_V, double output_V, Series_Circuit series_circuit)
{
Pattern pattern_K = Pattern.compile("(K)(\\d)-(\\d)");
Pattern pattern_F = Pattern.compile("(F)(\\d)-(\\d)");
Pattern pattern_L = Pattern.compile("(L)(\\d)-(\\d)");
Pattern pattern_B = Pattern.compile("(B)(\\d)-(\\d)");
Pattern pattern_R = Pattern.compile("(R)(\\d)-(\\d)");
Pattern pattern_D = Pattern.compile("(D)(\\d)-(\\d)");
Pattern pattern_A = Pattern.compile("(A)(\\d)-(\\d)");
Pattern pattern_M = Pattern.compile("M(\\d)-IN");
Matcher matcher_K = pattern_K.matcher(input_String);
Matcher matcher_F = pattern_F.matcher(input_String);
Matcher matcher_L = pattern_L.matcher(input_String);
Matcher matcher_B = pattern_B.matcher(input_String);
Matcher matcher_R = pattern_R.matcher(input_String);
Matcher matcher_D = pattern_D.matcher(input_String);
Matcher matcher_A = pattern_A.matcher(input_String);
Matcher matcher_M = pattern_M.matcher(input_String);
···
···
···
}
//自定義函式：//根據電阻計算比例ratio
public static void Calculate_Ratio(Series_Circuit main_circuit)
{
for (Device device : main_circuit.device_list)
{
if (device.resistance != 0)
{
···
···
···
}
}
}
//自定義函式：//根據開關情況，main_circuit流入電流
public static void Check_Main_Circuit( Series_Circuit main_circuit, double input_V, double output_V)
{
double current_V = input_V;
if(main_circuit.running)
{
···
···
···
}
}
//自定義函式：//按開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、落地扇的順序依次輸出所有裝置的狀態或引數。每個裝置一行。同類裝置按編號順序從小到大輸出。
public static void Show_Device(ArrayList<Series_Circuit> series_circuit_list)
{
ArrayList<Device> device_list = new ArrayList<>();
//收集所有裝置
for (Series_Circuit series_circuit : series_circuit_list)
{
device_list.addAll(series_circuit.device_list);
}
//按編號升序輸出開關資訊
···
//按編號升序輸出分檔調速器資訊
···
//按編號升序輸出連續調速器資訊
···
//按編號升序輸出白熾燈資訊
···
//按編號升序輸出日光燈資訊
···
//按編號升序輸出吊扇資訊
···
//按編號升序輸出落地扇資訊
···
}
}
四、PowerDesigner類圖模型
題目（1）：
題目（2）：
五、SourceMonitor程式碼分析
題目（1）：
題目（2）：
六、自學內容
展示自學內容，並進行重點的歸納和整理（這裡只展示個人認為比較重要且題目需要用到的知識點）
正規表示式
推薦正規表示式的網上測試工具網址：<正規表示式線上測試 | 菜鳥工具 (jyshare.com)>裡面附帶下圖最基本的正規表示式語法參考
Pattern類 和 Matcher 方法
（1） Matcher 匹配器類，透過 Pattern 執行匹配操作，基本用法為：
Pattern [pattern名稱] = Pattern.compile([正規表示式/固定字串]);
Matcher [matcher名稱] = [pattern名稱].matcher([被匹配的字串]);
（2）.matches() 方法：對整個字串進行匹配，匹配成功返回true
例：正規表示式：\d+ //至少一個數字
被匹配字串：12345 //匹配成功 被匹配字串：12345abc //匹配失敗
//(1)程式碼
if( [matcher名稱].matches() ){
System.out.println("匹配成功");
}
（3）.find() 方法：對字串進行區域性匹配，匹配成功返回true
.find()方法在匹配後會從匹配部分的下個位置開始
例：正規表示式：\d+ //至少一個數字
被匹配字串：123abc //匹配成功一次 被匹配字串：123abc123 //匹配成功兩次
//(1)程式碼
if( [matches名稱].find() ){
System.out.println("匹配成功");
}
（4）.group() 方法：透過對括號內的字元分組，對每個組進行處理的方法
group( [組數] )，括號中的整型(>0) 對應 正規表示式中按括號分組的區域性字元段；整型（=0）對應整個字串
Pattern pattern = Pattern.compile("(\\w+)-(\\d+)"); //[至少一個數字]-[至少一個字母]
Matcher matcher = pattern.matcher("a-1,b-b,c-3,d-d");
while ( matcher.find() ) //迴圈區域性匹配
{
System.out.println("整組：" + matcher.group(0));
System.out.println("組1：" + matcher.group(1));
System.out.println("組2：" + matcher.group(2));
}
輸出如圖：
ArrayList 和 LinkedList
需要匯入 java.util.Array 、java.util.LinkedList 包
異同：
相同處：沒有固定大小的限制，可以新增或刪除元素
不同處:1）ArrayList按線性的順序儲存資料；LinkedList是在每一個節點裡存到下個節點地址的線性表
2）ArrayList適用頻繁訪問列表中的某個元素，查詢和修改操作效率較低 LinkedList需要透過迴圈迭代來訪問列表中的元素，增加和刪除操作效率較高
（1）建立
ArrayList<E> [表名稱] =new ArrayList<>(); //E—>泛型
LinkedList<E> [表名稱] = new LinkedList<E>(); //E—>泛型，普通建立
LinkedList<E> [表名稱] = new LinkedList(Collection<? extends E> c); //E—>泛型，集合建立
（2）.add() 方法：新增元素
List.add( [元素] ); //尾插一個新元素
（3）. get() 方法：訪問元素
List.get( n-1 ); //訪問第n個元素
（4）size() 方法：計算大小
List.size(); //返回整型=表的元素個數
（5）for each 方法：迭代遍歷
for ( [元素型別] [迴圈變數] : [表名稱] )
{
System.out.println([迴圈變數]);
}
HashMap 和 LinkedHashMap
需要匯入 java.util.HashMap 、java.util.LinkedHashMap 包
異同：
相同處：沒有固定大小的限制的雜湊表，它儲存的內容是鍵值對(key-value)對映
不同處:1）HashMap每次新增元素的存放位置是無序的；LinkedHashMap保證迭代順序，即按 照儲存順序排列
2） LinkedHashMap額外加了 *頭節點header*，*標誌位accessOrder* 兩個成員變數
（1）建立
HashMap<[key型別], [value型別]> [表名稱] = new HashMap<{[key型別], [value型別]}>(); //E—>泛型，{}中內容可以省略
LinkedHashMap<[key型別], [value型別]> [表名稱] = new LinkedHashMap<{[key型別], [value型別]}>(); //E—>泛型，{}中內容可以省略
（2）.put() 方法：新增元素
Map.put( [key],[value] ); //尾插一個新元素
（3）. get(key) 方法：訪問鍵值對應對映值
Map.get( [key] ); //訪問key的value
（4）size() 方法：計算大小
Map.size(); //返回整型=表的元素個數
（5）for each 方法：迭代遍歷
// 輸出 key 和 value
for ([key型別] key : [表名稱].keySet() ) //.keySet()方法當前獲取鍵值
{
System.out.println( "key: " + key + " value: " + [表名稱].get(key) );
}
Comparator 和 Comparable方法
需要匯入 java.util.Comparator 包
異同：
相同處：可以對 集合Collections 進行排序
不同處：Comparator 可以有更多的排序方法
數值排序
class [方法名稱] implements Comparator<[排序物件型別]>
{
public int compare( [排序元素1] , [排序元素2] ) //Comparator介面的方法 int compare(object o1,object o2);
{
if([排序元素1]>[排序元素2]) return 1;
else if([排序元素1]>[排序元素2]) return -1;
else return 0;
}
}
字串排序
class [方法名稱] implements Comparator<[排序物件型別]>
{
public int compare( [排序元素1] , [排序元素2] )
{
return [排序元素1].compareTO( [排序元素2] ); //.compareTo()方法用於字串之間的比較
}
}
Optional 類(資料流)
需要匯入 java.util.Optional 包
可以儲存
型別的容器物件，可以很好的解決空指標異常問題
（1）建立
//在parallel_circuit_list中尋找編號為sub_num的物件
Optional<Parallel_Circuit> FoundOptional = parallel_circuit_list.stream().filter(parallel_circuit -> parallel_circuit.num == sub_num).findFirst(); //.findFirst()——找到第一個就返回該物件
（2）isPresent() 方法：物件存在則返回true
if( FoundOptional.isPresent() ) //透過資料流找到相應元素
{
//相應操作
}
七、總結
（1）面對家居強電電路模擬程式-2時，應提前做好類的設計，提前規劃類圖，確認類之間屬性的公共性和對應方法體
（2）家居強電電路模擬程式-2 尤其體現了類的繼承與多型，極大提升了程式碼的可複用性
（3）程式碼的質量仍待提高：比如類設計的單一職責原則、不必要的演算法結構、過多的分支結構等問題使程式碼還有更多的可提升空間
E N D