java期末复习

最新推荐文章于 2024-06-28 18:39:41 发布
最新推荐文章于 2024-06-28 18:39:41 发布
阅读量746 收藏 8
点赞数 1
分类专栏： 资料 文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rose_never_soft/article/details/129089379
版权

1.小小ATM

题目：

* 自动取款机又称ATM(Automated Teller Machine的缩写)，它是一种高度精密的机电一体化装置，利用磁性代码卡或智能卡实现金融交易的自助服务，代替银行柜面人员的工作。持卡人可以使用信用卡或储蓄卡，根据密码办理自动取款、查询余额、转账、现金存款，存折补登，购买基金，更改密码，缴纳手机话费等业务。
* 请在start-end区域中填充代码，实现一个ATM取款机小程序，效果图如下：
* 欧迎使用中国人民银行ATM取款机
* 输入取款金额：100
* 900是否继续（’1’：结束，’2’：继续）：2
* 剩余金额：
* 输入取款金额：999
* 目前余额：900无法满足您的取款需求！
* 输入取款金额：100
* 剩余金额：800是否继续（’1’：结束，’2'：继续）：1取款结束！

练习模板：

import java.util.Scanner;
public class Main {
   public static void main(String[] args){
       int my_money = 1000;//定义一个变量保存我的金额
       int cash = 0;//定义一个变量保存我当下要取的金额
       int is_get_cash = 0;//定义一个变量保存我是否8继续取款的决定('1'：结束，'2'：继续)
       Scanner input = new Scanner(System.in);
       System.out.println("欢迎使用中国人民银行ATM取款机");
       do{
           /********start**********/

           /*********end**********/
      }while(my_money>0);
       System.out.println("取款结束！");
  }
}

参考答案：

/**
* 自动取款机又称ATM(AutomatedTeller Machine的缩写)，它是一种高度精密的机电一体化装置，利用磁性代码卡或智能卡实现金融交易的自助服务，代替银行柜面人员的工作。持卡人可以使用信用卡或储蓄卡，根据密码办理自动取款、查询余额、转账、现金存款，存折补登，购买基金，更改密码，缴纳手机话费等业务。
* 请在start-end区域中填充代码，实现一个ATM取款机小程序，效果图如下：
* 欧迎使用中国人民银行ATM取款机
* 输入取款金额：100
* 900是否继续（’1’：结束，’2’：继续）：2
* 剩余金额：
* 输入取款金额：999
* 目前余额：900无法满足您的取款需求！
* 输入取款金额：100
* 剩余金额：800是否继续（’1’：结束，’2'：继续）：1取款结束！
* */
import java.util.Scanner;
public class Main {
   public static void main(String[] args){
       int my_money = 1000;//定义一个变量保存我的金额
       int cash = 0;//定义一个变量保存我当下要取的金额
       int is_get_cash = 0;//定义一个变量保存我是否8继续取款的决定('1'：结束，'2'：继续)
       Scanner input = new Scanner(System.in);
       System.out.println("欢迎使用中国人民银行ATM取款机");
       do{
           /********start**********/
           System.out.println("请输入取款金额：");
           cash = input.nextInt();//存放取款金额
           //这里有两种情况，钱不够和钱够
           if(cash<=my_money){//钱够
               my_money-=cash;
               System.out.println("剩余金额："+my_money+"，是否继续：（‘1’：结束，‘2’：继续）");
               is_get_cash=input.nextInt();
               if(is_get_cash==1) break;//等于1跳出循环，取款结束
          }
           else{//钱不够
               System.out.println("目前余额："+my_money+"无法满足您的取款需求！");
          }
           /*********end**********/
      }while(my_money>0);
       System.out.println("取款结束！");
  }
}

这道题几乎没有涉及到什么特殊的知识点，你只要搞清楚取钱给钱的流程就够了，逻辑不要写反这题很容易。

2.算算最高分

题目：

Java面向对象程序设计作为计算机类学生的专业核心课程，
为后续学习操作系统、数据库原理与应用、软件工程、软件项目实训等课程奠定编程基础。因专业学生人数多故开设了多个课程班级，现需要对所有Java课程班级的成绩进行统计。
在start-end区域中填充代码，编写一个能计算所有Java课程班级的平均分和最高分的小程序。
输入说明
3表示班级数，4表示第一个班级人数，79，98，88，99为这4位学生的Java成绩；2表示第二个班级人数，87，85为这2位学生的Java成绩；4表示第三个班级人数，
67，78，89，69为这4位学生的Java成绩
输出说明
99.0是所有人的最高分，83.9是所有人的平均成绩

练习模板：

/*
* 题目描述
* 2 Java面向对象程序设计作为计算机类学生的专业核心课程
为后续学习操作系统、数据库原理与应用、软件工程、软件项目实训等课程奠定编程基础。因专业学生人数多故开设了多个课程班级，
* 现需要对所有Java课程班级的成绩进行统计。
在start-end区域中填充代码，编写一个能计算所有Java课程班级的平均分和最高分的小程序。
输入说明
3表示班级数，4表示第一个班级人数，79，98，88，99为这4位学生的Java成绩；2表示第二个班级人数，87，85为这2位学生的Java成绩；
4表示第三个班级人数，67，78，89，69为这4位学生的Java成绩
输出说明
99.0是所有人的最高分，83.9是所有人的平均成绩

*
* */
import java.util.Scanner;

