首页 > 其他分享 >pta总结

pta总结

时间：2023-04-01 20:37:24浏览次数：37  
标签：总结 String int System pta else public out

本三次题目知识点很多，运用了多种方法，需要我们掌握各种语法的作用，以及慢函数哦，设计对象啊！等等，很多很多Java语言是强类型语言，对于每一种数据都定义了明确的具体的数据类型，在内存中分配了不同大小的内存空间这也就要求我们软件工程师要不断地学习，

在 Java 5 以前，switch(expr)中，expr 只能是 byte、short、char、int。从 Java5 开始，Java 中引入了枚举类型，expr 也可以是 enum 类型，从 Java 7 开始，expr 还可以是字符串（String）

建立终生学习的学习目标。题量适中，难度也适中，知识点较多，对于中等学生来说较为适合，但是对正则表达式还是有一定困难，许多关于正则表达式的题目无从下手，题目大多为十天期限，对提高写作业效率有较大帮助，在写程序时问题出现较多，常常需要花大量时间来调试，对写程序的效率有较大的影响，常常要两三个小时来完成作业，这也就导致了有时实验报告无法按时提交的情况，但是在写程序的过程中，能让我学到更多知识，无论是上网查询到的知识还是同学告诉的知识，都使我不断地获取新知识，使我受益匪浅，在与他人交流题目的过程，也是增长我与他人交流能力的过程，对于今后的发张也有着至关重要的作用，在想算法的时候，也锻炼了我的思维能力，对我今后对各个事情的思考也有很大帮助。

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
double s=scanner.nextDouble();
double h=scanner.nextDouble();
double b=s/(h*h);
if(s<=0||s>727)
System.out.println("input out of range");
else if(h>2.72||h<=0)
System.out.println("input out of range");
else if(b<18.5)
System.out.println("thin");
else if(b>=18.5&&b<24)
System.out.println("fit");
else if(b>=24&&b<28)
System.out.println("overweight");
else
System.out.println("fat");
}
}

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
double s=scanner.nextDouble();
double h=scanner.nextDouble();
s=s/0.45359237;
h=h/0.0254;
System.out.printf((float)s+" "+(float)h);

}
}

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
int a,b=0;
for(int i=0;i<10;i++) {
a=scanner.nextInt();
if(a%2==1||a%2==-1)
b=b+a;

}
System.out.println(b);
}
}

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
int b=scanner.nextInt();
int c=scanner.nextInt();
double d=scanner.nextDouble();
double f=0,j=0,h=0,e=0;
if(a==1){
if(d<=90){
e=(100*c);}
else if(90<d&&d<=144){
e=(100*c)*1.5;}
else if(d>144){
e=(100*c)*3;}
}
else if(a>1){
e=(100*c)*3;
}
f=b*5;
j=3*d;
h=1.36*d;
System.out.print((float)e+" "+(float)f+" "+(float)j+" "+(float)h);
}
}

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
int b=scanner.nextInt();
String cc,dd;
if(a==1){
cc="人类";}
else if(a==2){
cc="精灵";
}
else if(a==3){
cc="兽人";
}
else if(a==4){
cc="暗精灵";
}else{
System.out.println("Wrong Format");
return;}
if(b==1){
dd="战士";
}
else if(b==2){
dd="法师";
}
else if(b==3){
dd="射手";
}
else{
System.out.println("Wrong Format");
return;}
System.out.print(cc+" "+dd);
}
}

 

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
String abc = scanner.next();
String xue = "";
if(abc.length()!=8){
System.out.println("Wrong Format");
}
else{
String year = abc.substring(0, 2);
String id = abc.substring(6);
String xueyuan = abc.substring(2,4);
String Class = abc.substring(4,6);
if(xueyuan.equals("01")||xueyuan.equals("02")||xueyuan.equals("03")||xueyuan.equals("20"))
{
switch(xueyuan){
case "01":
xue = "材料学院";
break;
case "02":
xue = "机械学院";
break;
case "03":
xue = "外语学院";
break;
case "20":
xue = "软件学院";
break;
}
System.out.println("入学年份：20"+year+"年");
System.out.println("学院："+xue);
System.out.println("班级："+Class);
System.out.println("学号："+id);
}
else{
System.out.println("Wrong Format");
}
}
}
}

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
float n=scanner.nextFloat();
float lastGuess=scanner.nextFloat();
if(n<0||lastGuess<=0){
System.out.println("Wrong Format");
return;}
float nextGuess = (lastGuess+n/lastGuess)/2;
while(Math.abs(nextGuess-lastGuess)>=0.00001){
lastGuess=nextGuess;
nextGuess = (lastGuess+n/lastGuess)/2;
}
System.out.print(lastGuess);
}
}

