• java必做实验3

    (1). 运行以下三个程序，对每一行语句加上注释，并对每一个程序的每一个输出结果给出分析。在报告中附上程序截图和详细的文字说明。

    1. public class first_1 {
    2.     public static void main(String []args){
    3.         System.out.println("Hi, ABC, good".matches("ABC "));//matches判断所给字符串是否匹配给定（ABC ）正则表达式，不匹配，返回false
    4.         System.out.println("Hi, ABC, good".matches(".*ABC.*"));//.*ABC.*与所给字符串匹配，返回true
    5.         System.out.println("A,B;C".replaceAll(",;","#"));//replaceAll方法想将”,;“替换成”#“，原字符串没有”,;“，则没有变化
    6.         System.out.println("A,B;C".replaceAll("[,;]","#"));//正则表达式[,;]通过replaceAll方法将字符中所有”,“，”;“替换成”#“
    7.         String []tokens="A,B;C".split("[,;]");//正则表达式[,;]通过split方法将字符中所有”,“，”;“作为分割符将原字符串分割
    8.         for(int i=0;i//i
    9.             System.out.println(tokens[i]+" ");//输出split后的tokens的单个字符，每个字符占一行
    10.     }
    11. }
    1. public class first_2 {
    2.     public static void main(String []args){//main方法
    3.         String s="Hi, Good Morning";//定义一个字符串s并对其赋值为”Hi, Good Morning“
    4.         System.out.println(m(s));//输出以s为参数的m方法的返回值，m的定义在下面
    5.     }
    6.     public static int m(String s){//以字符串s为形参，int为返回类型的共有静态方法m的定义
    7.         int count = 0;//定义一个int型变量count，并初始化为0
    8.         for(int i=0;i//i初始化为0，i
    9.             if(Character.isUpperCase(s.charAt(i)))//如果以i下标的s字符为大写英文字母，执行下面语句
    10.                 count++;//count的值加一
    11.         }
    12.         return count;//将count做为返回值
    13.     }
    14. }
    1. public class first_3 {
    2.     public static void main(String []args){//main方法
    3.         String s="java";//定义String类型的变量s并初始化为“java”
    4.         StringBuilder builder=new StringBuilder(s);//以s为参数定义StringBuilder类型的变量builder
    5.         change(s,builder);//将s,builder作为实参执行change方法
    6.         System.out.println(s);//输出change方法后的s
    7.         System.out.println(builder);//输出change方法后的builder
    8.     }
    9.     private static void change(String s,StringBuilder builder){//以是s，builder为形参void为返回类型的私有静态方法change的定义
    10.         s=s+" and HTML";//企图在s后面加上“and HTML”
    11.         //但是在方法change里面的s不是main里面的s（值传递），所以在退出方法change后s末尾并未被加上“HTML”
    12.         builder.append(" and HTML");//用StringBuilder中的append方法在builder字符串后面加上“and HTML”
    13.     }
    14. }

    2). 抽象类和接口的实验。

    (2.1) 定义一个抽象类Human：包含一个成员变量String name；构造方法Human(String name)，用于初始化姓名name；一个抽象方法double sayHi()。在报告中附上程序截图和详细的文字说明。

    1. package second;
    2.  
    3. public abstract  class Human {//抽象类Human
    4.     String name;//成员变量name
    5.     Human(String name){//以name为参数的构造方法
    6.         this.name=name;//因为重名所以用this所指出的成员变量name被形参name赋值
    7.     }
    8.     public abstract double sayHi();//一个抽象方法double sayHi()
    9. }

     （单个抽象类无法执行，执行结果放1.3）

    (2.2) 定义三个继承抽象类Human的类，分别命名为Chinese、Japanese和English，在这三个类中重写sayHi()方法，分别输出一句中文、日文和英文的问候；在报告中附上程序截图、运行结果和详细的文字说明。

    三个类的定义都是类似的：

    Chinese类：

    1. package second;
    2. public class Chinese extends Human{
    3.         Chinese(String name){//构造方法的实现
    4.             super(name);//调用父类构造 tips必须是构造方法中都第一条语句
    5.         }
    6.         public double sayHi(){//抽象成员方法的实现
    7.             System.out.println("Hi, I'm"+name);//输出name为了测试是否继承了成员变量
    8.             return 0;
    9.         }
    10. }

    English类：

    1. package second;
    2. public class English extends Human{
    3.     English(String name){//构造方法的实现
    4.         super(name);//调用父类构造 tips必须是构造方法中都第一条语句
    5.     }
    6.     public double sayHi(){//抽象成员方法的实现
    7.         System.out.println("Hi, I'm"+name);//输出name为了测试是否继承了成员变量
    8.         return 0;
    9.     }
    10. }

    Japanese类：

    1. package second;
    2. public class Japanese extends Human{
    3.     Japanese(String name){//构造方法的实现
    4.         super(name);//调用父类构造 tips必须是构造方法中都第一条语句
    5.     }
    6.     public double sayHi(){//抽象成员方法的实现
    7.         System.out.println("Hi, I'm"+name);//输出name为了测试是否继承了成员变量
    8.         return 0;
    9.     }
    10. }

    （未定义main方法，执行结果放2.3）

    (2.3) 定义一个测试类HumanTest：创建一个包含3个Human对象的数组，3个Human对象来自Chinese、Japanese和English类，循环调用该数组中的元素的sayHi()方法。在报告中附上程序截图、运行结果和详细的文字说明。

    因为要用Human对象调用3者，可知这是上转型变量的数组

    代码如下：

    1. package second;
    2. public class Human_test {
    3.     public static void main(String []args){
    4.         System.out.println("抽象类实现上转型对象：");
    5.         Human []human=new Human[3];//创建human数组
    6.         human[0]= new Chinese("Chinese");
    7.         human[1]=new English("English");
    8.         human[2]=new Japanese("Japanese");//human数组变量分别是3者的上转型
    9.         for(int i=0;i<3;i++) human[i].sayHi();
    10.     }
    11. }

    名字输出正确，打招呼方法与想对应子类对应，代码执行成功。 

    (2.4) 通过一个接口（命名为Human）和三个实现类（命名为Chinese、Japanese和English）来达到如上类似的效果。在报告中附上程序截图、运行结果和详细的文字说明。

    接口：

    1. package second_new;
    2. public interface Human {
    3.     double sayHello();
    4. }

    三个类：

    1. package second_new;
    2. public class Chinese implements Human{
    3.     String name;//接口中只能有final数据类型，所以name放在这里
    4.     Chinese(String name){//构造方法的实现
    5.         this.name=name;
    6.     }
    7.     public double sayHello(){//抽象成员方法的实现
    8.         System.out.println("Hello, I'm "+name);//输出name为了测试是否实现了抽象的接口方法
    9.         return 0;
    10.     }
    11. }
    12.  
    13. package second_new;
    14. public class English implements Human{
    15.     String name;//接口中只能有final数据类型，所以name放在这里
    16.     English(String name){//构造方法的实现
    17.         this.name=name;
    18.     }
    19.     public double sayHello(){//抽象成员方法的实现
    20.         System.out.println("Hello, I'm "+name);//输出name为了测试是否实现了抽象的接口方法
    21.         return 0;
    22.     }
    23. }
    24.  
    25.  
    26. package second_new;
    27. public class Japanese implements Human{
    28.     String name;//接口中只能有final数据类型，所以name放在这里
    29.     Japanese(String name){//构造方法的实现
    30.         this.name=name;
    31.     }
    32.     public double sayHello(){//抽象成员方法的实现
    33.         System.out.println("Hello, I'm "+name);//输出name为了测试是否实现了抽象的接口方法
    34.         return 0;
    35.     }
    36. }

    测试类：

    1. package second_new;
    2. public class interface_test {
    3.     public static void main(String []args){
    4.         System.out.println("接口实现上转型对象：");
    5.         Human[] human=new Human[3];//创建human数组
    6.         human[0]= new Chinese("Chinese");
    7.         human[1]=new English("English");
    8.         human[2]=new Japanese("Japanese");
    9.         for(int i=0;i<3;i++) human[i].sayHello();
    10.     }
    11. }

    运行成功！

    (3). 编写Java应用程序，计算菜单“北京烤鸭：199.1元；西芹炒肉：11.8元；酸菜鱼：59.1元；铁板牛柳：32.1元”的总价格。在报告中附上程序截图、完整的运行结果截图和简要文字说明。

    由题可知，这道题主要对题目的这个字符串进行处理，将菜名和菜的价格从字符串中提出，我想到的是用Scanner提供的分隔符切割提取的方法

    源代码如下（只有一个主方法）

    其中的正则表达式[；元：]是因为菜名和价格之间都是隔着这些字符

    1. package third;
    2. import java.util.*;
    3. import java.util.Scanner;
    4. public class menu {
    5.     public static void main(String []args){
    6.         String s1=("北京烤鸭：199.1元；西芹炒肉：12.9元；酸菜鱼：59元；铁板牛柳：32.1元");
    7.         Scanner menu =new Scanner(s1);
    8.         menu.useDelimiter("[：元；]");//自定义正则表达式作为分隔标记
    9.         double []price=new double[4];//保存菜价
    10.         String []name=new String[4];//保存菜名
    11.         int i=0,j=0;//i,j后面分别作为price和name的数组下标
    12.         double sum=0;//sum作为总价最后输出
    13.         while(menu.hasNext()){
    14.             try{//读入double数据
    15.                 double num= menu.nextDouble();//这里用num记录下nextDouble的值
    16.                 price[i++]= num;
    17.                 sum+=num;//若用两次nextDouble就会出错
    18.             }//被分隔分开的不是double数，由正则表达式可知保存的是菜名
    19.             catch(InputMismatchException exp) {
    20.                 name[j++]= menu.next();
    21.             }//while中catch利用异常处理方法获得菜名
    22.         }
    23.         for(int ii=0;ii<name.length;ii++){//i已经被定义过了，不能重定义，就用ii啦
    24.             System.out.println(name[ii]+"的价格是："+price[ii]+"元");
    25.         }
    26.         System.out.println("总价是："+sum);//输出总价
    27.     }
    28. }

    菜名和价格都输出准确，最后的总价也计算正确，代码执行成功

    (4). 编写Java应用程序，每次从键盘读入一个包含有大写英文字母、小写英文字母和数字混杂的字符串(例如Aa123bEFGaaa49023)，要求按顺序输出大写英文字母（例如AEFG）、小写英文字母（abaaa）和数字（12349023）。要求循环连续测试10次，在报告中附上程序截图、完整的运行结果截图和简要文字说明。

    由题我想到了正则表达式及字符串的替换与分解的用法

    源代码：

    1. package fourth;
    2. import java.util.*;
    3. import java.util.regex.*;
    4. public class four {
    5.     public static void main(String []args){
    6.         for(int i=0;i<10;i++){
    7.             System.out.print("Please input your string:");
    8.             Scanner input=new Scanner(System.in);
    9.             String s=input.nextLine();//s保留输入的字符串，设为输入一整行
    10.             Pattern p;
    11.             Matcher m;
    12.             p=Pattern.compile("[A-Z]+");//正则化表达式，取A到Z字符
    13.             m=p.matcher(s);
    14.             System.out.print("The following is majuscule:");
    15.             while(m.find()){
    16.                 String str=m.group();
    17.                 System.out.print(str);
    18.             }
    19.             System.out.println();
    20.             p=Pattern.compile("[a-z]+");正则化表达式，取a到z字符
    21.             m=p.matcher(s);
    22.             System.out.print("The following is minuscule:");
    23.             while(m.find()){
    24.                 String str=m.group();
    25.                 System.out.print(str);
    26.             }
    27.             System.out.println();
    28.             p=Pattern.compile("[\\d+]");正则化表达式，取阿拉伯数字
    29.             m=p.matcher(s);
    30.             System.out.print("The following is number:");
    31.             while(m.find()){
    32.                 String str=m.group();
    33.                 System.out.print(str);
    34.             }
    35.             System.out.println();
    36.         }
    37.     }
    38. }

    运行结果（题目给的自己瞎搞了几组数据，好像没什么大问题了）。

    （5）编写Java应用程序，统计分析网页About-Shenzhen University (SZU) 中关于深圳大学的介绍的英文文章（包括题目About）中每个英文单词出现的次数（不区分大小写，不要写爬虫，可以把整篇文章的内容当作一个字符串读入），并输出出现次数最多的50个英文单词（按出现次数排序，每行输出10个英文单词，共5行）。在报告中附上程序截图、完整的运行结果截图和简要文字说明。

    文本预处理，把换行符全去了，将整篇文章作为一行输入（太菜了，只能这样了QAQ）

    代码：

    1. package fifth;
    2. import java.util.*;
    3. import static java.lang.Character.*;
    4. public class web {
    5.     public static void main(String []args){
    6.         Scanner input= new Scanner(System.in);
    7.         StringBuilder article=new StringBuilder();//article存放输入的文章
    8.         article.append(input.nextLine());
    9.         for(int i=0;i
    10.             if(isUpperCase(article.charAt(i)))
    11.                 article.setCharAt(i,toLowerCase(article.charAt(i)));//将article里面的所有大写字母转为小写
    12.         String[] words=article.toString().split("[^a-z']");//将^和a~z之外的所有字符作为分隔符
    13.         HashMap map=new HashMap<>();//统计单词数的图
    14.         for(String word:words) {//若拆分出来的字符不为空串，则统计出现的次数
    15.             if (word.equals("")) continue;
    16.             if (map.containsKey(word))
    17.                 map.replace(word, map.get(word) + 1);//若已经存在该单词的键，则对应的值+1
    18.             else map.put(word, 1);//若不存在该单词的键，则将其对应的值设为1
    19.         }
    20.             List> list=new ArrayList<>(map.entrySet());//将哈希表中的键值对转化成List
    21.             list.sort((o1,o2)->o2.getValue().compareTo(o1.getValue()));//降序排序
    22.             for(int i=0;i<5;i++){//输出出现次数最多的前50个单词
    23.                 for(int j=0;j<10;j++)
    24.                     System.out.printf("%s:%d  ",list.get(i*10+j).getKey(),list.get(i*10+j).getValue());//每个单词占20个字符，左对齐
    25.                 System.out.println();
    26.             }
    27.     }
    28. }

    (6). 张三、李四等人是A社团成员，李四、王五等人是B社团成员，编写一个Java应用程序（要求使用集合类），输出参加A社团的人、参加B社团的人、以及同时参加两个社团的人。在报告中附上程序截图、完整的运行结果截图和详细的文字说明。（10分）

    这道题中李四即是A社团的成员又是B社团的成员，他是A社团和B社团的交集，在学的集合类中，HashSet是一个可以求交、并集的类，所以这道题我用了HashSet求交集

    源代码如下：

    1. package fifth;
    2. import java.util.*;
    3. import java.util.HashMap;
    4. public class six {
    5.     public static void main(String args[]){
    6.         HashSet A=new HashSet();//A社团初始化
    7.         A.add("张三");
    8.         A.add("李四");
    9.         System.out.print("A的社团成员有：");
    10.         Object []a=A.toArray();
    11.         for(int i=0;i//输出A社团成员
    12.             System.out.print(a[i]+" ");
    13.         HashSet B=new HashSet();//B社团成员初始化
    14.         B.add("李四");
    15.         B.add("王五");
    16.         System.out.print("\nB社团成员有：");
    17.         Object []b=B.toArray();
    18.         for(int i=0;i
    19.             System.out.print(b[i]+" ");
    20.         B.retainAll(A);//求A社团和B社团的交集，求到的赋值给B
    21.         System.out.print("\n同时参加两个社团的人有：");
    22.         Object []c=B.toArray();
    23.         for(int i=0;i//输出同时参加两个社团的人
    24.             System.out.print(c[i]+" ");
    25.         System.out.println();
    26.     }
    27. }

    (7). 有10个国家，其属性有name、GDP2020和COVID19，分别表示国家名称、国际货币基金组织公布的2020年的国内生产总值（单位：百万美元）和网易新闻2021年10月7日公布的新冠肺炎累计确诊人数。10个国家的信息如下：

    1. package seven;
    2. import java.util.*;
    3. class country {//利用country存放每个国家的信息
    4.     String name;//国家名字
    5.     Integer GDP2020,COVID19;//2020年GDP、2019年确诊人数
    6.     public country(String name,int GDP2020,int COVID19){//有参构造初始化
    7.         this.name=name;
    8.         this.GDP2020=GDP2020;
    9.         this.COVID19=COVID19;
    10.     }
    11.     public String toString(){//格式化
    12.         return String.format("%-10s%s",name,"GDP2020:"+GDP2020+"COVID19"+COVID19);
    13.     }
    14. }
    15.  
    16. public class seven {
    17.     public static void main(String args[]){
    18.         Scanner input=new Scanner(System.in);
    19.         TreeMapmap=new TreeMap<>(new Comparator() {
    20.             public int compare(country c1,country c2){//重写compare
    21.                 return c1.COVID19.compareTo(c2.COVID19);//升序排序
    22.             }
    23.         });
    24.         for(int i=0;i<10;i++){
    25.             String name=input.next();
    26.             int GDP2020=input.nextInt();
    27.             int COVID19=input.nextInt();
    28.             map.put(new country(name,GDP2020,COVID19),COVID19);
    29.         }
    30.         for(country c:map.keySet())
    31.             System.out.println(c);
    32.     }
    33. }

    其他（例如感想、建议等等）。

    这次实验是做的时间最长的一次了，主要的困难在第六题，一开始我是想这正常输入的，但是使用while（input.hasNextLine()）时始终无法跳出循环，询问助教后也没有很好的解决方法，于是在助教的认同下先对文本进行处理后进行输入（删除换行符）。

  • 相关阅读:
    无聊的一篇博客（如何通过路由器登陆页对固定机器进行网速干扰，如何帮熊孩子戒网瘾）
    [算法周训 2]字符串训练1
    【SA8295P 源码分析 (一)】07 - XBL Loader 解析 sbl1_config_table 规则分析
    数据类型总结
    总结了30段极简的Python代码！(一)
    jsp儿童网站系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
    Unity游戏开发基础组件
    多数互联网人对2021年终奖不抱期待
    C++之static，静态变量
    算法提高： 二叉树算法题目大全
  • 原文地址：https://blog.csdn.net/weixin_62431082/article/details/127578584