public class Main{
   public static void main(String[] args){
       Scanner scanner = new Scanner(System.in);
       System.out.println("请输入班级数量");
       double[][] scores = new double[scanner.nextInt()][];//班级数就是二维数组行数
       for(int i=0;i<scores.length;i++){
           System.out.println("请输入第"+(i+1)+"个班级学生人数");
           /**********Begin**********/

           /**********End************/
           for(int j=0;j<scores[i].length;i++){
               System.out.println("请输入本班第"+(j+1)+"个学生的Java成绩：");
               /**********Begin**********/

               /**********End************/
          }
      }
       /**********Begin**********/
       
       /**********End************/
  }
}

参考答案：

/*
* 题目描述
* 2 Java面向对象程序设计作为计算机类学生的专业核心课程
为后续学习操作系统、数据库原理与应用、软件工程、软件项目实训等课程奠定编程基础。因专业学生人数多故开设了多个课程班级，
* 现需要对所有Java课程班级的成绩进行统计。
在start-end区域中填充代码，编写一个能计算所有Java课程班级的平均分和最高分的小程序。
输入说明
3表示班级数，4表示第一个班级人数，79，98，88，99为这4位学生的Java成绩；2表示第二个班级人数，87，85为这2位学生的Java成绩；
4表示第三个班级人数，67，78，89，69为这4位学生的Java成绩
输出说明
99.0是所有人的最高分，83.9是所有人的平均成绩

*
* */
import java.util.Scanner;

public class Main{
   public static void main(String[] args){
       Scanner scanner = new Scanner(System.in);
       System.out.println("请输入班级数量");
       double[][] scores = new double[scanner.nextInt()][];//班级数就是二维数组行数
       for(int i=0;i<scores.length;i++){
           System.out.println("请输入第"+(i+1)+"个班级学生人数");
           /**********Begin**********/
           scores[i]=new double[scanner.nextInt()];

           /**********End************/
           for(int j=0;j<scores[i].length;i++){
               System.out.println("请输入本班第"+(j+1)+"个学生的Java成绩：");
               /**********Begin**********/
               scores[i][j]=scanner.nextDouble();

               /**********End************/
          }
      }
       /**********Begin**********/
       double aver=0;
       double max=0;
       int num=0;
       for(int i=0;i<scores.length;i++){
           for(int j=0;j<scores[i].length;i++){
               if(max<scores[i][j])max=scores[i][j];
               aver+=scores[i][j];
               num++;
          }
      }
       aver=aver/num*1.0;
       System.out.println(max+"是所有人的最高分，"+aver+"是所有人的平均成绩");
       /**********End************/
  }
}

知识点梳理：

这个题主要考二维数组的应用。

double[][] scores = new double[scanner.nextInt()][];

先定义了二维数组的行数。

scores[i]=new double[scanner.nextInt()];

再定义二维数组的列数。

3.汪汪和喵喵

题目：

动物(CAnima) 是生物的一个种类。 它们一舰以有机物为食，是鲍够自主运动或相够活动的有感党的生物。人类也是动物之一。

根据化石研究地球上最早出现的动物源于海洋。早期的海洋动物经过澧长的地质时期。逐渐澳化出各种分支，丰富了早期的地球生命形态。在人类出现以前，史前动物便已出现，并在各自的活动期得到繁荣发展。后来，它们在不断支换的生存环境下相继灭绝。但是，地球上的动物仍以从低等到美等、从简单到這杂的趋势不断进化并繁行，并有了如今的多样性。

创建一个父类动物类(Animals) 。以及两个子类，分别是猫类(Cat) 和狗类(Dogl。动物类叫声为输出“叽里咕鲁”。猫类， 狗类分别发出叫声“唱有”，“注汪”，输入动物名，输出相应动物叫声，输出格式为动物名动物叫声。

父类有属性姓名(name)

在父类构造方法中对属生姓名附值。

在父类中定义getName0oshout（）用于获职动物的姓名信意以及输出动物的叫声。

猫和狗继承动物类，通过在子类构造方法中调用父类构造方法，分别构建描和狗对象。通过子类重写父类的shout0输出动物的叫声。

练习模板：

import  java.util.Scanner;
public class Main {
   public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      String animal = sc.next();
      switch(animal){
          case("dog"):{
              //创建Dog类对象dog，通过有参构造方法实例化该对象
              //shout()方法，输出”dog：汪汪“
              /*********begin************/
              
              /*********end**************/
          }
          case("cat"):{
              //创建Cat类对象cat，通过有参构造方法实例化该对象
              //shout()方法，输出”cat：喵喵“
              /*********begin************/
              
              /*********end**************/
          }
          default:{
              //创建Animal类对象animal，通过有参构造方法实例化该对象
              //shout()方法，输出”animal：叽里咕噜“
              /*********begin************/
              
              /*********end**************/
          }
      }
  }
}
//父类Animals 封装私有属性name
//有参构造方法初始化name
//属性的get方法
//shout方法，输出”叽里咕噜“
class Animals{
   /*************begin************/
  
   /**********end****************/
}

//Dog继承自Animal类
//有参构造方法初始化name
//重写父类shout()方法
class Dog extends Animals{
   /**********begin*************/
 
   /**********end**************/
}

//Cat继承自Animals类
//有参构造方法初始化name
//重写父类shout()方法

class Cat extends Animals{
   /***********begin*************/
 
   /*************end**************/
}

参考答案：