import java.util.*;
public class Main{
public static void main(String args[]){
Scanner scanner=new Scanner(System.in);
String xl=scanner.nextLine();
int n=xl.length();
int k=0;
String zfc="";
for(k=0;k<n;k++){
if(xl.charAt(k)=='0')
zfc=zfc+xl.charAt(k);
else if(xl.charAt(k)=='1')
zfc=zfc+xl.charAt(k);
else if(xl.charAt(k)=='-'&&xl.charAt(k+1)=='1'){
System.out.print(zfc);
return;
}

}
System.out.println("Wrong Format");
}
}

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
double s=scanner.nextDouble();
double h=scanner.nextDouble();
double b=scanner.nextDouble();
if((s>=1&&s<=200)&&(h>=1&&h<=200)&&(b>=1&&b<=200))
{
if((s+h>b) && (s+b>h) && (h+b>s))
{
if((s==h)&&(s==b)&&(b==h))
{
System.out.print("Equilateral triangle");
}
else if((s==h)&&((Math.pow(s,2)+Math.pow(h,2))-Math.pow(b,2))<0.00001)
{
System.out.print("Isosceles right-angled triangle");
}
else if((s==b)&&((Math.pow(h,2)+Math.pow(b,2))-Math.pow(s,2))<0.00001)
{
System.out.print("Isosceles right-angled triangle");
}
else if((b==h)&&((Math.pow(s,2)+Math.pow(b,2))-Math.pow(h,2))<0.00001)
{
System.out.print("Isosceles right-angled triangle");
}

else if(s==h||s==b||h==b)
{
System.out.print("Isosceles triangle");
return;
}

else if((Math.pow(s,2)+Math.pow(h,2))==Math.pow(b,2)||(Math.pow(h,2)+Math.pow(b,2))==Math.pow(s,2)||(Math.pow(s,2)+Math.pow(b,2))==Math.pow(h,2))
{
System.out.print("Right-angled triangle");
return;
}

else if((s+h>b) && (h+b>s) && (s+b>h))
{
System.out.print("General triangle");
return;
}
else
{
System.out.print("Not a triangle");
return;
}
}

else
{
System.out.print("Not a triangle");
return;
}


}
else
{
System.out.print("Wrong Format");
return;
}


}

}

这些呢，是第一次作业代码，嗯，比较简单使我在理论上对JAVA有了全新的认识,在实践能力上也得到了提高,真正地做到了学以致用,更学到了很多做人的道理,

import java.util.Scanner;

class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
Menu mu = new Menu();
Order od = new Order();
String tem = null;
int i=0;
int a=0;
while(!"end".equals(tem)){
tem = sc.nextLine();
if(tem.equals("end")){
break;
}
String[] tem1 = tem.split(" ");
od.records[i] = new Record();
od.records[i] = od.addARecord(tem1[0],Integer.parseInt(tem1[1]));
a++;
i++;
}
/*
判断是否存在；
*/
Dish te;
for(i=0;i<a;i++){
te = mu.searthDish(od.records[i].d.name);
if(te==null){
System.out.println(od.records[i].d.name+" "+"does not exist");
}
else{
od.records[i].d.unit_price = te.unit_price;
}
}
System.out.println(od.getTotalPrice());
}
}

class Dish {
String name;//菜品名称
int unit_price; //单价
int a;
int getPrice(int portion){
switch (portion)
{
case 1:a=unit_price;break;
case 2:a=(int) Math.round(unit_price*1.5);break;
case 3:a=unit_price*2;break;
}
return a;
}
public Dish(String name,int unit_price,int getPrice){
this.name=name;
this.unit_price=unit_price;
}
public Dish() {
// TODO Auto-generated constructor stub
}
}

