OOP题目集7~8的总结

目录

（一）前言

（二）作业介绍

（三）算法与代码

（四）PowerDesigner类图模型

（五）SourceMonitor代码分析

（六）自学内容

（七）总结

---

一、前言

介绍本篇博客的大致内容、写作目的、意义等

本篇博客介绍如何使用Java语言基础和算法来解决题目问题，在此基础上进行对最近Java编程语言学习的总结

题目的难度为Java入门，主要考察 类的设计、类的继承与多态、集合（列表）、接口的使用 等一些基础算法以及一些自学内容

---

二、作业介绍

展示作业题目，并梳理算法思路

题目内容

第七~八次PTA作业共两大题，本篇博客将直接挑选最终迭代的 一题 进行分析与总结：

题目：

---

家居强电电路模拟程序 题目组共有四题。* 家居强电电路模拟程序-4* 是对 家居强电电路模拟程序 -3 的增补和迭代，下面内容将对这一题展开分析与总结

---

三、算法与代码

展示个人解决题目的算法思路以及答案

算法大纲

题目：家居强电电路模拟程序-4

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()（根据输入电压计算转速）

• <继承-原件类>受控窗帘类class Curtain，除继承属性外包含：

  • int—ratio（开窗比例）
  • 方法—Ratio_calculate(double Total_lux)（根据总光照强度计算开窗比例）

• <继承-原件类>互斥开关类class Switch，除继承属性外包含：

  • boolean —STATUS（输入引脚情况）
  • 方法—Status_Adjust(String status)（根据输入状态，设置状态）

• <继承-原件类>二极管类class Diode，除继承属性外包含：

  • boolean —STATUS（二极管正反向状态）

主函数

• 链表ArrayList<Series_Circuit> series_circuit_list——存放 串联电路类 信息

• 链表ArrayList<Parallel_Circuit> parallel_circuit_list——存放 并联电路类 信息

个人思路：

	采用循环结构利用正则表达式逐行收集输入信息，并标注主电路信息——>判断所有电路开关情况——>根据调速器更新电压——>计算电路电阻——>根据电阻计算比例ratio——>根据开关情况，主电路流入电流——>处理并校对各元件对应信息格式——>输出结果

---

代码大纲

题目：

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
{
    
}

//互斥开关：3个引脚：1个是汇总引脚，另两个是分支引脚。
//左边是汇总引脚，编号为1；右边两个是分支引脚，右上的输出引脚为2，右下输出引脚为3。
//1、2、3引脚均可以是输入引脚，当1为输入引脚时，2、3引脚为输出引脚；1为输出引脚时，2、3引脚为输入引脚。
//互斥开关只有两种状态：开关接往上面的2号引脚、接往下面的3号引脚。开关每次只能接通其中一个分支引脚，而另一个分支引脚处于断开状态。
//互斥开关的默认状态为1、2引脚接通，1、3引脚断开。
//互斥开关可以反过来接入电路，即汇总引脚接往接地端，两个分支引脚接往电源端。
//互斥开关显示1、2引脚的接通状态，接通时显示closed，断开时显示turned on。
class Switch 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
{
    
}


//受控窗帘
//电路中所有灯光的光照强度总和在[0,50)lux范围内，窗帘全开；
//在[50,100)lux范围内，窗帘打开比例为0.8；
//在[100,200)lux范围内，窗帘打开比例为0.6；
//在[200,300)lux范围内，窗帘打开比例为0.4；
//在[300,400)lux范围内，窗帘打开比例为0.2；
//在400lux及以上范围内，窗帘关闭。
//窗帘默认为关闭状态。
class Curtain extends Device
{
    
}