import  java.util.Scanner;
public class Main {
   public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      String animal = sc.next();
      switch(animal){
          case("dog"):{
              //创建Dog类对象dog，通过有参构造方法实例化该对象
              //shout()方法，输出”dog：汪汪“
              /*********begin************/
              Dog dog = new Dog(animal);
              dog.get();
              dog.shout();
              break;
              /*********end**************/
          }
          case("cat"):{
              //创建Cat类对象cat，通过有参构造方法实例化该对象
              //shout()方法，输出”cat：喵喵“
              /*********begin************/
              Cat cat = new Cat(animal);
              cat.get();
              cat.shout();
              break;
              /*********end**************/
          }
          default:{
              //创建Animal类对象animal，通过有参构造方法实例化该对象
              //shout()方法，输出”animal：叽里咕噜“
              /*********begin************/
              Animals animals = new Animals(animal);
              animals.get();
              animals.shout();
              break;
              /*********end**************/
          }
      }
  }
}
//父类Animals 封装私有属性name
//有参构造方法初始化name
//属性的get方法
//shout方法，输出”叽里咕噜“
class Animals{
   /*************begin************/
   private String name;
   Animals(String name){
       this.name=name;
  }
   public void get(){
       System.out.print(name+":");
  }
   public void shout(){
       System.out.println("叽里咕噜");
  }
   /**********end****************/
}

//Dog继承自Animal类
//有参构造方法初始化name
//重写父类shout()方法
class Dog extends Animals{
   /**********begin*************/
   String name;
   Dog(String name) {
       super(name);
  }
   public void shout(){
       System.out.println("汪汪");
  }
   /**********end**************/
}

//Cat继承自Animals类
//有参构造方法初始化name
//重写父类shout()方法

class Cat extends Animals{
   /***********begin*************/
   String name;
   Cat(String name) {
       super(name);
  }
   public void shout(){
       System.out.println("喵喵");
  }
   /*************end**************/
}

知识点梳理：

这道题考的是继承，继承其实算比较简单好理解的了，子类继承父类所有方法和属性，并且可以在子类中重写父类中的方法，你也可以理解成if的嵌套，他们在逻辑上有些相似。

其他语法自己看书，这里给你写几个需要注意的点：

  • 创建类的对象

  • 在创建类的对象时要分清到底要创建的是哪个类，例如这个题中，case==“dog”时，我们就需要创建animal类的子类Dog，因为我们最终要调用dog重写的shout方法。

  • 封装属性

  • 封装属性的大白话就是将一个类里所有要用的东西写在这个类里面，你可以理解成你想要做一件事，你需要事先准备好所有你要的东西，然后把他们装进背包。那么这个背包就是类，而那些“东西”就是你需要封装的属性。

  • super关键字

  • 子类不继承父类的构造方法，如果想要使用就要在子类的构造方法里使用super关键字，super必须是子类构造方法中的第一条语句。

  • 在调用时，父类可能有多个构造方法，但他们的构造方法的参数一定不一样，认准你要调用的构造方法的参数。例如父类中：

class Father{
String name;
int age;
String occupation;
Father(String name,int age,String occupation){
   this.name=name;
   this.age=age;
   this.occupation=occupation;
}
Father(){
   System.out.println("woshinibaba");
}
}

class Son extends Father{
   Son(String name,int age,String occupation){
       super(name,age,occupation);//参数一定对应
  }
   Son(){
       super();
  }
}

  • this关键字

String name;
int age;
String occupation;
Father(String name,int age,String occupation){
   this.name=name;
   this.age=age;
   this.occupation=occupation;
}

这个就很好理解，我先声明了我这个类里有三个属性，我们写一个构造方法，使得在创建这个对象的时候就可以直接为这三个属性赋值 ，this.name就可以理解为指向，this.name代表的是第一行这个name，=后面的name就是构造方法传值传进来的name，我们用传进来的值为对象的name属性赋值。

PS：还看不懂记下来就完事了，好像就这么多知识点了。

4.天选读书打工人

题目：

/**

* 学生，一般指正在学校、学堂或其他学习地方受教育的人，根据学习的不同阶段，我们可以把学生分为：幼儿园学生、小学生、中学生、高等院校学生(大学生、硕士研究生、博士研究生)等等。学生是一种身份的名词，具有学籍的人都统称学生。

* 工人，通常是指为挣工资而被雇用从事体力或技术劳动的人，他们本身不占有生产资料，只能通过自己的劳动才能获得工资性质的收入。工人一般指工厂中生产工序的人，除了工厂的管理者外，都称为工人。如：操作工人、搬运工人等。

*

* 声明一个名为Person的抽象类，在Person类中声明了三个属性姓名name、年龄age和职业occupation和一个返回String的抽象方法talk()；

* 声明一个Student类和一个Worker类，都继承自Person类，添加含有三个参数的构造方法

* 分别实例化Student类和Worker类，分别调用各自类中被复写的talk()方法打印输出信息；

* 输入：

* 张三 20 学生

* 李四 30 工人

* 输出：

* 学生————>姓名：张三，年龄：20，职业：学生！

* 工人————>姓名：李四，年龄：30，职业：工人！

*/

练习模板：

import java.util.Scanner;
public class Main {
   public static void main(String[] args){
       Scanner sc = new Scanner(System.in);
       String stuName=sc.next();
       int stuAge=sc.nextInt();
       String stuOccupation=sc.next();
       String worName=sc.next();
       int worAge=sc.nextInt();
       String worOccupation=sc.next();
       /************begin************/
       //分别实例化Student类和Worker类的对象，并调用各自的构造方法初始化类属性
      
       //分别调用各自类中被复写的talk()方法 打印信息
  
       /***********end**************/
  }
}