class Menu {
Dish[] dishs = new Dish[4];//菜品数组，保存所有菜品信息

Dish searthDish(String dishName){

dishs[0] = new Dish();
dishs[1] = new Dish();
dishs[2] = new Dish();
dishs[3] = new Dish();

dishs[0].name ="西红柿炒蛋";
dishs[1].name = "清炒土豆丝";
dishs[2].name = "麻婆豆腐";
dishs[3].name = "油淋生菜";

dishs[0].unit_price = 15;
dishs[1].unit_price = 12;
dishs[2].unit_price = 12;
dishs[3].unit_price = 9;

for(int i=0;i<4;i++){
if(dishName.equals(dishs[i].name)){
return dishs[i];
}
}
return null;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

class Record {
Dish d=new Dish();//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice(){
return d.getPrice(portion);
}//计价，计算本条记录的价格
}

class Order {
Record[] records=new Record[100];//保存订单上每一道的记录
int count=0;
int getTotalPrice(){
int sum=0;
for(int i=0;i<count;i++){
sum=sum+records[i].getPrice();
}
return sum;
}//计算订单的总价
Record addARecord(String dishName,int portion){
Record rdcord = new Record();
rdcord.d.name = dishName;
rdcord.portion = portion;
count++;
return rdcord;
}
//添加一条菜品信息到订单中。
}

菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}

订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}

  • 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
  • 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
  • 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
  • 类可以看成是创建 Java 对象的模板。 通过上图创建一个简单的类来理解下 Java 中类的定义： 一个类可以包含以下类型变量： 1. 局部变量：在方法、构造方法或者语句
  • 每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。 在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，
  • 菜单计价程序-2 分数 40 作者 蔡轲 单位 南昌航空大学

    设计点菜计价程序，根据输入的信息，计算并输出总价格。

    输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

    菜单由一条或多条菜品记录组成，每条记录一行

    每条菜品记录包含：菜名、基础价格 两个信息。


    订单分：点菜记录和删除信息。每一类信息都可包含一条或多条记录，每条记录一行。
    点菜记录包含：序号、菜名、份额、份数。
    份额可选项包括：1、2、3，分别代表小、中、大份。

    删除记录格式：序号 delete

    标识删除对应序号的那条点菜记录。

    不同份额菜价的计算方法：
    小份菜的价格=菜品的基础价格。
    中份菜的价格=菜品的基础价格1.5。
    小份菜的价格=菜品的基础价格    2。
    如果计算出现小数，按四舍五入的规则进行处理。

    参考以下类的模板进行设计：
    菜品类：对应菜谱上一道菜的信息。

    Dish {    
   String name;//菜品名称    
   int unit_price;    //单价    
   int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）    }
     

    菜谱类：对应菜谱，包含饭店提供的所有菜的信息。

      
    Menu {
   Dish[] dishs ;//菜品数组，保存所有菜品信息
   Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
   Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}
     

    点菜记录类：保存订单上的一道菜品记录

      
    Record {
   int orderNum;//序号\
   Dish d;//菜品\
   int portion;//份额（1/2/3代表小/中/大份）\
   int getPrice()//计价，计算本条记录的价格\
}
     

    订单类：保存用户点的所有菜的信息。

    Order {
   Record[] records；//保存订单上每一道的记录
   int getTotalPrice()//计算订单的总价
   Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
   delARecordByOrderNum(int orderNum)//根据序号删除一条记录
   findRecordByNum(int orderNum)//根据序号查找一条记录
}
     

    输入格式:

    菜品记录格式：

    菜名+英文空格+基础价格

    如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

    点菜记录格式：
    序号+英文空格+菜名+英文空格+份额+英文空格+份数
    注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

    删除记录格式：序号 +英文空格+delete


    最后一条记录以“end”结束。

    输出格式:

    按顺序输出每条订单记录的处理信息，

    每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。
    如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名

    如果删除记录的序号不存在，则输出“delete error”

    最后输出订单上所有菜品的总价（整数数值），

    本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的下一次作业中会做要求。

    输入样例:

    在这里给出一组输入。例如：

    麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
     

    输出样例:

    在这里给出相应的输出。例如：

    1 麻婆豆腐 36
2 油淋生菜 27
63
     

    输入样例1:

    订单中包含删除记录。例如：

    麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
     

    输出样例1:

    在这里给出相应的输出。例如：

    1 麻婆豆腐 36
