目录
（一）前言
（二）作业介绍
（三）算法与代码
（四）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
标签：总结,题目,matcher,OOP,circuit,Pattern,pattern,class From： https://www.cnblogs.com/nchu22022202java01/p/18235654