//声明一个名为Person的类，在Person类中声明了三个属性name,age,occupation和一个抽象方法——talk()
abstract class Person{
   /*********begin*************/

   /***********end*************/
}
//Student类继承自Person，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息（“学生————>姓名:name，年龄：age，职业：occupation!")
class Student extends Person{
   /*********begin***********/
  
   /*********end*************/
}
//Worker类继承自Person，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息（“学生————>姓名:name，年龄：age，职业：occupation!")
class Worker extends Person{
   /***********begin*********/
   
   /**********end***********/
}

参考答案：

import java.util.Scanner;
public class Main {
   public static void main(String[] args){
       Scanner sc = new Scanner(System.in);
       String stuName=sc.next();
       int stuAge=sc.nextInt();
       String stuOccupation=sc.next();
       String worName=sc.next();
       int worAge=sc.nextInt();
       String worOccupation=sc.next();
       /************begin************/
       //分别实例化Student类和Worker类的对象，并调用各自的构造方法初始化类属性
       Student student = new Student(stuName,stuAge,stuOccupation);
       Worker worker = new Worker(worName,worAge,worOccupation);
       //分别调用各自类中被复写的talk()方法 打印信息
       System.out.println(student.talk());
       System.out.println(worker.talk());

       /***********end**************/
  }
}

//声明一个名为Person的类，在Person类中声明了三个属性name,age,occupation和一个抽象方法——talk()
abstract class Person{
   /*********begin*************/
   String name;
   int age;
   String occupation;
   abstract String talk();
   /***********end*************/
}
//Student类继承自Person，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息（“学生————>姓名:name，年龄：age，职业：occupation!")
class Student extends Person{
   /*********begin***********/
   Student(String name,int age,String occupation){
       this.name=name;
       this.age=age;
       this.occupation=occupation;
  }
   String talk(){
       return "学生————>姓名："+name+"，年龄："+age+"，职业："+occupation+"!";
  }
   /*********end*************/
}
//Worker类继承自Person，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息（“学生————>姓名:name，年龄：age，职业：occupation!")
class Worker extends Person{
   /***********begin*********/
   Worker(String name,int age,String occupation){
       this.name=name;
       this.age=age;
       this.occupation=occupation;
  }
   String talk(){
       return "工人————>姓名："+name+"，年龄："+age+"，职业："+occupation+"!";
  }
   /**********end***********/
}

这个也类似，应该都能做出来。

5.字符串小裁缝

题目：

拼接字符串

从键盘输入多个字符串，然后将其拼接成为一个字符串并输出，字符串之间用“”隔开，输入"!”则表示输入结束输入说明

第一次输入hello，第二次输入world，第三次输入!输出说明

结果是hello world

输入示例

hello world!

输出示例

hello world

练习模板：

import java.io.*;
import java.util.Scanner;
public class Main {
   public static void main(String[] args) throws IOException{
       String str;
       Scanner scanner =new Scanner(System.in);
       StringBuilder sb = new StringBuilder();
       /************begin****************/
      
       /************End******************/
       System.out.println(sb);
  }
}

参考答案：(常规做法)

/*
* 拼接字符串
从键盘输入多个字符串，然后将其拼接成为一个字符串并输出，字符串之间用“”隔开，输入"!”则表示输入结束输入说明
第一次输入hello，第二次输入world，第三次输入!输出说明
结果是hello world
输入示例
hello world!
输出示例
hello world
*
* */
import java.io.*;
import java.util.Scanner;
public class Main {
   public static void main(String[] args) throws IOException{
       String str;
       Scanner scanner =new Scanner(System.in);
       StringBuilder sb = new StringBuilder();
       /************begin****************/
       str=scanner.next();
       while(str.equals("!")==false){
           sb.append(str);
           sb.append(" ");
           str= scanner.next();
      }
       /************End******************/
       System.out.println(sb);
  }
}

（另辟蹊径法）

import java.io.*;
import java.util.Scanner;
public class Main {
   public static void main(String[] args) throws IOException{
       String str;
       Scanner scanner =new Scanner(System.in);
       StringBuilder sb = new StringBuilder();
       String sbb="";
       /************begin****************/
       str=scanner.next();
       while(str.equals("!")==false){
           sbb=sbb+str+" ";
           str= scanner.next();
      }
       /************End******************/
       System.out.println(sbb);
  }
}

这个没什么知识点，就是简单的String类的方法调用。

6.字符串换换换

题目：

字符串计数替换

题目：因为绝大部分计算机都应用于数据处理，所以字符串在程序设计中具有非常重要的地位，许多程序设计语言都增加了对字符串处理的函数或者方法，便于实现对字符串进行统计、排序、解析、截取、反转等操作。

从控制台输入字符串strall“5月1号劳动节，6月1号儿童节，7月1号建党节，8月1号建军节，10月1号国庆节”，统计strall中“号”的次数并输出；输入替换字符串str1，然后将字符串strall中的“号”替换成str1，并输出strall。

请在Begin-End间补齐代码，完成功能。

可以使用提示函数完成。

提示：正则表达式中，\s表示空白，^表集合求反；+表示重复1次及以上

函数提示：

*public String replaceAll(String regex,String replacement)

功能：用给定的字符串replacement替换与给定的正则表达式regex匹配的此字符串的每个子字符串

* public String trim()

功能：返回一个字符串，其值为此字符串，删除任何前导和尾随空格。

* public String， split(Stringregex)

功能：将此字符串拆分为给定的regular expression匹配的字符串数组。