2 油淋生菜 27
27


    import java.util.Scanner;
    public class Main
    {
    public static void main(String[] args)
    {
    Scanner input=new Scanner(System.in);
    String []menu =new String[500];
    int []price=new int[500];
    String menuName;
    int inputPrice;
    int i=0;
    String wholeJudge;
    while(true)
    {
    int reption=1;
    menuName=input.next();
    if(menuName.equals("1"))
    {
    wholeJudge="1";
    break;
    }
    if(menuName.equals("end"))
    {
    wholeJudge="0";
    break;
    }
    inputPrice=input.nextInt();
    for(int k=0;k<i;k++)
    if(menuName.equals(menu[k]))
    {
    price[k]=inputPrice;reption=0;
    break;
    }
    if(reption==1)
    {
    menu[i]=menuName;
    price[i]=inputPrice;
    i++;
    }
    }
    int everyPrice=0;
    int totalPrice = 0;
    int count=0;
    int []recording=new int[100];
    int re=0;
    int judge3=1,judge2=0;
    String endJudge="";
    if(wholeJudge.equals("1"))
    while(!wholeJudge.equals("end"))
    {
    everyPrice=0;
    int flag=0;
    String order=input.next();
    if(order.equals("delete"))
    {
    if(judge2==1&&judge3==0)
    wholeJudge = endJudge;
    int p=Integer.parseInt(wholeJudge);

    if(p<1||p>count||recording[p-1]==0)
    System.out.println("delete error;");
    if(p>=1&&p<=count&&recording[p-1]!=0)
    {
    totalPrice -= recording[p-1];
    recording[p-1]=0;
    }
    endJudge = input.next();
    judge3 = 0;
    if(endJudge.equals("end"))
    break;
    else
    {
    judge2=1;
    wholeJudge=endJudge;
    continue;
    }
    }
    else judge3=1;
    int size1=input.nextInt();
    int b=input.nextInt();
    for(int j=0;j<i;j++)
    {
    if(order.equals(menu[j]))
    {
    flag=1;
    if(size1==1)everyPrice+=price[j];
    if(size1==2)
    {
    if(price[j]%2==1)
    everyPrice+=price[j]*1.5+1;
    else
    everyPrice+=price[j]*1.5;
    }
    if(size1==3)
    everyPrice+=2*price[j];
    }
    }

    if(flag==0)
    {
    recording[re++]=0;
    System.out.println(order+" does not exist");
    count++;
    }

    if(flag==1)
    {
    everyPrice*=b;
    totalPrice+=everyPrice;
    recording[re++]=everyPrice;
    System.out.println(wholeJudge+" "+order+" "+everyPrice);
    count++;
    }
    wholeJudge=input.next();
    }

    if(!wholeJudge.equals("0"))
    System.out.println(totalPrice);
    else System.out.println("0");
    }
    }

     jmu-java-日期类的基本使用  
    1. 给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
    2. 给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。

    输入格式:

    第一行输入一个日期字符串，格式为"YYYY-MM-dd"
    第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。

    输出格式:

    如果第一行日期字符串非法，输出自定义的错误信息。
    如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
    如果第二行两个日期，只要有一个无效。就输出相关错误信息。
    如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息

    public class Test {

    public static void main(String[] args) {

    // 测试1890年到2030年之间的闰年
    for (int y = 1890; y < 2030; y++) {
    if (isLeap(y)) {
    System.out.println(y + "是闰年！");
    }
    }
    System.out.println("**********************");
    // 测试合法日期
    for (int y = 2012; y < 2020; y++)
    for (int m = -1; m < 14; m++)
    for (int d = 0; d < 33; d++) {
    if (isValidDate(y, m, d)) {
    System.out.println(y + "年" + m + "月" + d + "日是一个合法日期！");
    }

    }

    }

    // 判断是否是闰年
    public static Boolean isLeap(int year) {

    if (year % 4 == 0 && year % 100 != 0) {
    return true;
    } else if (year % 100 == 0 && year % 400 == 0) {
    return true;
    } else {
    return false;
    }

    }

    // 判断是合法日期
    public static Boolean isValidDate(int year, int month, int day) {

    if (year > 0 && month > 0 && month < 13 && day > 0 && day < 32) {

    if (month == 2) {
    if (isLeap(year) && day < 30) {
    return true;
    }
    if (!isLeap(year) && day < 29) {
    return true;
    }

    } else if ((month == 4 || month == 6 || month == 9 || month == 11) && day < 31) {
    return true;
    }

    else if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10
    || month == 12)) {
    return true;
    }

    } else {

    return false;
    }
    return false;

    }

    小明走格子

    import java.util.*;

    import java.io.*;

    public class Main {
    public static void main(String[] args) throws Exception
    {
    //TODO Auto-generated method stub
    BufferedReader b1 = new BufferedReader(new InputStreamReader(System.in));
    int[] a = new int[10000 + 5];
    int[] b = new int[100];
    int n = 0;
    try{
    n = Integer.parseInt(b1.readLine());
    }
    catch (NumberFormatException e) {
    e.printStackTrace();
    }
    catch (IOException e) {
    e.printStackTrace();
    }
    for(int i = 0;i < n;i++)
    {
    try {
    a[i] = Integer.parseInt(b1.readLine());
    } catch (NumberFormatException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    for(int i = 0;i < n;i++)
    {
    for(int j = 1;j <= a[i];j++)
    {
    if (j == 1)
    b[j] = 1;
    else if (j == 2)
    b[j] = 2;
    else if (j == 3)
    b[j] = 4;
    else if (j == 4)
    b[j] = 8;
    else {
    b[j] = b[j - 1] + b[j - 2] + b[j - 3] + b[j - 4];
    }
    }
    System.out.println(b[a[i]]);
    }
    }
    }

    这是第2次作业，这让我 掌握类的定义，熟悉属性、构造函数、方法的作用，掌握用类作为类型声明变量和方法返回值； （2） 理解类和对象的区别，掌握构造函数的使用，熟悉通过对象名引用实例的方法和属性； （3） 理解static修饰符对类、类成员变量及类方法的影响，

    类的基本思想分为数据抽象和封装。结构体中的函数称为成员函数，结构体中的数据被称为数据成员。这种结构体被称为类，变量称为对象。
    数据成员可以在类内初始化也可以在类外初始化。在类内时先声明再定义。类外初始化是在类内声明，在类外进行定义，不过在函数名字前要加类名字和作用域符。在刚开始用这个内容时，经常忘记加类名字和作用域符。

     菜单计价程序-3

    设计点菜计价程序，根据输入的信息，计算并输出总价格。

    输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

    菜单由一条或多条菜品记录组成，每条记录一行

    每条菜品记录包含：菜名、基础价格 两个信息。

    订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。

    桌号标识独占一行，包含两个信息：桌号、时间。

    桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。

    点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。

    不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。

    删除记录格式：序号 delete

    标识删除对应序号的那条点菜记录。

    如果序号不对，输出"delete error"


    import java.util.Scanner;
    public class Main{
    public static void main(String[] args){
    Scanner input = new Scanner(System.in);
    String []menu =new String[]{"西红柿炒蛋","清炒土豆丝","麻婆豆腐","油淋生菜"};
    String dish;
    int portion;
    int totalPrice = 0;
    double price = 0;
    int judge = 0;
    while(true){
    dish = input.next();
    if(dish.equals("end")){
    break;
    }
    portion = input.nextInt();
    if(portion==1) price = 1;
    if(portion==2) price = 1.5;
    if(portion==3) price = 2;
    if(dish.equals(menu[0])){
    judge = 0;
    }else if(dish.equals(menu[1])){
    judge = 1;
    }else if(dish.equals(menu[2])){
    judge = 2;
    }else if(dish.equals(menu[3])){
    judge = 3;
    }else{
    System.out.println(dish+" does not exist");
    continue;
    }
    switch(judge){
    case 0:
    totalPrice += Math.round(15 * price);
    break;
    case 1:
    totalPrice += Math.round(12 * price);
    break;
    case 2:
    totalPrice += Math.round(12 * price);
    break;
    case 3:
    totalPrice += Math.round(9 * price);
    break;
    default:
    System.out.println(input+" does not exist");
    break;
    }
    }
    System.out.println(totalPrice);
    }

     有重复的数据

    import java.util.HashSet;
    import java.util.Scanner;


    public class Main {
    public static void main(String[] args) {
    Scanner cao = new Scanner(System.in);
    int n=cao.nextInt();
    cao.nextLine();
    String str = cao.nextLine();
    String[] a = str.split(" ");
    HashSet<String> b = new HashSet<String>();

    for(int i=0;i<n;i++)
    {
    b.add(a[i]);
    }
    int size = b.size();
    if(size==n)
    {
    System.out.println("NO");
    }
    else{
    System.out.println("YES");
    }
    }

    }

    去掉重复的数据

    import java.util.*;
    public class Main {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int f = sc.nextInt();
    int flag=0;
    String str = sc.nextLine();
    while(sc.hasNext())
    {
    String s = sc.nextLine();
    str = str + s;
    }
    String[] arr = str.split(" ");
    LinkedHashSet<String> list = new LinkedHashSet<String>();
    for (int i = 0; i < arr.length; i++) {
    list.add(arr[i]);
    }
    for (String w : list) {
    if(flag==0)
    {
    System.out.print(w);
    flag = 1;
    }
    else System.out.print(" "+w);
    }
    }
    }

    单词统计与排序

    import java.util.*;
    public class Main {
    public static void main(String[] args) {
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    String[] ss=s.split("\\,|\\ |\\.");//以“,”、“.”还有空格分割
    TreeSet<String> m=new TreeSet<String>(new MyComparator());
    for(int i=0;i<ss.length;i++)
    {
    if(ss[i]!=null&&ss[i].length()!=0)//删除字符串数组内的空格
    {
    m.add(ss[i]);
    }
    }
    Iterator it=m.iterator();
    while(it.hasNext())
    {
    String o=(String)it.next();
    System.out.println(o);
    }

    }
    }
    class MyComparator implements Comparator<String>{

    @Override
    public int compare(String arg0, String arg1) {
    // TODO Auto-generated method stub
    if(arg0.length()>arg1.length())
    return -1;
    else if(arg0.length()==arg1.length())
    return arg0.compareToIgnoreCase(arg1);
    else
    return 1;
    }
    }

     面向对象编程(封装性)


    public class Student{
    private String name;
    private int score;
    //对于这个类，它的默认构造方法如下：
    public Stduent(){

    }
    //每个类都有一个默认的无参构造方法，如下：
    public Stduent(String name, int score){
    this.name = name;
    this.score = score;
    }
    //这样当我们想修改数据的时候，只需要在Main函数创建对象的时候输入内容即可：
    public static void main(String[] args){
    Student rouji = new Student("rouji",10);
    //这样便完成了赋值与修改，Java中很多内容都要这样去定义，比如Dimension等

    同样的，我们可以修改括号内的形参来改变我们的构造方法从而改变对对象的操作，并且当我们修改以后新的构造方法会覆盖原来的构造方法，这一现象叫做方法重载
    //方法重载：1.方法名重名 2.参数类型(个数,顺序)不一样
    //同一个方法，通过参数的选择实现不同的需求
    public Student() {
    this.name = name;
    this.score = score;
    }//这样便实现了方法重载

    //同样的，作为方法，构造方法可以互相调用，但是注意无法形成死循环，比如当我们有两个构造方法的时候，我们不能在两个构造方法中互相调用双方，这样导致陷入循环报错
    public Student(String name,int age) {
    this.name = name;
    this.age = age;
    }
    public Student() {
    //构造方法相互调用(必须放在代码第一句)：this(参数，，);
    //创建对象时设置默认值
    this("mazi",18);

    GPS测绘中度分秒转换

    import java.text.DecimalFormat;
    import java.util.Scanner;

    public class Main {
    public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    String line = input.nextLine(); // 读入一行字符串
    String[] parts = line.split(" "); // 使用空格分割度分秒信息
    int degree = Integer.parseInt(parts[0]); // 提取度
    int minute = Integer.parseInt(parts[1]); // 提取分
    double second = Double.parseDouble(parts[2]); // 提取秒
    double result = degree + minute / 60.0 + second / 3600.0; // 计算结果
    DecimalFormat df = new DecimalFormat("#0.000000");
    String results = df.format(result);
    System.out.printf(degree+"°"+minute+"′"+parts[2]+"″"+" = "+results); // 输出结果
    }
    }

    判断两个日期的先后，计算间隔天数、周数

    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.*;

    public class Main {
    public static void main(String[] args) throws ParseException {
    Scanner cin = new Scanner(System.in);
    String s1 = cin.next();
    String s2 = cin.next();
    SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");//设置输入日期的格式
    Date date1 = format.parse(s1);
    Date date2 = format.parse(s2);
    int a = (int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24));
    System.out.println("日期差为" + a);
    }
    }

    这是第3次的，题越来越难 带有static ,不需要对象就能调用,对象里的方法不带有static

    当我们通过new关键字来创建对象时,其实就是在调用构造方法,构造方法和它所在的类的名字相同,但是没有返回值,所有的类都有自己的默认构造方法,但是当我们定义了自己的构造方法后,默认构造方法就会失效 , 格式：
    public 类名称（参数类型 参数名称）{
    方法体，类的引用和对象的概念没什么好弄混的，但是对象和实例之间的区别让人疑惑，”。很多地方提到对象和实例就是一个东西，在我理解看来，这种说法不准确，更准确的理解是实例表示的是对象和类的关系。在最后部分，我将学习源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。
    }

     

     
     

     

     

标签：总结,String,int,System,pta,else,public,out
From： https://www.cnblogs.com/shbwd/p/17279279.html

相关文章

  • Linux服务器MySQL操作总结
    目录1.Navicat连接服务器MySQL2.如何查看MySQL用户名和密码3.修改MySQL的登录密码4.安装MySQL开发包(Centos7版)错误：error1045(28000):accessdeniedforuser'root'@'localhost'(usingpassword:yes)1.Navicat连接服务器MySQL1.选择数据库直接使用第一个MySQL即可......
  • 每日总结--2023/3/31(解决了数据库连接不正常的问题，完成了javaweb暂时的配置)
    今天耗费一天的时间总算是找到了问题所在.问题出在mysqlServlet的版本上。在重装系统前,我所装的mysqlSevlet版本是5.0左右的,所以连接数据库的驱动也是5.0，包括url,而在重装系统后我的mysqlSevlet版本是8.0以上的，所以用原来的语句是不正确的,要修改为8.0版本的才能够运行,同......
  • 每日总结--2023/3/29(解决sevlet报错问题和数据库中文编码错误)
    今日完成:昨天的残留问题，查询了很多资料，也没能完全解决。首先是tomcat版本问题，重新下载并且部署了tomcat10版本的内容，解决了sevlet代码报错的问题。但是连接数据库仍然是不成功，报500错误，检查了mysql数据库，发现数据库正常（除中文变为？的bug)。连接数据库暂时仍不成功，但是成功解决......
  • 每日总结--2023/3/26
    完成同一线路的查询：sevlet代码：packageServelet;importDButil.DButil;importbean.User;importcom.sun.net.httpserver.HttpServer;importjakarta.servlet.ServletException;importjakarta.servlet.annotation.WebServlet;importjakarta.servlet.http.HttpServlet;importj......
  • 每日总结--2023/3/27
    完成内容：在subwayweb程序中加入了地图<%--CreatedbyIntelliJIDEA.User:86178Date:2023/3/13Time:16:43TochangethistemplateuseFile|Settings|FileTemplates.--%><%@pagecontentType="text/html;charset=UTF-8"language="java&qu......
  • 对于数据链路层滑动窗口协议中窗口大小的总结
    3.4节中介绍了三种滑动窗口协议:1位滑动窗口协议、GBN协议、SR协议。1位滑动窗口协议本质上就是一种全双工的停等式协议，它的发送窗口和接收窗口大小都是1，在此不做赘述，我主要分析后两种协议的窗口大小。在SR协议中，窗口大小默认满足如下两个基本条件:发送窗口大小=接收窗口大小发......
  • Menu5.2运行机制分析总结
    同步机制分析示例代码对于任务管理采用了单向链表的管理方式，包含了创建、删除、添加、删除、搜索节点以及获取链表头和下一个节点的功能（在Menu5.2中，仅支持默认的）。这些操作涉及多线程并发操作，所以采用了互斥量（mutex）进行同步。当一个线程需要对链接表进行修改操作时，需要先对互斥量......
  • 装疯卖傻总结性blog
    前言1.    Scannerin=newScanner(System.in);Scanner是一个类，in是一个实例或者说是对象，new是一个创建对象的方法2.(float)(x/0.45359237)强制数据类型转换的写法3．String[]race=newString[]{"人类","精灵","兽人","暗精灵"};创建数组格式likethis，与c不一样要......
  • makefile使用总结（一）
    本文参考《跟我一起写Makefile》编写，并做了一些适合个人习惯的修改，稍加总结而成。 首先提出的问题是：什么是makefile？为什么要用makefile？如何使用makefile？为了回答这三个问题，下面就围绕这些问题做一些记录。什么是makefile？简单点说makefile是一个描述了整个工程的编译规......
  • docker 常用命令总结
    attach#当前shell下attach连接指定运行镜像build#通过Dockerfile定制镜像commmit#提交当前容器为新的镜像cp#从容器中拷贝指定文件或者目录到宿主机中create#创建一个新的容器，同run，但不启动容器diff......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99