//二极管
//正向导通，反向截止
//当电流从左至右流过时，二极管导通”conduction”，电阻为0；
//电流从右至左流动时，二极管截止”cutoff”，电阻无穷大，相当于开关打开
class Diodeextends 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<>();
        ArrayList<Switch> switch_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);

            //串联或并联电路信息
            //串联信息 #T(*):
            if(matcher_T.find())
            {

                ···


                //[* *]
                Pattern pattern_information = Pattern.compile("\\[(\\S+)\\s(\\S+)\\]");
                Matcher matcher_information = pattern_information.matcher(inputString);

                //循环提取电路信息
                while(matcher_information.find())
                {
                    //【IN
                    ···

                    // OUT】
                    ···

                    //GND】
                    else if (matcher_information.group(2).contains("GND"))
                    {
                        G = 0.0;
                    }

                    //【*
                    Pattern front_pattern = Pattern.compile("\\[(\\w\\d-\\d)");
                    Matcher fronMatcher = front_pattern.matcher(inputString);

                    //*】
                    Pattern back_pattern = Pattern.compile("(\\w\\d-\\d)\\]");
                    Matcher backMatcher = back_pattern.matcher(matcher_information.group(0));

                    //M*-IN
                    Pattern sub_pattern = Pattern.compile("M(\\d)-IN");
                    Matcher subMatcher = sub_pattern.matcher(matcher_information.group(0));

                    //T*-IN
                    Pattern sub_pattern_T = Pattern.compile("T(\\d)-IN");
                    Matcher subMatcher_T = sub_pattern_T.matcher(matcher_information.group(0));

                    if(fronMatcher.find())
                    {

                        ···

                    }

                    //*】
                    if(backMatcher.find())
                    {
                        Pattern pattern_H = Pattern.compile("(H)(\\d)-(\\d)");
                        Matcher matcher_H = pattern_H.matcher(matcher_information.group(0));

                        if(matcher_H.find())//是互斥开关
                        {

                            ···

                        }
                        else//不是互斥开关
                        {
                            ···
                        }


                    }

                    //M*-IN
                    if(subMatcher.find())
                    {

                        ···

                    }
                    //T*-IN
                    else if(subMatcher_T.find())
                    {

                        ···

                    }

                }

                //【VCC
                if(inputString.contains("VCC"))
                {

                   ···

                }
            }
            //并联信息 #M(*):
            else if(matcher_M.find())
            {
                int current_num = Integer.parseInt(matcher_M.group(1));

                //创建并联电路
                Parallel_Circuit parallel_circuit = new Parallel_Circuit(current_num);
                parallel_circuit_list.add(parallel_circuit);

                //T(*)
                Pattern pattern_MT = Pattern.compile("T(\\d+)");
                Matcher matcher_MT = pattern_MT.matcher(inputString);
                while(matcher_MT.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())
            {

                ···

                //开关状态反转

                ···

            }
            //inputString== #F*+\-  ——调节分档调速器档位
            else if (matcher_F.matches())
            {

                ···

            }
            //inputString== #L*:*(.*)  ——调节连续调速器参数
            else if (matcher_L.matches()) {

                ···

            }

        }//总while结束


        //当前电压
        double current_V = V;

        //判断所有电路开关情况
        for (Series_Circuit series_circuit : series_circuit_list)
        {
            //在series_circuit_list找到所有开关
            for (Device device : series_circuit.device_list)
            {
                ···
            }

            //在series_circuit_list找到所有互斥开关
            for (Device device : series_circuit.device_list)
            {
                ···
            }
        }

        //根据调速器更新电压
        for(Device device : main_circuit.device_list)
        {
            //按照线路处理电器

            ···

        }




        //计算电路电阻
        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;


                   
                    //检查是否有子串联电路短路

                   ···

                    //flag=true 短路,则当前子并联电路不运行

                    ···


                    //进入子串联电路
                    for (Series_Circuit series_circuit : ((Parallel_Circuit) device).SUB_Series_list)
                    {

                        ···

                    }

                    //子并联电路有多个子串联电路，并且电路都运行

                    ···

                }
            }
            else Main_Sum_resistance += device.resistance;
        }
        main_circuit.resistance = Main_Sum_resistance;
        main_circuit.ratio = 1;


        //根据电阻计算比例ratio
        Calculate_Ratio(main_circuit);


        //根据开关情况，main_circuit流入电流
        Check_Main_Circuit(main_circuit,current_V,G);


        //求出总光照度
        double Total_LUX = Get_LUX(main_circuit);

        //受控窗帘计算光照度
        Calculate_Curtain_Status(series_circuit_list,Total_LUX);




        //输出结果
        Show_Device(series_circuit_list);



    }


    //自定义函数：检测输入电器类型，创建对应对象
    public static void ADD_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_H = Pattern.compile("(H)(\\d)-(\\d)");
        Pattern pattern_S = Pattern.compile("(S)(\\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_H = pattern_H.matcher(input_String);
        Matcher matcher_S = pattern_S.matcher(input_String);
        Matcher matcher_M = pattern_M.matcher(input_String);

        if (matcher_K.matches())  //开关
        {
            ON_OFF on_off = new ON_OFF(Integer.parseInt(matcher_K.group(2)), input_V, output_V);
            series_circuit.device_list.add(on_off);
        } else if (matcher_F.matches()) //分档调速器
        {
            Split_Speeder split_speeder = new Split_Speeder(Integer.parseInt(matcher_F.group(2)), matcher_F.group(3));
            series_circuit.device_list.add(split_speeder);
        } else if (matcher_L.matches()) //连续调速器
        {
            Continuous_Speeder continuous_speeder = new Continuous_Speeder(Integer.parseInt(matcher_L.group(2)), input_V, output_V);
            series_circuit.device_list.add(continuous_speeder);
        } else if (matcher_B.matches()) //白炽灯
        {
            Incandescent_Lamp incandescent_lamp = new Incandescent_Lamp(Integer.parseInt(matcher_B.group(2)), input_V, output_V);
            series_circuit.device_list.add(incandescent_lamp);
        } else if (matcher_R.matches()) //日光灯
        {
            Fluorescent_Lamp fluorescent_lamp = new Fluorescent_Lamp(Integer.parseInt(matcher_R.group(2)), input_V, output_V);
            series_circuit.device_list.add(fluorescent_lamp);
        } else if (matcher_D.matches()) //吊扇
        {
            Ceiling_Fan ceiling_fan = new Ceiling_Fan(Integer.parseInt(matcher_D.group(2)), input_V, output_V);
            series_circuit.device_list.add(ceiling_fan);
        } else if (matcher_A.matches()) //落地扇
        {
            Ground_Fan ground_fan = new Ground_Fan(Integer.parseInt(matcher_A.group(2)), input_V, output_V);
            series_circuit.device_list.add(ground_fan);
        } else if (matcher_H.matches()) //互斥开关
        {
            Switch switch_ = new Switch(Integer.parseInt(matcher_H.group(2)), input_V, output_V);
            series_circuit.device_list.add(switch_);
        } else if (matcher_S.matches()) //受控窗帘
        {
            Curtain curtain = new Curtain(Integer.parseInt(matcher_S.group(2)), input_V, output_V);
            series_circuit.device_list.add(curtain);
        }else if (matcher_M.matches()) //并联电路
        {
            Parallel_Circuit parallel_circuit = new Parallel_Circuit(Integer.parseInt(matcher_M.group(1)));
            series_circuit.device_list.add(parallel_circuit);
        }

    }

    //自定义函数：//根据电阻计算比例ratio
    public static void Calculate_Ratio(Series_Circuit main_circuit)
    {
        for (Device device : main_circuit.device_list)
        {
            if (device.resistance != 0)
            {
                device.ratio = device.resistance / main_circuit.resistance;

                device.input_pin1 = main_circuit.input_pin1 * device.ratio;

                if (device instanceof Parallel_Circuit)
                {
                    if(((Parallel_Circuit) device).running)
                    {
                        for (Series_Circuit Sub_series_circuit : ((Parallel_Circuit) device).SUB_Series_list)
                        {
                            if (Sub_series_circuit.running)
                            {
                                Sub_series_circuit.input_pin1 = device.input_pin1;
                                Calculate_Ratio(Sub_series_circuit);
                            }
                        }
                    }
                }
            }
        }
    }

    //自定义函数：//根据开关情况，main_circuit流入电流
    public static void Check_Main_Circuit( Series_Circuit main_circuit, double input_V, double output_V)
    {
        if(main_circuit.running)
        {
            main_circuit.input_pin1 = input_V;
            for(Device device : main_circuit.device_list)
            {
                if (device instanceof Incandescent_Lamp) {
                    //白炽灯

                    ((Incandescent_Lamp) device).Brightness_calculate();

                } else if (device instanceof Fluorescent_Lamp) {
                    //日光灯

                    ((Fluorescent_Lamp) device).Brightness_calculate();

                } else if (device instanceof Ceiling_Fan) {
                    //吊扇

                    ((Ceiling_Fan) device).Speed_calculate();

                }else if (device instanceof Ground_Fan) {
                    //落地扇

                    ((Ground_Fan) device).Speed_calculate();
                }

                else if (device instanceof Parallel_Circuit)
                {
                    if(((Parallel_Circuit) device).running)
                    {
                        //递归调用，检测并联电路里的子电路
                        for(Series_Circuit series_circuit : ((Parallel_Circuit) device).SUB_Series_list)
                        {
                            if(series_circuit.running)
                            {
                                Check_Main_Circuit(series_circuit, series_circuit.input_pin1, output_V);
                            }
                        }
                    }
                }
            }

        }



    }



   //自定义函数：//求出总光照强度
    public static double Get_LUX(Series_Circuit main_circuit)
    {
        ···
        return LUX;
    }


    //自定义函数：根据总光照强度计算窗帘开合度
    public static void Calculate_Curtain_Status(ArrayList<Series_Circuit> series_circuit_list, double LUX)
    {

        ···

    }


    //自定义函数：检测输入电器类型，创建对应对象
    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)
    {
        
        ···
        
    }

}

---

四、PowerDesigner类图模型

---

五、SourceMonitor代码分析

题目：

---

六、自学内容

展示自学内容，并进行重点的归纳和整理（这里只展示个人认为比较重要且题目需要用到的知识点）

正则表达式

推荐正则表达式的网上测试工具网址：<正则表达式在线测试 | 菜鸟工具 (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

Map.put( [key],[value] );  	//尾插一个新元素

---

七、总结

（1）面对家居强电电路模拟程序-4时，应提前做好类的设计，提前规划类图，确认类之间属性的公共性和对应方法体

（2）家居强电电路模拟程序-4 尤其体现了类的继承与多态，极大提升了代码的可复用性

（3）代码的质量仍待提高：比如类设计的单一职责原则、不必要的算法结构、过多的分支结构等问题使代码还有更多的可提升空间

---

---

E N D