输入示例；

5月1号穿动节，6月1号儿童节，7月1号建党节，8月1号建军节，10月1号国庆节日

5 5月1日劳动节，6月1日儿童节，7月1日建党节，8月1日建军节，10月1日国庆节

练习模板：

import java.util.Scanner;
public class Main {
   public static void main(String[] args) {
       String strall,str1,reg;
       Scanner sc = new Scanner(System.in);
       strall = sc.next();
       str1 = sc.next();
       /**************begin************/
       
       
       /***************end*************/
  }
}

参考答案：(这题感觉有好多种做法，因为当时不会正则表达式，所以用的下面这种string自带函数做的)

import java.util.Scanner;
public class Main {
   public static void main(String[] args) {
       String strall,str1,reg;
       Scanner sc = new Scanner(System.in);
       strall = sc.next();
       str1 = sc.next();
       /**************begin************/
       int num=0;//用来计数
       for(int i=0;i<strall.length();i++){
           char ch = strall.charAt(i);
           if(ch=='号') num++;//出现一次计数一次
      }
       System.out.println(num);
       System.out.println(strall.replace("号",str1));

       /***************end*************/
  }
}

正则表达式做法：(讲实话，根本看不懂)

import java.util.Scanner;
public class Main {
   public static void main(String[] args) {
       String strall,str1,reg;
       Scanner sc = new Scanner(System.in);
       strall = sc.next();
       str1 = sc.next();
       /**************begin************/
       //正则表达式法
       reg = "[^号]";
       String strall1;
       strall1 = strall.replaceAll(reg," ");
       strall1 = strall1.trim();
       String[] strArr = strall1.split("\\s+");
       
       System.out.println(strArr.length);
       strall = strall.replaceAll("号",str1);
       System.out.println(strall);

       /***************end*************/
  }
}

这里很明显的字符串有关的知识点，有几个字符串相关的函数比较常用：

//replace函数

函数解释：将某个字符串的某个字符（oldchar)全部替换成另一个字符（newchar).

使用：string1=string.replace(String oldchar,String newchar);

//replaceAll函数

函数解释：*public String replaceAll(String regex,String replacement)

功能：用给定的字符串replacement替换与给定的正则表达式regex匹配的此字符串的每个子字符串

//trim函数

public String trim0

功能：返回一个字符串，其值为此字符串，删除任何前导和尾随空格。

//split函数

这是最基础的函数

* public String split(String regex)

功能：将此字符串拆分为给定的regular expression匹配的字符串数组。

-->正则表达式

正则表达式可以校验字符串是否满足一定的规则，并用来校验数据格式的合法性。

需求：假如现在要求校验一个qq号码是否正确。

规则：6位及20位之内，0不能再开头，必须全部是数字。

用正则表达式

String qq ="123456789";

System.out.println(qq.match("[1-9]\\d{5,19}"));

在这之中[1-9]表示第一个数只能是1-9，\\d表示多个数，{5，19}表示除第一个数5-19位。

作用：

  • 作用一：校验字符串是否满足规则

  • 作用二：在一段文本中查找满足要求的内容

（来自黑马程序员）黑马程序员Java零基础视频教程_上部(Java入门，含斯坦福大学练习题+力扣算法题+大厂java面试题）_哔哩哔哩_bilibili

总结：【】表示自己规定范围,\什么什么表示已有的几种规定

接下来是代码练习：

注意：在写正则表达式时要从左向右依次去写。

public class Main {
   public static void main(String[] args) {
     //验证座机电话号码
       //020-2324242 027-42424 0712-3242434
       //第一部分 0开头的区号 0就表示是0开头的
           //0之后就是2到3位数字 \\d表示是数字{2，3}表示两到三位 -->合起来就是两到三位数字
       //第二部分 -     ?次数0或1次
       //第三部分 号码   第一位不能以0开头，从第二位可以是任意的数字，号码总长度5-10位
       String regex = "0\\d{2,3}-?\\d{4,9}";
       System.out.println("020-2324242".matches(regex));//true
       System.out.println("027-42424".matches(regex));//true
       System.out.println("0712-3242434".matches(regex));//true
       System.out.println("1777-687699".matches(regex));//false
  }

}

在了解了正则表达式做法后，我对正则表达式做法写了注释。

//正则表达式法

reg = "[^号]"; //除了 “号”

String strall1;

strall1 = strall.replaceAll(reg," ");//将除了“号”的全部替换成“ ”

strall1 = strall1.trim();//头尾空格全部删除

String[] strArr = strall1.split("\\s+");//空白字符切割，就得到几个“号”

System.out.println(strArr.length);

strall = strall.replaceAll("号",str1); //将所有“号”替换成str1

System.out.println(strall);

看懂之后突然觉得，也就那样，还不如用数组计数法ὠ0。

7.阳光开朗字符串

题目：

字符串数值解析求和

因为绝大部分计算机都应用于数据处理，所以字符串在程序设计中具有非常重要的地位，许多程序设计语言都增加了对字符串处理的函数或者方法，便于实现对字符串进行统计、排序、解析、截取、反转等操作。

从控制台输入字符串“早餐10.5元，中餐20.2元，晚餐12.9元”，对字符串进行解析获得字符串中的金额，求和并保留2位小数输出。请在Begin-End间补齐代码，完成功能。

可以使用提示方法完成。

提示：正则表达式中，+表示重复1次及以上，*表示重复0次及以上，？表示重复0次或1次

函数提示：

★public static Pattern compile(Stringregex) 功能：模式类的方法，将给定的正则表达式编译为模式，获得一个模式对象

★public Matcher matcher(CharSequenceinput)功能：模式对象的方法，创建一个匹配器/匹配对象，匹配给定的输入与此模式。input为需要分析的输入字符串

练习模板：

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
   public static void main(String[] args) {
       String str,reg;
       Scanner scan = new Scanner(System.in);
       str = scan.next();

       /************begin*********/
       

       /***********end***********/
  }
}

参考答案：

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
   public static void main(String[] args) {
       String str,reg;
       Scanner scan = new Scanner(System.in);
       str = scan.next();

       /************begin*********/
       reg = "\\d+.?\\d*";   \\d表示一个数字，+表示一个或多个，这两个合起来表示多少元；. ?表示0个或一个.;\\d*表示0个或多个数字，表示几角几分
       Pattern p = Pattern.compile(reg);//创建一个模式对象，将给定的正则表达式编译为模式
       Matcher m =p.matcher(str);//模式对象的方法，将str解析为只包含符合正则表达式
       double s=0;
       while(m.find()){
           s = s+Double.parseDouble(m.group());
      }
       System.out.printf("%.2f",s);

       /***********end***********/
  }
}

知识点解析：

  1. 正则表达式，不懂去看第二题

  1. 模式类：

在帮助文档中获得资料表示：

  • 正则表达式的编译表示。

必须首先将正则表达式（指定为字符串）编译为此类的实例。 然后将所得的图案可以被用来创建一个Matcher对象可以匹配任意character sequences针对正则表达式。 执行匹配的所有状态都驻留在匹配器中，所以许多匹配者可以共享相同的模式。

  • 因此，典型的调用序列

Pattern p = Pattern.compile("a*b");//编写实例

Matcher m = p.matcher("aaaaab");//创建matcher对象来匹配"aaaaab"

boolean b = m.matches();//

  • 这个类定义了一个matches方法，以便在正则表达式只使用一次时方便。 该方法编译一个表达式，并在单个调用中匹配输入序列。 该声明

boolean b = Pattern.matches("a*b", "aaaaab");

相当于上面的三个语句，尽管对于重复匹配，它的效率较低，因为它不允许编译的模式被重用。

这个类的实例是不可变的，可以安全地被多个并发线程使用。 该实例Matcher类不适合这样的使用是安全的。

看到这里不懂没关系，因为我也看不懂，接下来可以看看我的大白话。ᾒd

看到这题的时候，我的第一反应是用字符串遍历把数字抠出来然后相加，后来发现在String中不管是数字，点都是以单个的字符存在的，所以把数字抠出来这种简单粗暴的做法显然有些耗费时间。

那么就要采取正则表达式的做法，把字符串里与正则表达式相匹配的一串抠出来，而这种做法Java专门提供了用来进行匹配模式的Pattern类和Matcher类，具体操作方法如下：

  • 得到Pattern对象

使用正则表达式regex作为参数得到一个称为模式的Pattern类的实例pattern.

String regex = "\\d+.?\\d*";

Pattern pattern = Pattern.compile(regex);

  • 得到Matcher对象

Matcher matcher = pattern.matcher(str);

  • 进行了如上两个步骤，就可以用matcher对象来调用各种匹配模式的方法

  • public boolean find()//寻找str中与regex相匹配的下一子序列，成功返回true，否则返回false.
    //每次寻找会从上一次找到的子序列往后查找

  • public String group()//返回一个String对象，该对象的字符序列是find方法在str中找到的匹配regex的子字符序列

看到这儿再回去看上面的代码，应该就能理解这个是怎么做的了吧。

可能还有一个地方不懂，

Double.parseDouble(m.group());

因为我们抠出来的其实是一个字符串，相加的话需要先把他转化成double 类型。这个就是固定写法，记住就好啦。

同时还有String转int，String转float：

int num4 = Integer.parseInt(str1);

float float1 =Float.parseFloat(str2);

int转String，double转String，float转String：

int i = 10;

double d = 12.34;

float f = 3.2;

String si = Integer.toString(i);

String di = Double.toString(d);

String fi = String.valueOf(f);

8.HashMap集合大法好

题目：

输入示例:

王晓红：24，赵彩：24，王春桃：22

输出示例：

{王晓红=24,赵彩=24,王春桃=22}

练习模板：

public class Main {
   public static void main(String[] args) {
      /******* Begin *******/
       //第一步:接收给定字符串
       
       //第二步:切割花名册
       
       //第三步:创建HashMap集合,key为姓名, value 为年龄
       
       // 第四步:添加数据到集合中
       
       //第五步:打印集合
       
       /******** End *******/
  }
}

参考答案：

import java.util.HashMap;
import java.util.Scanner;
import java.util.*;
public class Main {
   public static void main(String[] args) {
      /******* Begin *******/
       //第一步:接收给定字符串
       Scanner sc = new Scanner(System.in);
       String line = sc.nextLine();
       //第二步:切割花名册
       String[] str = line.split("，");
       //第三步:创建HashMap集合,key为姓名, value 为年龄
       Map<String,String> map = new HashMap<>();
       // 第四步:添加数据到集合中
       for(String s:str){
           String[] s1 =s.split("：");
           map.put(s1[0],s1[1]);
      }
       //第五步:打印集合
       System.out.println(map);
       /******** End *******/
  }
}

知识点梳理：

这题的知识点其实好少，大致理一下：

  • 字符串操作这个都很简单，自己看吧。

  • HashMap<K,V>泛型类：

  • 泛型：你可以单纯的理解为他暂时是没有属性的，等着你去规定。

  • HashMap<K,V>泛型类创建的对象称作散列映射，如：

  • HashMap<String,Student> hashtable=HashMap<String,Student> ();

  • 其中，hashtable就可以存储“键/值”对数据，其中的键必须是一个String对象，键对应的值必须是Student对象。

  • hashtable可以调用public V put(K key,V value)将“键/值”对数据存放到散列映射中，该方法同时返回键所对应的值。(K和V是一种类型，看作int之类的)

  • hashmap的基本解释，hashmap其实就是哈希表，他的数据结构是数组+链表。

  • HashMap 数据结构为 *数组+链表*，其中：链表的节点存储的是一个 Entry 对象，每个Entry 对象存储四个属性（hash，key，value，next），看不懂的话没关系，看下面这个图

  • SHAPE \* MERGEFORMAT

  • 大致了解之后，只需要记住他的常用方法:

  • put方法：put(key，value)，我们经常用存储一些常用的数据，比如flag、百分比之类的，我们就可以返回map结构，如果key相同则值会覆盖，允许key和value为null。

  • get方法：get(key)，主要用来取map中存储的数据，我们根据其key值，可以取到对应的value值，没有该key对应的值则返回null。

  • remove方法：remove(key)，主要用来删除map中对应的key及其value值。

  • clear方法，用法：clear()，会清空map中的数据。

  • containsKey(key)，判断map集合中是否包含某个key。

  • containsKey(value)，判断map集合中是否包含某个value。

for(String s:str){

System.out.println(s+" ");

}

同样，也可以通过for循环遍历：

for (int i = 0; i < str.length(); i++) {

System.out.println(str.charAt(i));

}

除此之外，还有一种很常用的利用下标索引遍历：

for (int i = 0; i < str.length(); i++) {

System.out.println(str.substring(i, i + 1));

}

但是相比之下，前两种更加实用也更加好理解。

9.喜欢hello的HashSet

题目：

HashSet是为了快速查找而设计的Set,请使用HashSet常用方

法完成以下需求，

* 1.接收给定的一行字符串(如：hello,hi,ask)；

* 2.根据英文逗号切割字符串，把切割后的元素加进HashSet；

* 3.判断集合中元素个数，当个数大于4，且集合中没有元素 hello 时，往集合中添加元素hello，

* 如果集合中已有元素 hello，请输出提示语句：“集合中已有该元素”，

* 当个数小于等于 4时，请输出提示语句：“元素个数小于4”；

* 4.打印集合。

练习模板：

/*
* HashSet是为了快速查找而设计的Set,请使用HashSet常用方
法完成以下需求，
* 1.接收给定的一行字符串(如：hello,hi,ask)；
* 2.根据英文逗号切割字符串，把切割后的元素加进HashSet；
* 3.判断集合中元素个数，当个数大于4，且集合中没有元素 hello 时，往集合中添加元素hello，
* 如果集合中已有元素 hello，请输出提示语句：“集合中已有该元素”，
* 当个数小于等于 4时，请输出提示语句：“元素个数小于4”；
* 4.打印集合。
**/
import java.util.Scanner;
import java.util.HashSet;
import java.util.Set;

public class Main {
   public static void main(String[] args){
       //第一步：接受给定的字符串

       //第二步：切割字符串

       //第三步：创建集合

       //第四步：将切割后的元素添加进集合

       //第五步：判断集合中的元素个数是否大于4

           //第六步：当元素个数大于4，且元素中含有hello时，输出指定语
     
           
           //第七步：当元素个数大于四，且元素中不含hello时，往集合中添加hello
     
       //第八步：当元素个数小于4时，输出指定语
  
       //第九步：打印集合

  }
}

参考答案：

/*
* HashSet是为了快速查找而设计的Set,请使用HashSet常用方
法完成以下需求，
* 1.接收给定的一行字符串(如：hello,hi,ask)；
* 2.根据英文逗号切割字符串，把切割后的元素加进HashSet；
* 3.判断集合中元素个数，当个数大于4，且集合中没有元素 hello 时，往集合中添加元素hello，
* 如果集合中已有元素 hello，请输出提示语句：“集合中已有该元素”，
* 当个数小于等于 4时，请输出提示语句：“元素个数小于4”；
* 4.打印集合。
**/
import java.util.Scanner;
import java.util.HashSet;
import java.util.Set;

public class Main {
   public static void main(String[] args){
       //第一步：接受给定的字符串
       Scanner sc =new Scanner(System.in);
       String line = sc.nextLine();
       //第二步：切割字符串
       String[] str=line.split(",");
       //第三步：创建集合
       HashSet<String> hs = new HashSet<String>();
       //第四步：将切割后的元素添加进集合
       for(int i=0;i< str.length;i++){
           hs.add(str[i]);
      }
       //第五步：判断集合中的元素个数是否大于4
       if(hs.size()>4) {
           //第六步：当元素个数大于4，且元素中含有hello时，输出指定语
           if(hs.contains("hello"))
               System.out.println("集合中已有该元素");
           //第七步：当元素个数大于四，且元素中不含hello时，往集合中添加hello
           else hs.add("hello");
      }
       //第八步：当元素个数小于4时，输出指定语
       else{
           System.out.println("元素个数小于4");
      }
       //第九步：打印集合
       System.out.println(hs);
  }
}

这个也没什么好说的，单纯的记得方法都能做得出来。

不要再掉头发啦！
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA期末复习
09-10
JAVA期末复习
java期末复习 (1)
12-18
根据给定的信息，我们可以从标题、描述以及部分内容中提取出一系列重要的Java知识点： ### Java语言基础知识 #### 静态成员 1. **概念**：如果类中的成员使用了`static`修饰，则称该成员为静态成员。静态成员属于...
Java期末复习
weixin_54217081的博客
12-13 720
1.Java语言中的8种基本数据类型 2.方法重载 3.方法重写/覆盖 4.容器 5.事件 6.事件源 7.事件监听器 8.GUI事件监听步骤
Java部分复习笔记整理
最新发布
Gou_Hao_Liang的博客
06-28 717
创建和删除数据库表结构的语言常用语句：create ，alter，drop，rename。创建表的步骤：1.确定表名，2.确定列名，
Java8新特性(三) Optional与NullPointerException
戏流年的博客
04-08 1937
导航 引例 Optional 容器类 有值状态与无值状态 三种方法创建Optional对象 Optional操作详解 取值 isPresent和ifPresent filter、map、flatMap 注意点 引例 说起NullPointerException你肯定不会陌生，因为它大概是我们日常开发中碰到最多的问题。为了避免空指针异常的出现，我们常常需要做很多的逻辑判断。下...
【专题】Java期末复习资料
Pqf18064375973的博客
06-08 347
Java 是从C++演变而来的，它消除了许多难以理解和令人困惑的功能，同时继承了C++的大部分语法规则，因此易于使用。例如，自动垃圾。当程序创建对象时，需要分配内存，使用后销毁对象，Java将为程序员完成任务。Java是一种面向对象的语言，它结合了面向对象语言的各种特征，例如封装，继承和多态性。可移植性是指程序在不更改程序源代码的情况下在任何平台上运行的能力。仅仅因为Java字节码的平台独立性，Java程序可以移植到任何支持JVM的平台。
JAVA期末复习知识点整理（一）.doc
12-05
在提供的文件【标题】"JAVA期末复习知识点整理（一）.doc"中，我们首先看到的是一个简单的Java应用程序的结构，它演示了如何创建和运行一个Java程序。 1. **程序结构**： - **package** 语句：这是用来组织代码的...
Java期末复习题目 Java期末复习题目 Java期末复习题目
06-25
Java期末复习题目 Java是当前最流行的编程语言之一，广泛应用于Android应用开发、Web开发、企业软件开发等领域。为了帮助学习者更好地掌握Java编程语言，以下是Java期末复习题目的详细知识点总结。 数据类型关键字...
java期末复习试题.doc
09-30
根据提供的文件信息，我们可以从中提炼出一系列与Java编程语言相关的知识点。下面将对这些知识点进行详细的解释和扩展。 ### 1. Java 文件的基本结构 **知识点：** - **Java源程序文件扩展名:** Java源程序文件...
java期末复习资料
01-05
package chap01; public class chap061 { private static int a=0,b=2,c=7,d=4,e=5; static int shuzu[]={b,a,e,d,c}; int max(int a,int b) { return a>b?a:b; } public static void main(String[] args) { // TODO 自动生成方法存根 chap061 cp=new chap061(); int x; for(int i=0;i<shuzu.length-1;i++){ for(int j=0;j<shuzu.length-1;j++) { if(cp.max(shuzu[j],shuzu[j+1])==shuzu[j]) { x = shuzu[j]; shuzu[j] = shuzu[j+1]; shuzu[j+1] = x; } } } System.out.println("最小:"+shuzu[0]); System.out.println("最小:"+shuzu[4]); } }
Java期末复习资料_第1章_Java入门_.pdf
05-18
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征
java期末复习题
07-04
《java程序设计》期末考试试题。跟考试的极其相似哟！
Java期末复习题
09-10
复习重点 面向对象程序设计复习题 一、单选 1．对象是构成现实世界的一个独立单位，它具有自己的静态特征和（ ）特征。 A. 颜色 B. 动态 C. 状态 D. 重量 3．Java语言的主要特点不包括（ ）。 A. 面向对象 B. 自动垃圾回收 C. 处理文件 D. 可移植性 4. 具有相同属性和服务的一组对象的模板称为（ ）。 A. 程序 B. 类 C. 代码 D. 概念 5．组成Java程序的最小单位是（ ）。 A. 类 B. 方法 C. 变量 D. 常量
Java期末复习题 Java 期末 复习题
05-28
Java 期末 复习题 Java 期末 复习题 Java 期末 复习题 Java 期末 复习题 Java 期末 复习题 Java 期末 复习题
java 期末复习
葉蕖的博客
01-05 1017
知识点总结： Java基础知识总结 Java知识点汇总 Java基础知识总结（博客园） 百度文库： https://wenku.baidu.com/view/49e237dbdb38376baf1ffc4ffe4733687e21fccb.html
Java·期末复习
居贝比的博客
06-17 492
第一章 java中的数据类型：简单类型和复合类型： 简单数据类型包括： 整数类型：byte（8位）， short， int， long（64位） (都是有符号类型) 　 浮点类型：float，double 　 字符类型：char （16位，使用Unicode字符集） 　 布尔类型：boolean （C++ 的布尔类型是...
Java期末复习：核心知识点与编程题解析
"Java期末复习题" 以下是针对Java期末复习题的详细知识点解析： 1、在Java中不属于整型变量的是（C、double） Java的整型变量包括：byte, short, int, 和 long，而double是浮点型变量。 2、以下变量声明正确的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值