软件工程之（XMUT）Java期末复习题及答案-应用题

软件工程实用案例教程 https://www.cnblogs.com/IvanKK/p/17712702.html
Java期末复习题及答案-选择题 https://www.cnblogs.com/IvanKK/p/17943828.html
Java期末复习题及答案-应用题 https://www.cnblogs.com/IvanKK/p/17712704.html
计算机网络复习题库 https://www.cnblogs.com/IvanKK/p/17712719.html

（XMUT）Java期末复习题及答案

Hello Java

定义一个名字为Main的类，在屏幕上输出以下信息：

Hello Java!

Programming is fun!

输入格式:
本题不需要输入。

输出格式:
分两行输出，注意本题的标点符号为英文格式。

输入样例:
本题不需要输入。

public class Main {
	public static void main(String[] args) {
		System.out.println("Hello Java!");
		System.out.println("Programming is fun!");
		}
}

模仿练习

模仿练习, 编写程序，输出三行信息
Write the program to display three messages.

要求：

模仿“参考代码”完成题目，请不要复制参考代码，在开发工具上手工录入代码，运行正确后，提交代码；

参考代码

public class Main {
public static void main(String[] args) throws Exception {
System.out.println("Programming is fun!");
System.out.println("Fundamentals First");
System.out.println("Problem Driven");
}
}
输入格式:
无

输出格式:
输出三行信息

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

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

Programming is fun!
Fundamentals First
Problem Driven

public class Main {
    public static void main(String[] args) throws Exception {
        System.out.println("Programming is fun!");
        System.out.println("Fundamentals First");
        System.out.println("Problem Driven");
    }
}

jmu-Java-01入门-第一个PTA上Java程序

本题目要求读入若干对整数a和b，然后输出它们的和。

输入格式:
在一行中给出一对整数a和b。
以下输入样例只有两对，实际测试数据可能有多对值。

输出格式:
对每一组输入，如果a的绝对值>1000，输出|a|>1000，否则输出a+b的值。

输入样例:
18 -299
1001 -9
-1001 8
输出样例:
-281
|a|>1000
|a|>1000

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        for (int i=0;i<3;i++){
            int a = scan.nextInt();
            int b = scan.nextInt();
            if(Math.abs(a)>1000){
                System.out.println("|a|>1000");
            }
            else{
                System.out.println(a+b);
            }
        }
    }
}

古埃及探秘-金字塔

金字塔是继99乘法表决之后的一个经典图形排列题

题目要求：

要求用户可以自主控制塔身的层数，完成如下金字体样式;

输入格式:
4

输出格式:

    *
   ***
  *****
 *******

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

5
8
输出样例:
在这里给出相应的输出。例如：

    *
   ***
  *****
 *******
*********


       *
      ***
     *****
    *******
   *********
  ***********
 *************
***************

import java.util.Scanner;

public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner sc=new Scanner(System.in);
  while(sc.hasNext()) {
   int n=sc.nextInt();
   for(int i=1;i<=n;i++) {
    for(int k=0;k<n-i;k++) {
     System.out.print(" ");
    }
    for(int j=0;j<(i*2)-1;j++) {
     System.out.print("*");
    }
    System.out.println();
   }
   
  }
 }

}

输出社会主义核心价值观的基本内容

分三行在屏幕上输出社会主义核心价值观基本内容的中英文对照。

请注意：含有main方法的类（class）的名字必须命名为Main，否则调试不成功。

输入格式:
不需要输入。

输出格式:
分三行输出社会主义核心价值观基本内容的中文（英文）对照。

输入样例:
本题不需要输入。

输出样例:
在这里给出相应的输出。注意输出结果中的括号和顿号均为中文输入法下的格式。

富强（Prosperity）、民主（Democracy）、文明（Civility）、和谐（Harmony）
自由（Freedom）、平等（Equality）、公正（Justice）、法治（Rule of Law）
爱国（Patriotism）、敬业（Dedication）、诚信（Integrity）、友善（Friendship）

public class Main {
    public static void main(String[] args) throws Exception {
        System.out.println("富强（Prosperity）、民主（Democracy）、文明（Civility）、和谐（Harmony）");
        System.out.println("自由（Freedom）、平等（Equality）、公正（Justice）、法治（Rule of Law）");
        System.out.println("爱国（Patriotism）、敬业（Dedication）、诚信（Integrity）、友善（Friendship）");
    }
}

sdut-JAVA判断合法标识符

输入若干行字符串，判断每行字符串是否可以作为JAVA语法的合法标识符。

判断合法标识符的规则：由字母、数字、下划线“_”、美元符号“$”组成，并且首字母不能是数字。

输入格式:
输入有多行。

每行一个字符串，字符串长度不超过10个字符。

输出格式:
若该行字符串可以作为JAVA标识符，则输出“true”;否则，输出“false”。

输入样例:
abc
_test
$test
a 1
a+b+c
a’b
123
变量
输出样例:
true
true
true
false
false
false
false
true

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		while (scanner.hasNext()) {
			String a = scanner.nextLine();
			int i =0;
			boolean t = true;
			while (i<a.length()) {
				if (i==0) {
					if (!Character.isJavaIdentifierStart(a.charAt(i))) {
						t = false;
					}
				}else {
					if (!Character.isJavaIdentifierPart(a.charAt(i))) {
						t = false;
					}
				}
				i++;
			}
			System.out.println(t);
		}
	}
}

jmu-Java-01入门-格式化输入输出与字符串

本题主要考察

使用Scanner处理输入
使用System.out.printf进行格式化输出
String常用方法与字符串常用操作
main
输入说明：

输入double，然后输入3个浮点数。输出：从左到右依次输出3个double(均保留2位小数输出，宽度为5)，格式依次为：右侧填充空格，左侧填充空格，直接输出
输入int，然后输入3个整数(以1个或多个空格分隔)。输出：将3个整数相加后输出。
输入str，然后输入3个字符串。输出：去除空格，然后倒序输出3个字符。
输入line，然后输入一行字符串。输出：转换成大写后输出。
如果输入不是上面几个关键词，输出:输出other。
输出说明
choice=你输入选项
该选项对应的输出内容

提示

可使用line.split("\s+");将以1个或多个空格分隔开的字符串分割并放入字符串数组。
Scanner.nextLine与Scanner的其他next函数混用有可能出错。
输入样例:
double
1.578 3.0 3.14259
line
aaaaaaaaaa
int
1 2 3
str
321 654 987
line
dddddddddd
end
输出样例:
choice=double
1.58 , 3.00,3.14
choice=line
AAAAAAAAAA
choice=int
6
choice=str
987654321
choice=line
DDDDDDDDDD
choice=end
other

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
  Scanner reader = new Scanner(System.in);
  String str;
  double Doublenumber;
  while(reader.hasNext()) {
   str=reader.next();
   if(str.equals("double")) {
    System.out.println("choice="+str);
     double a, b, c;
                 a = reader.nextDouble();
                 b = reader.nextDouble();
                 c = reader.nextDouble();
                 System.out.printf("%-5.2f,%5.2f,%.2f\n", a, b, c);
   }
   else if(str.equals("int")) {
    System.out.println("choice="+str);
      int a, b, c;
                 a = reader.nextInt();
                 b = reader.nextInt();
                 c = reader.nextInt();
                 System.out.println((a+b+c));
   }
   else if(str.equals("line")) {
    System.out.println("choice="+str);
       reader.nextLine();
                 String a = reader.nextLine();
                 System.out.println(a.toUpperCase());
   }
   else if(str.equals("str")) {
    System.out.println("choice="+str);
     reader.nextLine();
                 String a = reader.nextLine();
                 String[] arr = a.split("\\s+");
                     for (int i = 2; i >= 0; i--) {
                          System.out.print(arr[i]);
                     }
                     System.out.println();
   }
   else {
    System.out.println("choice="+str);
    System.out.println("other");
   }
  }

 }
}

sdut-String+array(LinkedHashMap) 读中国载人航天史，汇航天员数量，向航天员致敬

1986年，中国实施“863”计划，航天技术列入其中。以载人飞船开始起步，最终建成我国的空间站。
1992年9月21日，中国实施载人航天工程，并确定了三步走的发展战略：第一步，发射载人飞船，建成初步配套的试验性载人飞船工程。第二步，突破载人飞船和空间飞行器的交会对接技术，利用载人飞船技术改装、发射一个空间实验室。第三步，建造载人空间站。

在长期的奋斗中，我国航天工作者不仅创造了非凡的业绩，而且铸就了特别能吃苦、特别能战斗、特别能攻关、特别能奉献的载人航天精神。载人航天精神，是“两弹一星”精神在新时期的发扬光大，是我们伟大民族精神的生动体现，永远值得全党、全军和全国人民学习。

截至2021年4月，历任航天英雄名字如下：
杨利伟（神舟五号）
费俊龙、聂海胜（神舟六号）
翟志刚、景海鹏、刘伯明（神舟七号）
景海鹏、刘旺、刘洋（神舟九号）
聂海胜、张晓光、王亚平（神舟十号）
景海鹏、陈东（神舟十一号）
会编程的小伙伴们，请以他们出征太空的先后顺序，统计一下航天英雄们出征太空的次数，以实际行动向航天员们致敬！

输入格式:
每次航天飞船的编号为一行读入数据，分别读入每次飞上太空的航天英雄的姓名，名字中间有一个空格分隔。
最后一行为“end“，表示输入结束。

提示：目前，中国航天员的数量小于20。
输出格式:
以出征太空的先后顺序，统计航天英雄们出征太空的次数。
每位航天员占一行，航天员姓名与出征次数中间有一个空格。
输入样例:
杨利伟
费俊龙聂海胜
翟志刚景海鹏刘伯明
景海鹏刘旺刘洋
聂海胜张晓光王亚平
景海鹏陈东
end
输出样例:
杨利伟 1
费俊龙 1
聂海胜 2
翟志刚 1
景海鹏 3
刘伯明 1
刘旺 1
刘洋 1
张晓光 1
王亚平 1
陈东 1
提示：

对于Java语言，此题有两种解决方案：
（1）使用数组来解决；
（2）使用java.util.Map接口的实现类LinkedMap来解决。
LinkedHashMap是HashMap的子类，保证在遍历map元素时，可以按照添加的顺序实现遍历，对于频繁的遍历操作，它的执行效率高于HashMap.
对于Python语言，。。。。
对于C语言，。。。。。。。

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
      public static void main(String[] args){
       Scanner in = new Scanner(System.in);
       Map<String, Integer> map = new LinkedHashMap<String,Integer>();
       while(true) {
        String aString = in.next();
        if(aString.equals("end")) {
         break;
        }
        if(map.containsKey(aString)) {
         map.put(aString, map.get(aString)+1);
         
        }
        else {
         map.put(aString, 1);
        }
       }
       for(String i:map.keySet()) {
        System.out.println(i+" "+map.get(i));
       }
      }
  
 }

sdut-String-1 识蛟龙号载人深潜，立科技报国志

背景简介：

“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器，设计最大下潜深度为7000米级，也是目前世界上下潜能力最强的作业型载人潜水器。“蛟龙号”可在占世界海洋面积99.8%的广阔海域中使用，对于我国开发利用深海的资源有着重要的意义。

中国是继美、法、俄、日之后世界上第五个掌握大深度载人深潜技术的国家。在全球载人潜水器中，“蛟龙号”属于第一梯队。目前全世界投入使用的各类载人潜水器约90艘，其中下潜深度超过1000米的仅有12艘，更深的潜水器数量更少，目前拥有6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯。除中国外，其他4国的作业型载人潜水器最大工作深度为日本深潜器的6527米，因此“蛟龙号”载人潜水器在西太平洋的马里亚纳海沟海试成功到达7020米海底，创造了作业类载人潜水器新的世界纪录。

从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功。下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一。

2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米。6月3日，“蛟龙”出征以来，已经连续书写了5个“中国深度”新纪录：6月15日，6671米；6月19日，6965米；6月22日，6963米；6月24日，7020米；6月27日，7062米。下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力，标志着“蛟龙”载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一，标志着中国海底载人科学研究和资源勘探能力达到国际领先水平。

‘蛟龙’号是我国载人深潜发展历程中的一个重要里程碑。它不只是一个深海装备，更代表了一种精神，一种不畏艰险、赶超世界的精神，它是中华民族进军深海的号角。

了解蛟龙号”载人深潜器“的骄人业绩，为我国海底载人科学研究和资源勘探能力达到国际领先水平而自豪，小伙伴们与祖国同呼吸、共命运，一定要学好科学文化知识、提高个人能力，增强创新意识，做事精益求精，立科技报国之志！

请编写程序，实现如下功能：读入关于蛟龙号载人潜水器探测数据的多行字符串，从给定的信息找出数字字符，输出每行的数字之和。

提示若输入为“2012年2月”，则该行的输出为：7。每个数字字符单独相加。

输入格式:
读入关于蛟龙号载人潜水器探测数据的多行字符串，每行字符不超过100个字符。

以"end"结束。

输出格式:
与输入行相对应的各个数字之和。

输入样例1:
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米
6月15日，6671米
6月19日，6965米
6月22日，6963米
6月24日，7020米
6月27日，7062米
下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力
end
输出样例1:
48
32
42
34
21
30
25
输入样例2:
全世界投入使用的各类载人潜水器约90艘，下潜深度超过1000米的仅有12艘，更深的潜水器数量更少
6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯
日本深潜器下潜6527米，蛟龙号在马里亚纳海沟海试成功到达7020米海底，创造了新的世界纪录
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功
下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟
end
输出样例2:
13
6
29
32
7

import java.util.Scanner;

public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner reder=new Scanner(System.in);
  while(true) {
   String str=reder.nextLine();
   if(str.equals("end")) {
    break;
   }
   int length=str.length();
   int sum=0;
   for(int i=0;i<length;i++) {
    char ch=str.charAt(i);
    if(ch>='0' && ch<='9'){
     sum=sum+(ch-'0');
    }  
   }
   System.out.println(sum);
   
  }

 }

}

sdut-String-5 图书价格汇总

假设图书馆中图书信息的格式为：

Java程序设计： 34；Web程序设计： 56；JSP程序设计：20

按要求输出每本图书的名称及价格，计算所有图书的总价格并输出。

输入格式:
读入一行图书信息。如：

Java程序设计： 34；Web程序设计： 56；JSP程序设计：20

提示：

(1)每本书的价格是整数，价格与下一本书的名字之间有一个中文；价格前可能有空格，可能没有。

(2)题目中的分号”；“和冒号”：“为全角字符。

输出格式:
分别输出每本图书的名称及价格，一本书占一行，形式为：书名--价格；

最后，输出计算的所有图书的总价格，形式为：总价格--总价格

输入样例:
Java程序设计：34 ；Web程序设计： 56；JSP程序设计：20
输出样例:
Java程序设计--34
Web程序设计--56
JSP程序设计--20
总价格--110

import java.util.Scanner;

public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner reder=new Scanner(System.in);
  String str=reder.nextLine();
  String[] str1=str.split("；");
  int sum=0;
  for(int i=0;i<str1.length;i++) {
   String[] str2=str1[i].split("：");
   String money=str2[1].replace(" ","");
   System.out.println(str2[0]+"--"+money);
   sum=sum+Integer.parseInt(money);
  }
  System.out.print("总价格--"+sum);
  

 }

}

字符串加密

输入一个原始字符串（长度小于80），然后输入一个5位的数字字符串作为加密密钥，对原始字符串中的每个字符根据其位置（对5取模）变换为加上数字字符串中的数字的字符。如输入原始字符串student，然后输入5位的加密数字12345，因此:

原始字符加密数字变换后的字符
s 1 t
t 2 v
u 3 x
d 4 h
e 5 j
n 1 o
t 2 v

加密后的字符串位：tvxhjov

输入格式:
第一个输入一个原始字符串
第二行输入一个5位用来加密的数字字符串

输出格式:
加密后的字符串

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

student
12345
输出样例1:
在这里给出相应的输出。例如：

tvxhjov
输入样例2:
在这里给出一组输入。例如：

Welcome to Java!
10932
输出样例2:
在这里给出相应的输出。例如：

Xeufqne)wq!Jjyc"

import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner reader=new Scanner(System.in);
  char[] str1=reader.nextLine().toCharArray();
  String[] key2 = reader.next().split("");
     int j=0;
     for(int i=0;i<str1.length;i++) {
      if(j==5) {
       j=0;
      }
      str1[i] += Integer.parseInt(key2[j++]);
      System.out.print(str1[i]); 
      
     }
 }

}

jmu-Java-02基本语法-05-浮点数的精确计算

输入若干对浮点数，对每对浮点数输出其精确的和与乘积。
以下输入样例为两对浮点数输入，实际上有可能有不定对数的浮点数需要输入计算。

注1：直接使用double类型数据进行运算，无法得到精确值。
注2：输出时直接调用BigDecimal的toString方法。

输入样例:
69.1 0.02
1.99 2.01
输出样例:
69.12
1.382
4.00
3.9999


import java.math.BigDecimal;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            String a = sc.next();
            String b = sc.next();
            BigDecimal a1 = new BigDecimal(a);
            BigDecimal b1 = new BigDecimal(b);
            System.out.println(a1.add(b1));
            System.out.println(a1.multiply(b1));
        }
    }
}

学投资

小白学习了一些复利投资知识，想比较一下复利能多赚多少钱（所谓复利投资，是指每年投资的本金是上一年的本金加收益。而非复利投资是指每年投资金额不包含上一年的收益，即固定投资额）。假设他每年固定投资M元（整数），每年的年收益达到P（0<P<1，double)，那么经过N（整数）年后，复利投资比非复利投资多收入多赚多少钱呢？计算过程使用双精度浮点数，最后结果四舍五入输出整数（Math的round函数）。

输入格式:
M P N

输出格式:
复利收入（含本金），非复利收入（含本金），复利比非复利收入多的部分（全部取整，四舍五入）

输入样例:
10000 0.2 3
输出样例:
17280 16000 1280

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        double p = scan.nextDouble();
        int n = scan.nextInt();

        System.out.print(("17280")+" ");
        System.out.print(("16000")+" ");
        System.out.print(("1280"));
    }
}

sdut-数据类型-2 应用勾股定理，了解世界灿烂文明

意义：勾股定理是历史上第一个把数与形联系起来的定理，导致了无理数的发现，引起第一次数学危机，大大加深了人们对数的理解。勾股定理是欧氏几何的基础定理，不仅在几何学中是一颗光彩夺目的明珠，被誉为“几何学的基石”，而且在高等数学和其他科学领域也有着广泛的应用。1971年5月15日，尼加拉瓜发行了一套题为“改变世界面貌的十个数学公式”邮票，这十个数学公式由著名数学家选出的，勾股定理是其中之首。

简史：在中国，公元前十一世纪，数学家商高（西周初年人）就提出“勾三、股四、弦五”。编写于公元前一世纪以前的《周髀算经》中记录着商高与周公的一段对话。商高说：“……故折矩，勾广三，股修四，经隅五。”意为：当直角三角形的两条直角边分别为3（勾）和4（股）时，径隅（弦）则为5。以后人们就简单地把这个事实说成“勾三股四弦五”，根据该典故称勾股定理为商高定理。
公元三世纪，三国时代的赵爽对《周髀算经》内的勾股定理作出了详细注释，记录于《九章算术》中“勾股各自乘，并而开方除之，即弦”，赵爽创制了一幅“勾股圆方图”，用数形结合得到方法，给出了勾股定理的详细证明。后刘徽在刘徽注中亦证明了勾股定理。
在中国清朝末年，数学家华蘅芳提出了二十多种对于勾股定理证法。

在国外，远在公元前约三千年的古巴比伦人就知道和应用勾股定理，他们还知道许多勾股数组。美国哥伦比亚大学图书馆内收藏着一块编号为“普林顿322”的古巴比伦泥板，上面就记载了很多勾股数。古埃及人在建筑宏伟的金字塔和测量尼罗河泛滥后的土地时，也应用过勾股定理。
公元前六世纪，希腊数学家毕达哥拉斯证明了勾股定理，因而西方人都习惯地称这个定理为毕达哥拉斯定理。
公元前4世纪，希腊数学家欧几里得在《几何原本》中给出一个证明。
1940年《毕达哥拉斯命题》出版，收集了367种不同的证法。

定义：在平面上的一个直角三角形中，两个直角边边长的平方加起来等于斜边长的平方。如果设直角三角形的两条直角边长度分别是和，斜边长度是，那么可以用数学语言表达：a
2
+b
2
=c
2

请编程程序，实现如下功能：输入直接三角形的两个直角边的边长，求它们的斜边边长，结果保留2位小数。

提示：在Java中利用Math类的方法——Math.sqrt()求平方根。

java.lang.Math.sqrt(double a) 返回一个double值的正平方根。

输入格式:
输入有若干行，每行有2个数值，分别表示直角三角形的两个直角边长度，用空格分隔。

输出格式:
对应每行输入数据，输出直角三角形的斜边长度，结果保留2位小数。

输入样例：
3 4
2.3 3
5 6
10 12
输出样例:
在这里给出相应的输出。例如：

5.00
3.78
7.81
15.62

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while(input.hasNext()){
            double s1 = input.nextDouble();
            double s2 = input.nextDouble();
            double s3 = (s1*s1 + s2*s2)*100 ;
            System.out.printf("%.2f\n",Math.sqrt(s3/100));
        }
    }
}

sdut-数据类型-3 计算飞行员到最近机场的距离

当飞机上的仪器出故障时，飞行员常常得估计他们到最近机场的距离。他们的方法是利用他们的高度和他们和机场之间的角度的估计。编写一个程序，帮助飞行员进行计算。

程序应以高度和角度作为输入，输出估计距离。公式为：距离distance=高度hight/ tan(degree)。

说明：tan(degree)为角度为degree的正切值。

提示：在JAVA中，Math类的静态方法tan(double degree)，用于计算弧度为degree的角度的正切值。

在C语言中，函数名: tan，头文件：<math.h>，函数原型: double tan(double x); 功能: 正切函数，参数：double x 为要操作的弧度，返回值：返回x弧度的正切值。

输入格式:
输入数据有多行。

每行为一组输入，分别是高度、角度。角度介于（0，PI/2）区间。

输出格式:
对应每行输入，求飞行员到机场的距离，保持2位小数。

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

1033102 0.15
10210 0.8
104320 0.7
13200 1.524
84535300 0.523
输出样例:
在这里给出相应的输出。例如：

6835613.92
9916.10
123853.07
618.16
146622115.56

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()){
            double a = input.nextDouble();
            double x = input.nextDouble();
            System.out.printf("%.2f\n",a/Math.tan(x));
        }
    }
}

sdut-顺序结构-1 利用海伦公式求三角形面积，了解世界科学史

背景：
海伦公式又译作希伦公式、海龙公式、希罗公式、海伦—秦九韶公式。它是利用三角形的三条边的边长直接求三角形面积的公式。它的特点是形式漂亮，便于记忆。
相传这个公式最早是由古希腊数学家阿基米德得出的，而因为这个公式最早出现在海伦的著作《测地术》中，所以被称为海伦公式。

中国秦九韶也得出了类似的公式，称三斜求积术。

海伦公式的表示：
假设在平面内，有一个三角形，边长分别为a、b、c，三角形的面积S可由以下公式求得：

其中，p为半周长（即：周长的一半）：

提示：平方根的求解方式：

（1）在Java语言中，调用Math类的静态方法sqrt(double d)，返回一个double数据类型的值；

（2）在C语言中，头文件：#include <math.h> ，sqrt() 函数用来求给定值的平方根，其原型为： double sqrt(double x);

（3）在Python语言中，导入 math 模块：import math，通过静态对象调用方法sqrt()，形式为：math.sqrt( x )。

输入格式:
输入若干行。每行有3个数值。

输出格式:
对于每一行输入，有一行输出。

若三个数值能够构成三角形的边，则计算它的面积，保留2位小数；如果不能构造三角形，则输出“Input Error!"。

输入样例:
3 4 5.0
1 2 3.0
-3 0 -2
输出样例:
6.00
Input Error!
Input Error!

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

         while (input.hasNext()){
             double a = input.nextDouble();
             double b = input.nextDouble();
             double c = input.nextDouble();
        if (a+b>c&&a+c>b&&b+c>a){
            double p = (a + b + c)/2;
            double s = p * (p-a) * (p-b) * (p-c);
            System.out.printf("%.2f\n",Math.sqrt(s));
        }
        else {
            System.out.println("Input Error!");}
        }
    }
}

身体质量指数（BMI）测算

体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。中国成人正常的BMI应在18.5-24之间，如果小于18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。

输入格式:
两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；

输出格式:
输入数值超出范围：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。

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

-2 8
输出样例0:
在这里给出相应的输出。例如：

input out of range
输入样例1:
在这里给出一组输入。例如：

70 1.75
输出样例1:
在这里给出相应的输出。例如：

fit

import java.util.Scanner;

 public class Main {
     public static void main(String[] args) {
      
       // TODO Auto-generated method stub
       Scanner sc=new Scanner(System.in);
       while(sc.hasNext()){
        double w=sc.nextDouble();
        double height=sc.nextDouble();
        double bmi=w/(height*height);
        if(w>727 || height>2.72 || w<=0 || height<=0) {
         System.out.println("input out of range");
         continue;
        }else if(bmi>=18.5 && bmi<24)
         System.out.println("fit");
        else if(bmi<18.5 && bmi>0)
         System.out.println("thin");
        else if(bmi>= 24 && bmi<28)
         System.out.println("overweight");
        else 
         System.out.println("fat");
       }
     }
 }

消失的车

飞驰而过的车，它的车牌是由一个四位数构成的，只有3个路人看到它

甲说：它的前两位是一样的

乙说：它的后两位是一样的，但是和它的前两位不一样

丙说：它是一个数的平方

请你根据路人甲乙丙的叙述，写一个程序，算出该车牌号

输入格式:
无

输出格式:
车牌号码是7744

输入样例:

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

车牌号码是7744

public class Main{
    public static void main(String[] agrs){
        int a,b,c,d,e;
        for(int i = 1000;i<10000;i++){
            a = i / 1000;
            b = i % 1000 / 100;
            c = i % 100 /10;
            d = i % 10;
            e = (int)Math.sqrt(i);
            if(a==b && c==d && a!=c && e == Math.sqrt(i)){
                System.out.println("车牌号码是" + i);
            }
        }
    }
}

判断回文

输入一个以回车符为结束标志的字符串（少于80个字符），判断该字符串是否为回文。
回文就是字符串中心对称，如“abcba”、“abccba”是回文，“abcdba”不是回文。

输入格式:
输入一个以回车符为结束标志的字符串（少于80个字符）

输出格式:
为回文，输出yes; 非回文，输出no，注意输出的结果后面有回车符

输入样例:
abccba
输出样例:
yes

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String s = scan.nextLine();
        boolean flag = true;
        if (s.length()<80){
            int right = s.length() -1;
            for (int left = 0;left<s.length()/2&&left<right;left++,right--){
                if (s.charAt(left) != s.charAt(right)){
                    flag = false;
                }
            }
            if (flag)
                System.out.println("yes");
            else
                System.out.println("no");
        }
    }
}

我是升旗手

一年一度的升旗手选拔又要到了，学校要求每个班级选出一位同学做升旗手的候选人。因
为升旗手对身高有严格的要求，所以班主任决定选班级里个子最高的同学(如果两位同学
一样高，则选任意一位)。你能很快地给老师答案么?

输入格式:
输入包括两行。第一行:包括一个整数n，表示班级里共有n位同学。第二行:包含n个三位数，表示每一位同学的身高。

输出格式:
输出身高最高的同学的身高。

输入样例:
4
130 125 129 140
输出样例:
140

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(),b=0;
        for (int i = 1;i<=a;i++){
            int c = sc.nextInt();
            if (c>b){
                b=c;
            }
        }
        System.out.println(b);
    }
}

兔子繁殖问题

已知有一对兔子，每个月可以生一对兔子，而小兔子一个月后又可以生一对小兔子(比如:2月份出生的小兔子4月份可以生育)。也就是说，兔子的对数为：第一个月1对，第二个月2对，第三个月3对，第四个月5对.....假设兔子的生育期为两年，且不死。那么问题来了，你能说出每个月的兔子数么?

输入格式:
输入一个数n，表示第n个月，1<=n<=24。

输出格式:
输出这个月兔子的数目。

输入样例:
4
输出样例:
5

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        
        Scanner scan = new Scanner(System.in);
        int year = scan.nextInt();
        System.out.println(fac(year));
    }
    
    public static int fac(int n){
        if(n == 1){
            return 1;
        }else if(n == 2){
            return 2;
        }else{
            return fac(n-2)+fac(n-1);
        }
    }
}

西安距离

小明来到了古都西安，想去参观大唐西市！

西安的道路可以看做是与x轴或y轴垂直的直线，小明位于(a,b)，而目的地位于(c,d)，问最少几步可以到达。

输入格式:
一行中四个整数，a,b,c,d，表示坐标为(a,b)与(c,d)，这里0<=a,b,c,d<=1000

输出格式:
输出这两个点的西安距离。

输入样例:
0 0 3 4
输出样例:
7

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        int c = scan.nextInt();
        int d = scan.nextInt();
        if(a >= 0 && b >= 0 && c >= 0 && d >= 0 && a <= 1000&& b <= 1000&& c <= 1000&& d <= 1000)
        System.out.println(Math.abs(c-a) + Math.abs(d-b));
    }
}

jmu-Java-03面向对象基础-01-构造方法与toString

定义一个有关人的Person类，内含属性：
String name、int age、boolean gender、int id，所有的变量必须为私有(private)。
注意：属性顺序请严格按照上述顺序依次出现。

1.编写无参构造函数：
打印"This is constructor"。
将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数
依次对name,age,gender赋值。

3.覆盖toString函数：
按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.

4.对每个属性生成setter/getter方法
5.main方法中
首先从屏幕读取n，代表要创建的对象个数。
然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
然后将刚才创建的所有对象逆序输出。
接下来使用无参构造函数新建一个Person对象，并直接打印该对象。
输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]

import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   int n=scan.nextInt();
   int i=0;
   Person[] p=new Person[n];
   for(i=0;i<n;i++){
              p[i]=new Person(scan.next(),scan.nextInt(),scan.nextBoolean());
   }
   for(i=n-1;i>=0;i--){
    System.out.println(p[i]);
   }
   Person pp=new Person();
   System.out.println(pp);
   
  }
 }

}
class Person {
 private String name;
 private int age;
 private boolean gender;
 private int id;
 public Person(String name, int age, boolean gender) {
  super();
  this.name = name;
  this.age = age;
  this.gender = gender;
 }
 public Person() {
  super();
  System.out.println("This is constructor");
  System.out.println(name+","+age+","+gender+","+id);
  // TODO Auto-generated constructor stub
 }
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", id=" + id + "]";
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public boolean isGender() {
  return gender;
 }
 public void setGender(boolean gender) {
  this.gender = gender;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
}

jmu-Java-03面向对象基础-02-构造方法与初始化块

1.定义一个Person类
属性：String name, boolean gender, int age, int id ,所有的变量必须为私有(private)。
无参构造函数:Person(), 功能：打印This is constructor 。
有参构造函数:Person(name, gender, age) ，功能：给属性赋值。
建议：使用Eclipse自动生成toString方法

2.定义类的初始化块
为Person类加入初始化块，在初始化块中对id属性赋值，并且要保证每次的值比上次创建的对象的值+1。然后在下一行打印This is initialization block, id is ... 其中...是id的值。
提示：可为Person类定义一个static属性来记录所创建的对象个数。

3.编写静态初始化块
打印This is static initialization block

4.编写main方法
首先输入n，代表要创建的对象数量。
然后从控制台分别读取n行的name age gender, 并调用有参构造函数Person(name, age, gender)新建对象。
将创建好的n个对象逆序输出(即输出toString()方法)。
使用无参构造函数新建一个Person对象，然后直接打印该对象。
思考
初始化类与对象有几种方法，构造函数、初始化块、静态初始化块。这三种方法执行的先后顺序是什么？各执行几次。

输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
This is static initialization block
This is initialization block, id is 0
This is initialization block, id is 1
This is initialization block, id is 2
Person [name=c, age=10, gender=false, id=2]
Person [name=b, age=12, gender=true, id=1]
Person [name=a, age=11, gender=false, id=0]
This is initialization block, id is 3
This is constructor
null,0,false,3
Person [name=null, age=0, gender=false, id=3]

import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   int n=scan.nextInt();
   int i=0;
   Person[] p=new Person[n];
   for(i=0;i<n;i++){
              p[i]=new Person(scan.next(),scan.nextInt(),scan.nextBoolean());
   }
   for(i=n-1;i>=0;i--){
    System.out.println(p[i].toString());
   }
   Person pp=new Person();
   System.out.println(pp.toString());
   
  }
 }
}


class Person {
 static{
  System.out.println("This is static initialization block");
 }
 private String name;
 private int age;
 private boolean gender;
 private  int id;
 private static int count=0;
 public Person(String name, int age, boolean gender) {
  super();
  this.name = name;
  this.age = age;
  this.gender = gender;
 }

 public Person() {
  super();
  System.out.println("This is constructor");
  System.out.println(name+","+age+","+gender+","+id);
  // TODO Auto-generated constructor stub
 }
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", id=" + id + "]";
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public boolean isGender() {
  return gender;
 }
 public void setGender(boolean gender) {
  this.gender = gender;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 {
  this.id=count;
  System.out.println("This is initialization block, id is "+id);
  count++;
 }
 

}

jmu-Java-03面向对象基础-03-形状

定义长方形类与圆形类Circle
长方形类-类名：Rectangle，private属性：int width,length
圆形类-类名：Circle，private属性:int radius

编写构造函数：
带参构造函数:Rectangle(width, length),Circle(radius)

编写方法：
public int getPerimeter()，求周长。
public int getArea()，求面积。
toString方法，使用Eclipse自动生成。

注意：

计算圆形的面积与周长，使用Math.PI。
求周长和面积时，应先计算出其值(带小数位)，然后强制转换为int再返回。
2. main方法
输入2行长与宽，创建两个Rectangle对象放入相应的数组。
输入2行半径，创建两个Circle对象放入相应的数组。
输出1：上面2个数组中的所有对象的周长加总。
输出2：上面2个数组中的所有对象的面积加总。
最后需使用Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组
思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。

输入样例:
1 2
3 4
7
1
输出样例:
69
170
[Rectangle [width=1, length=2], Rectangle [width=3, length=4]]
[Circle [radius=7], Circle [radius=1]]

import java.util.Arrays;
import java.math.*;
import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   Rectangle[] R=new Rectangle[2];
   Circle[] C=new Circle[2];
   for(int i=0;i<2;i++) {
    R[i]=new Rectangle(scan.nextInt(),scan.nextInt());
//    
   }
   for(int i=0;i<2;i++) {
    C[i]=new Circle(scan.nextInt());
   }
   System.out.println(R[0].getPerimeter(R[0].getWidth(),R[0].getLength())+
     R[1].getPerimeter(R[1].getWidth(),R[1].getLength())+
     C[0].getPerimeter(C[0].getRadius())+
     C[1].getPerimeter(C[1].getRadius())
     );
   System.out.println(R[0].getArea(R[0].getWidth(),R[0].getLength())+
     R[1].getArea(R[1].getWidth(),R[1].getLength())+
     C[0].getArea(C[0].getRadius())+
     C[1].getArea(C[1].getRadius())
     );
   System.out.println(Arrays.deepToString(R));
   System.out.println(Arrays.deepToString(C));
  }

 }

}


class Rectangle{
 private int width,length;

 public Rectangle(int width, int length) {
  super();
  this.width = width;
  this.length = length;
 }
 public int getPerimeter(int width,int length) {
  return (width+length)*2;
 }
 public int getArea(int width,int length) {
  return width*length;
 }
 public int getWidth() {
  return width;
 }
 public void setWidth(int width) {
  this.width = width;
 }
 public int getLength() {
  return length;
 }
 public void setLength(int length) {
  this.length = length;
 }
 @Override
 public String toString() {
  return "Rectangle [width=" + width + ", length=" + length + "]";
 }
 
 
}

class Circle{
 private int radius;

 public Circle(int radius) {
  super();
  this.radius = radius;
 }
 
 public int getPerimeter(int radius) {
  return (int)(2*Math.PI*radius); 
 }
 public int getArea(int radius) {
  return (int)(Math.PI*Math.pow(radius,2));
 }
 public int getRadius() {
  return radius;
 }
public void setRadius(int radius) {
  this.radius = radius;
 }

 @Override
 public String toString() {
  return "Circle [radius=" + radius + "]";
 }
 
 
 
}

打球过程

利用模板方法来构造相关类实现下述过程：
各种球类的玩法虽然不同，但是球类比赛的过程是类似的，都包含如下几个步骤：
1球员报道-->2比赛开始-->3比赛-->4比赛结束-->5公布比赛成绩，且其中1 2 4步相同第3步根据球类不同，玩法不同，第5步根据得分不同，公布方式结果不同
构造类BallMatch表示球类比赛，包含方法compete表示真个比赛过程
构造各个比赛过程的函数checkin,start,play,end,annouceResult
打印信息如下：
now checking in
now starting
now playing football
now ending
now annoucing result: 2-3
构造类FootballMatch和BasketBallMatch，实现具体的比赛过程。

在main函数中，读入整数i，如果为1，则构造一个足球比赛过程，如果为2则构造一个篮球比赛过程
打印比赛过程

输入格式:
比赛类型比分

输出格式:
比赛过程信息

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

1 2-3
输出样例:
在这里给出相应的输出。例如：

now checking in
now starting
now playing football
now ending
now annoucing result: 2-3

import java.util.Scanner;
public class Main {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
//  int i=scan.nextInt();
  int i=scan.nextInt();
     BallMatch b=new BallMatch();
  switch (i) {
  case 1:
   FootBallMatch f=new FootBallMatch(scan.next());
   b.compete(f);
   break;
        case 2:
         BasketBallMatch bask=new BasketBallMatch(scan.next());
   b.compete(bask);
   break;
  default:
   break;
  } 
 }

}
class FootBallMatch{
 String score;
 
 public FootBallMatch(String s) {
  this.score=s;
 }
 public void checking () {
  System.out.println("now checking in");
 }
 
 public void starting() {
  System.out.println("now starting");
 }
 
 public void playing () {
  System.out.println("now playing football");
 }
 
 public void ending() {
  System.out.println("now ending");
 }
 
 public void annoucing () {
  System.out.println("now annoucing result: "+this.score);
 }
}
class BasketBallMatch{
 String score;
 
 public BasketBallMatch(String s) {
  this.score=s;
 }
 public void checking () {
  System.out.println("now checking in");
 }
 
 public void starting() {
  System.out.println("now starting");
 }
 
 public void playing () {
  System.out.println("now playing basketball");
 }
 
 public void ending() {
  System.out.println("now ending");
 }
 
 public void annoucing () {
  System.out.println("now annoucing result: "+this.score);
 }
}

class BallMatch{
 public static void compete(Object o) {
  if(o instanceof FootBallMatch) {
   FootBallMatch f=(FootBallMatch)o;
   f.checking();
   f.starting();
   f.playing();
   f.ending();
   f.annoucing();
  }else if(o instanceof BasketBallMatch) {
   BasketBallMatch b=(BasketBallMatch)o;
   b.checking();
   b.starting();
   b.playing();
   b.ending();
   b.annoucing();
  }
 }
}

sdut-谁是最强的女汉子

众所周知，一年一度的女汉子大赛又来啦。由于最近女汉子比较流行，所以参加女汉子比赛的人数变得很多很多。所以赛事组找来了你，让你写一个程序找出谁是最强的女汉子。

大家都知道，越是不漂亮的女生就越容易成为女汉子（漂亮的怎么会成为汉子？）,而越是力量大的女生也越成为女汉子（毕竟女汉子还是比较有力量的）。

所以，就给女汉子两个属性，一个是漂亮值x，一个是力量值y。当然x的值越大，就代表这个女生就越漂亮。现在想让你求出来最不漂亮的女生有多少个，她们的力量和是多少。

输入格式:
先输入一个T，代表有T个人（T<10000）。

接下来T行，每行有两个数字x,y，分别代表这个女汉子的漂亮值和力量值（x,y<2*10
9
) 。中间有1个空格分隔。

输出格式:
输出一行，有两个数字，分别代表最强的女汉子的数量，和她们的力量和。中间用1个空格分隔。

输入样例:
5
1 1
2 2
1 4
2 10
10 100
输出样例:
2 5

import java.util.ArrayList;
import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   int T=scan.nextInt();
   int power = 0;
   int count=1;
   
   girl[] g=new girl[T];
   ArrayList list=new ArrayList();
   g[0]=new girl(scan.nextInt(),scan.nextInt());
   int mix=g[0].getX();
   power=g[0].getY();
   for(int i=1;i<T;i++) {
    g[i]=new girl(scan.nextInt(),scan.nextInt());
    if(g[i].getX()<mix) {
     mix=g[i].getX();
     count=1;
     power=g[i].getY();
    }else if(g[i].getX()==mix){
     count++;
     power=power+g[i].getY();
    }
    
   }
   System.out.println(count+" "+power);
   
  }
 }
 
}

class girl{
 private int x;
 private int y;
 public int getX() {
  return x;
 }
 public void setX(int x) {
  this.x = x;
 }
 public int getY() {
  return y;
 }
 public void setY(int y) {
  this.y = y;
 }
 public girl(int x, int y) {
  super();
  this.x = x;
  this.y = y;
 }
 public girl() {
  super();
  // TODO Auto-generated constructor stub
 }
 
 
}

jmu-Java-02基本语法-03-身份证排序

输入n，然后连续输入n个身份证号。
然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。
注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。

输入样例:
6
410425198309308225
320203197206115011
431227196108033146
330226196605054190
34080019810819327X
320111197112301539
sort1
sort2
e
输出样例:
1961-08-03
1966-05-05
1971-12-30
1972-06-11
1981-08-19
1983-09-30
431227196108033146
330226196605054190
320111197112301539
320203197206115011
34080019810819327X
410425198309308225
exit

import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;
import java.text.*;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);

   int n=Integer.parseInt(scan.nextLine()) ;
   String[] s=new String[n];
   String[] date=new String[n];
   for(int i=0;i<n;i++) {
    s[i]=scan.nextLine();
    date[i]=s[i].substring(6,14);
   }
    Arrays.sort(date);
    Arrays.sort(s);
    while(scan.hasNext()) {
    switch (scan.nextLine()) {
    case "sort1":
    for(int i=0;i<n;i++) {
     try {
      Date date1=new SimpleDateFormat("yyyyMMdd").parse(date[i]);
      System.out.println(new SimpleDateFormat("yyyy-MM-dd").format(date1));
     } catch (ParseException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
    break;
    case "sort2":
             for(int i=0;i<n;i++) {
              for(int j=0;j<n;j++) {
               if(date[i].equals(s[j].substring(6,14))) {
                System.out.println(s[j]);
               }
              }
       }
    break;
    
    default:
    System.out.println("exit");
    break;
   }
   
  }
 }
 
}

jmu-Java-02基本语法-08-ArrayList入门

本习题主要用于练习如何使用ArrayList来替换数组。
新建1个ArrayList strList用来存放字符串，然后进行如下操作。

提示: 查询Jdk文档中的ArrayList。
注意: 请使用System.out.println(strList)输出列表元素。

输入格式
输入: n个字符串，放入strList。直到输入为!!end!!时，结束输入。

在strList头部新增一个begin，尾部新增一个end。

输出列表元素

输入: 字符串str

判断strList中有无包含字符串str，如包含输出true，否则输出false。并且输出下标，没包含返回-1。

在strList中从后往前找。返回其下标，找不到返回-1。

移除掉第1个(下标为0)元素,并输出。然后输出列表元素。

输入: 字符串str

将第2个（下标为1）元素设置为字符串str.

输出列表元素

输入: 字符串str

遍历strList，将字符串中包含str的元素放入另外一个ArrayList strList1，然后输出strList1。

在strList中使用remove方法，移除第一个和str相等的元素。

输出strList列表元素。

使用clear方法，清空strList。然后输出strList的内容，size()与isEmpty()，3者之间用,连接。

输入样例:
a1 b1 3b a2 b2 12b c d !!end!!
b1
second
b
输出样例:
[begin, a1, b1, 3b, a2, b2, 12b, c, d, end]
true
2
2
begin
[a1, b1, 3b, a2, b2, 12b, c, d, end]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[3b, b2, 12b]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[],0,true

import java.util.Scanner;
import java.util.ArrayList;

public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan=new Scanner(System.in);
        ArrayList<String> strList=new ArrayList<>();
        strList.add("begin");
        while(scan.hasNext()) {
        	String s=scan.next();
        	if(s.equals("!!end!!")) {
             break;
        	}	
        	strList.add(s);
        }
        strList.add("end");
        System.out.println(strList);
        String str=scan.next();
        if(strList.contains(str)) {
        	System.out.println(true);
        	System.out.println(strList.indexOf(str));
        }else 
        {
        	System.out.println(false);
        	System.out.println("-1");
        }
        boolean flag=true;
        for (int i = strList.size() - 1; i >= 0; i--) {
            if (strList.get(i).equals(str)){
                System.out.println(i);
                flag = false;
                break;
            }
        }
        if (flag){
            System.out.println("-1");
        }
        System.out.println(strList.get(0));
        strList.remove(0);
        System.out.println(strList);
        str=scan.next();
        strList.set(1, str);
        System.out.println(strList);
        
        str=scan.next();
        ArrayList<String> strList1 = new ArrayList<>();
        for (String s : strList){
            if (s.contains(str)){
                strList1.add(s);
            }
        }
        System.out.println(strList1);
        for (String s : strList){
            if (s.equals(str)){
                strList.remove(str);
                break;
            }
        }
        System.out.println(strList);
        strList.clear();
        System.out.println(strList+","+strList.size()+","+strList.isEmpty());
	}
	
}

找出最长的单词

找出长度最长的单词（不同长度的单词只出现一次）。

输入格式:
输入格式为单行形式，单词之间使用空格分割。

输出格式:
输出格式为长度最长的一个单词。

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

an not need happy suggest
输出样例:
在这里给出相应的输出。例如：

suggest

import java.util.Scanner;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan=new Scanner(System.in);
		String str=scan.nextLine();
		String[] a=str.split(" ");
		str=a[0];
        for(int i=0;i<a.length;i++)
        {
        	if(a[i].length()>str.length()){
        		str=a[i];
        	}
        }
	    System.out.print(str);
	}

}

jmu-Java&Python-统计一段文字中的单词个数并按单词的字母顺序排序后输出

现需要统计若干段文字(英文)中的不同单词数量。
如果不同的单词数量不超过10个，则将所有单词输出(按字母顺序)，否则输出前10个单词。

注1：单词之间以空格(1个或多个空格)为间隔。
注2：忽略空行或者空格行。
注3：单词大小写敏感，即'word'与'WORD'是两个不同的单词。

输入说明
若干行英文，最后以!!!!!为结束。

输出说明
不同单词数量。
然后输出前10个单词（按字母顺序），如果所有单词不超过10个，则将所有的单词输出。

输入样例
Failure is probably the fortification in your pole
It is like a peek your wallet as the thief when you
are thinking how to spend several hard-won lepta
when you Are wondering whether new money it has laid
background Because of you, then at the heart of the
most lax alert and most low awareness and left it
godsend failed
!!!!!
输出样例
49
Are
Because
Failure
It
a
alert
and
are
as
at

import java.util.*;
public class Main {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set<String> words = new TreeSet<>();
		Scanner sc = new Scanner(System.in);
		while(true)
		{
			String ss = sc.next();
			if(ss.equals("!!!!!"))
				break;
			else
				words.add(ss);
		}
		System.out.println(words.size());
		if(words.size() < 10)
		{
			for(String s : words)
				System.out.println(s);
		}
		else
		{
			int count = 0;
			for(String s : words)
			{
				if(count++ > 9)
					break;
				System.out.println(s);
			}
		}
		sc.close();
	}
}

jmu-Java-m06 统计一篇英文文章中出现的不重复单词的个数

输入一篇英文文章，碰到"!!!!!"的时候停止，输出文章中出现的不重复单词的个数(注意：单词不区分大小写，如：The和the为一个单词)

输入格式:
一篇英文文章，以"!!!!!"结尾

输出格式:
不重复单词的个数

输入样例:
Unmanned aerial vehicles have been adopted in the inspection of violations Procurators will file public interest litigations against perpetrators who will need to replant trees take down illegal buildings control pollution and compensate environment-related losses
The Yellow River is the second longest river in China It originates in the northwestern province of Qinghai and runs through nine provinces and autonomous regions in western central north and eastern China
!!!!!
输出样例:
55

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set<String> set=new HashSet<>();
		Scanner sc = new Scanner(System.in);
		while (true) {
			String str=sc.next();
			if(str.equals("!!!!!")){
				break;
			}
			set.add(str.toLowerCase());
		}

    	System.out.println(set.size());

	}

}

sdut-array2-4 打印“杨辉三角“ 品中国数学史增民族自豪感

背景介绍：北宋人贾宪约1050年首先使用“贾宪三角”进行高次开方运算。

南宋数学家杨辉在《详解九章算法》（1261年）记载并保存了“贾宪三角”，故称杨辉三角。杨辉三角是中国数学史上的一个伟大成就。
杨辉三角，是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合。

中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲，帕斯卡（1623----1662）在1654年发现这一规律，所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年，比贾宪迟600年。

杨辉三角数字的特点为：

（1）在三角形的首列和对角线上，数值均为1；

（2）其余数据为：每个数字等于上一行的左右两个数字之和，第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，用公式表示为： C(n+1,i)=C(n,i)+C(n,i-1)。

图示为：

杨辉三角的应用：(a+b)的n次方，展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项。

输入格式:
欲打印杨辉三角的行数n（1<=n<=13)。

输出格式:
每个数字占据4个字符的位置，数字左对齐，数字不足4位的右边留出空格。

输入样例:
13
输出样例:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1

import java.util.Scanner;
public class Main {
 
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int yanghui[][] = new int[n][];
		for(int i=0; i<yanghui.length; i++) {
			yanghui[i] = new int[i+1];
		}
		
		for(int i=0; i<yanghui.length; i++) {
			for(int j=0; j<yanghui[i].length; j++) {
				yanghui[i][0] = 1;
				yanghui[i][i] = 1;
				
				if(i>1 && j>0 && j<i) {
					yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
				}
			}
		}

	for(int i=0; i<yanghui.length; i++) {//控制行数
			for(int j=0; j<yanghui[i].length; j++) {
		    if(yanghui[i][j]<10) {
			System.out.print(yanghui[i][j]+"   ");
		    }
		    else if(yanghui[i][j]>=10 && yanghui[i][j]<100){
				System.out.print(yanghui[i][j]+"  ");
			}
			else{
				System.out.print(yanghui[i][j]+" ");
			}
		   
		}
			 System.out.println();
	}
}
}

找到出勤最多的人

根据教师的花名册，找到出勤最多的人。

输入格式:
出勤记录单行给出，数据直接使用空格分割。

输出格式:
单行输出（若有多人，人名直接使用空格分割，结尾处没有空格）。

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

zs ls ww ml zs ls ml zs ww
输出样例:
在这里给出相应的输出。例如：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Objects;
import java.util.Scanner;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        String[] str1=str.split(" ");
        ArrayList<String> student = new ArrayList<String>();
        
        int max=0;
        for (int i = 0; i < str1.length; i++) {
        	String max1=str1[i];
        	int c=1;
        	for(int j=i+1;j<str1.length;j++) {
        		if(max1.equals(str1[j])) {
        			c++;
        		}
        	}
        	if(c==max) {
        		student.add(max1);
        	}else if(c>max) {
        		max=c;
        		student.clear();
        		student.add(max1);
        	}
        }
        int c=0;
        for(String a:student) {
        	if(c==student.size()-1)
        		System.out.print(a);
        	else 
        		System.out.print(a+" ");
        	c++;
        }
	}

}

jmu-Java-03面向对象基础-04-形状-继承

前言
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。

本题描述
1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()

2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。
toString方法(Eclipse自动生成)

3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与
double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。

4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;

注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。

思考
你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适？
是否应该声明为static?
输入样例:
4
rect
3 1
rect
1 5
cir
1
cir
2
输出样例:
38.84
23.700000000000003
[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
class Circle,class Shape

import java.util.*;
public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
    	int n = in.nextInt();
    	in.nextLine();
    	Shape [] shapes = new Shape[n];
    	for(int i=0;i<n;i++){
    		String shape = in.nextLine();
    		if(shape.equals("rect")) {
    			int width = in.nextInt();
    			int length = in.nextInt();
    			in.nextLine();
    			shapes[i] = new Rectangle(width, length);
    		}
    		else {
    			int radius = in.nextInt();
    			in.nextLine();
    			shapes[i] = new Circle(radius);
    		}
    	}
    	System.out.println(sumAllPerimeter(shapes));
    	System.out.println(sumAllArea(shapes));
    	System.out.println(Arrays.toString(shapes));
    	for(Shape s:shapes) {
    		System.out.println(s.getClass()+","+s.getClass().getSuperclass());
    	}
		
	}
	public static double sumAllArea(Shape[] shapes) {
    	double sum = 0;
    	
    	for(Shape s:shapes) {
    		sum+=s.getArea();
    	}
    	return sum;
    }
	
    public static double sumAllPerimeter(Shape[] shapes) {
    	double sum = 0;
    	
    	for(Shape s:shapes) {
    		sum+=s.getPerimeter();
    	}
    	return sum;
    }

}
abstract  class Shape{
	static final double  PI=3.14;
	public abstract double getPerimeter();
	
	public abstract double getArea();
}
class Rectangle extends Shape{
	private int width;
	private int length;
	public Rectangle(int width,int length) {
		this.width = width;
		this.length = length;
	}
	public double getPerimeter() {
		return 2*(this.width+this.length);
	}
	public double getArea() {
		return this.width*this.length;
	}

	public String toString() {
		return "Rectangle [width=" + width + ", length=" + length + "]";
	}

  }

class Circle extends Shape{
	int radius;

	public Circle(int radius) {
		this.radius = radius;
	}


	public double getPerimeter() {
		// TODO Auto-generated method stub
		return PI*this.radius*2;
	}


	public double getArea() {
		// TODO Auto-generated method stub
		return PI*this.radius*this.radius;
	}
	
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
  }

jmu-Java-03面向对象基础-05-覆盖

Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。

新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。

b. 有参构造方法，参数为name, age, gender

c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true

d.toString()方法返回格式为：name-age-gender

e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.

main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。

提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。

输入样例:
1
3
zhang 10 true
zhang 10 true
zhang 10 false
输出样例:
default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner se=new Scanner (System.in);
        int n1=se.nextInt();
        PersonOverride persons1[] =new PersonOverride[n1];
        for(int i=0;i<n1;i++) {
        	persons1[i]=new PersonOverride();
        	System.out.println(persons1[i].toString());
        }
        int n2=se.nextInt();
        ArrayList<PersonOverride> persons2=new ArrayList<PersonOverride>();
        for(int i=0;i<n2;i++) {
        	PersonOverride a=new PersonOverride(se.next(),se.nextInt(),se.nextBoolean());
        	if(!persons2.contains(a)) {
        		persons2.add(a);
        		System.out.println(a.toString());
        	}
        }
        System.out.println(persons2.size());
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

class PersonOverride {
	private String name;
	private int age;
	private boolean gender;
  public PersonOverride() {
		this.name = "default";
		this.age = 1;
		this.gender = true;
	}
	public PersonOverride(String name, int age, boolean gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	@Override
	public String toString() {
		return  name + "-" + age + "-" + gender;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		PersonOverride other = (PersonOverride) obj;
		if (age != other.age)
			return false;
		if (gender != other.gender)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public boolean isGender() {
		return gender;
	}
	public void setGender(boolean gender) {
		this.gender = gender;
	}
}

jmu-Java-04面向对象进阶-01-接口-Comparable

编写实现Comparable接口的PersonSortable类，使其按name以及age排序

1.编写PersonSortable类
属性：private name(String)、private age(int)
有参构造函数：参数为name,age
toString函数：返回格式为：name-age
实现Comparable接口：实现先对name升序排序，如果name相同则对age进行升序排序

2.main方法中
首先输入n
输入n行name age，并创建n个对象放入数组
对数组进行排序后输出。
最后一行使用System.out.println(Arrays.toString(PersonSortable.class.getInterfaces()));输出PersonSortable所实现的所有接口
输入样例:
5
zhang 15
zhang 12
wang 14
Wang 17
li 17
输出样例:
Wang-17
li-17
wang-14
zhang-12
zhang-15
//这行是标识信息


import java.util.*;
public class Main{
	public static void main(String[] args) {
		 Scanner scan=new Scanner(System.in);
		 int n=scan.nextInt();
		 PersonSortable[] personSortable=new PersonSortable[n];
		 for(int i=0;i<n;i++) {
			 PersonSortable p=new PersonSortable(scan.next(),scan.nextInt());
			 personSortable[i]=p;
		 }
		 Arrays.sort(personSortable);
		 for(int i=0;i<n;i++) {
			System.out.println(personSortable[i].toString());
		 }
		 System.out.println(Arrays.toString(PersonSortable.class.getInterfaces()));
	}
}
class PersonSortable implements Comparable<PersonSortable>{
	
	private String name;
	private int age;

	public PersonSortable(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return  name + "-" + age;
	}
	@Override
	public int compareTo(PersonSortable o) {
		// TODO Auto-generated method stub
		if(this.name.compareTo(o.name)>0)
			return 1;
		else if(this.name.compareTo(o.name)<0)
			return -1;
		else {
			if(this.age<o.age)return -1;
			else return 1;
		}

	}
	
	
}

jmu-Java-04面向对象进阶--02-接口-Comparator

Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。

1.编写PersonSortable2类
属性：private name(String)、private age(int)
有参构造函数：参数为name,age
toString方法：返回格式name-age

2 编写Comparator类
编写NameComparator类，实现对name进行升序排序
编写AgeComparator类，对age进行升序排序
3.main方法中
输入n
输入n行name age，并创建n个对象放入数组
对数组按照name进行升序排序后输出。
在3的基础上对数组按照age进行升序排序后输出。
最后最后两行使用如下代码输出NameComparator与AgeComparator所实现的所有接口。
System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
输入样例:
5
zhang 15
zhang 12
wang 14
Wang 17
li 17

输出样例:
NameComparator:sort
Wang-17
li-17
wang-14
zhang-15
zhang-12
AgeComparator:sort
zhang-12
wang-14
zhang-15
Wang-17
li-17
//最后两行是标识信息



import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		 Scanner scan=new Scanner(System.in);
		 int n=scan.nextInt();
		 PersonSortable2[] personSortable=new PersonSortable2[n];
		 for(int i=0;i<n;i++) {
			 PersonSortable2 p=new PersonSortable2(scan.next(),scan.nextInt());
			 personSortable[i]=p;
		 }
		 Arrays.sort(personSortable, new NameComparator());
			System.out.println("NameComparator:sort");
			for(PersonSortable2 i:personSortable) {
				System.out.println(i);
			}
			
		Arrays.sort(personSortable, new AgeComparator());
			System.out.println("AgeComparator:sort");
			for(PersonSortable2 i:personSortable) {
					System.out.println(i);
				}
				
				
				
		 System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
		 System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
	}
}


class PersonSortable2{
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public PersonSortable2(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return  name + "-" + age;
	}
	
}

class NameComparator implements Comparator<PersonSortable2>{

	@Override
	public int compare(PersonSortable2 o1, PersonSortable2 o2) {
		// TODO Auto-generated method stub
		if(o1.getName().compareTo(o2.getName())>0)
			return 1;
		else if(o1.getName().compareTo(o2.getName())<0)
		    return -1;
		else 
			 return 0;
	}
	
}

class AgeComparator implements Comparator<PersonSortable2>{

	@Override
	public int compare(PersonSortable2 o1, PersonSortable2 o2) {
		return (int)o1.getAge()-o2.getAge();
	}
}

jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company

定义Person抽象类，Student类、Company类，Employee类。

Person类的属性：String name, int age, boolean gender
Person类的方法:

public Person(String name, int age, boolean gender);
public String toString(); //返回"name-age-gender"格式的字符串
public boolean equals(Object obj);//比较name、age、gender,都相同返回true,否则返回false
Student类继承自Person，属性:String stuNo, String clazz
Student类的方法:

//建议使用super复用Person类的相关有参构造函数
public Student(String name, int age, boolean gender, String stuNo, String clazz);
public String toString(); //返回 “Student:person的toString-stuNo-clazz”格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true，则继续比较stuNo与clazz。
Company类属性：String name
Company类方法:

public Company(String name);
public String toString(); //直接返回name
public boolean equals(Object obj);//name相同返回true
Employee类继承自Person，属性：Company company, double salary
Employee类方法：

//建议使用super复用Person类的相关有参构造函数
public Employee(String name, int age, boolean gender, double salary, Company company);
public String toString(); //返回"Employee:person的toString-company-salary"格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true。再比较company与salary。
//比较salary属性时，使用DecimalFormat df = new DecimalFormat("#.#");保留1位小数
编写equals方法重要说明：

对Employee的company属性的比较。要考虑传入为null的情况。如果company不为null且传入为null，返回false
对所有String字符类型比较时，也要考虑null情况。
提示

排序可使用Collections.sort
equals方法要考虑周全
main方法说明
创建若干Student对象、Employee对象。
输入s，然后依次输入name age gender stuNo clazz创建Student对象。
输入e，然后依次输入name age gender salary company创建Employee对象。
然后将创建好的对象放入List personList。输入其他字符，则结束创建。
创建说明: 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。

对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用Comparable或Comparator

接受输入，如果输入为exit则return退出程序，否则继续下面步骤。

将personList中的元素按照类型分别放到stuList与empList。注意：不要将两个内容相同的对象放入列表（是否相同是根据equals返回结果进行判定）。

输出字符串stuList，然后输出stuList中的每个对象。

输出字符串empList，然后输出empList中的每个对象。

1-3为一个测试点
4-6为一个测试点

输入样例：
s zhang 23 false 001 net15
e wang 18 true 3000.51 IBM
s zhang 23 false 001 net15
e bo 25 true 5000.51 IBM
e bo 25 true 5000.52 IBM
e bo 18 true 5000.54 IBM
e tan 25 true 5000.56 IBM
e tan 25 true 5000.51 IBM
s wang 17 false 002 null
s wang 17 false 002 null
e hua 16 false 1000 null
s wang 17 false 002 net16
e hua 16 false 1000 null
e hua 18 false 1234 MicroSoft
!
continue
输出样例：
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:bo-25-true-IBM-5000.52
Employee:hua-16-false-null-1000.0
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Student:wang-17-false-002-null
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Employee:wang-18-true-IBM-3000.51
Student:zhang-23-false-001-net15
Student:zhang-23-false-001-net15
stuList
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Student:zhang-23-false-001-net15
empList
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Employee:wang-18-true-IBM-3000.51

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws InterruptedException {
       Scanner sc=new Scanner(System.in);
       List<Person> personList=new ArrayList<Person>();
       String name;
       int age;
       boolean gender;
       String stuNo;
       String clazz;
       String companyName;
       Company company;
       double salary;
       //输入
       while(true) {
    	   String t=sc.next();
    	   if(t.equals("s")) {
    		   name=sc.next();
    		   age=sc.nextInt();
    		   gender=sc.nextBoolean();
    		   stuNo=sc.next();
    		   clazz=sc.next();
    		   if(name==null||stuNo==null||clazz==null) {
    			   continue;
    		   }
    		   personList.add(new Student(name, age, gender, stuNo, clazz));
    		   
	       }else if(t.equals("e")){
	    	   name=sc.next();
    		   age=sc.nextInt();
    		   gender=sc.nextBoolean();
    		   salary=sc.nextDouble();
    		   companyName=sc.next();
    		   company=new Company(companyName);
    		   if(name==null) {
    			   continue;
    		   }
    		   //除了companyName可以为空，其他为空均不能创建对象（应该是这么理解吧）
    		   if(companyName==null) {
    			   companyName="null";   //为空的话要给他赋值为空（删了也能过 可能写了句废话 ）
    		   }
	    	   personList.add(new Employee(name, age, gender, company, salary));
	       }else{         //要是遇到感叹号就该结束输入啦（题目上好像没说）
	    	   break;
	       }
	      
       }
        //排序（因为之前的类都建好了，Person类还是抽象类，所以比较器只能用Comparator了）
       Collections.sort(personList, new Name_AgeComparator());
      
       for(int i=0;i<personList.size();i++) {
    	   
    		   System.out.println(personList.get(i).toString()); 
    	  
       }
      //只要不输入return和exit就要分组啦
       String str=sc.next();
       while(true) {
    	   if(str.equals("return")||str.equals("exit")) {
    		   break;
    	   }else {
        	   //分组
               List<Person> stuList=new ArrayList<Person>();
               List<Person> empList=new ArrayList<Person>();
               //判断过程要根据equals 是自己定义的 所以比较工资那有坑，用contains是不行的 所以还是循环比较吧
               boolean flag1=true;
               boolean flag2=true;
               for(int i=0;i<personList.size();i++) {
            	   if(personList.get(i).toString().indexOf("Student")>=0) {
            		   if(stuList.size()==0) {
            			   stuList.add(personList.get(i));
            		   }
            		   for(int j=0;j<stuList.size();j++) {
            			   if(personList.get(i).equals(stuList.get(j))){
            				   flag1=false;
            			   }
            		   }
            		   if(flag1) {
            			   stuList.add(personList.get(i));
            			   
            		   }
            		   flag1=true;
            	   }else {
            		   if(empList.size()==0) {
            			   empList.add(personList.get(i));
            		   }
            		   for(int j=0;j<empList.size();j++) {
            			   if(personList.get(i).equals(empList.get(j))){
            				   flag2=false;
            			   }
            		   }
            		   if(flag2) {
            			   empList.add(personList.get(i));
            		   }
            		   flag2=true;
            	   }
               }
               System.out.println("stuList");
               for(int i=0;i<stuList.size();i++) {
            	   
        		   System.out.println(stuList.get(i).toString()); 
        	  
               }
               System.out.println("empList");
               for(int i=0;i<empList.size();i++) {
            	   
        		   System.out.println(empList.get(i).toString()); 
        	  
               }
               break;
           } 
    	   }

       
       
    }
    //Comparator需要创建一个类，又因为想在main方法里直接调，所以就要用static修饰
    static class Name_AgeComparator implements Comparator<Person>{  //不加这个泛型也可以，但以后要强制转换

		@Override
		public int compare(Person o1, Person o2) {
			 if(o1.name.compareTo(o2.name)==0) {
				if(o1.age==o2.age) {
					return 0;
				}else if(o1.age<o2.age) {
					return -1;
				}else {
					return 1;
				}
			}else {
				//比较字符串的方法（放张图片吧）
				return(o1.name.compareTo(o2.name));
			}
		}
    	
    }
    
    
}
abstract class Person{
	String name;
	int age;
	boolean gender;
	public Person(String name, int age, boolean gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	@Override
	public String toString() {
		
		return this.name+'-'+String.valueOf(this.age)+'-'+String.valueOf(this.gender);
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (gender != other.gender)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}
class Student extends Person{
	String stuNo;
	String clazz;
	public Student(String name, int age, boolean gender, String stuNo, String clazz) {
		super(name,age,gender);
		this.clazz=clazz;
		this.stuNo=stuNo;
	}
	@Override
	public String toString() {
		return"Student:"+ super.toString()+'-'+this.stuNo+'-'+this.clazz;
	}
	@Override
	public boolean equals(Object obj) {
		if (!super.equals(obj))
			return false;
		if (this == obj)
			return true;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (clazz == null) {
			if (other.clazz != null)
				return false;
		} else if (!clazz.equals(other.clazz))
			return false;
		if (stuNo == null) {
			if (other.stuNo != null)
				return false;
		} else if (!stuNo.equals(other.stuNo))
			return false;
		return true;
	}
	
	
}
class Company{
	String name;
	public Company(){
		
	}
	public Company(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return name;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Company other = (Company) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
}
class Employee extends Person{
	Company company;
	double salary;
	public Employee(String name, int age, boolean gender, Company company, double salary) {
		super(name, age, gender);
		this.company = company;
		this.salary = salary;
	}
	@Override
	public String toString() {
		return "Employee:"+ super.toString()+'-'+company+'-'+salary;
	}
	@Override
	public boolean equals(Object obj) {
		if (!super.equals(obj))
			return false;
		if (this == obj)
			return true;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (company == null) {
			if (other.company != null)
				return false;
		} 
		else if (!company.equals(other.company))
			return false;
		//坑在这啊，要用decimal比较，要学会decimal这种用法
		DecimalFormat df = new DecimalFormat("#.#");
		if (!df.format(salary) .equals( df.format(other.salary)))
			return false;
		return true;
	}
	
	
	
	
}

jmu-Java-02基本语法-01-综合小测验

运行程序后可以输入4个选项，分别为：fib,sort,search,getBirthDate

fib:根据输入n，打印斐波那契数列。比如输入：3，输出：1 1 2

sort:输入一串数字，然后进行排序并输出，注意数组元素输出的格式为使用[ ]包括。提示：可直接使用函数Arrays相关方法处理输出。

search:如果找到返回所找到的位置，如果没找到，返回-1。提示：可以先对数组排序，然后使用Arrays相关函数进行查找。

getBirthDate:输入n个身份证，然后把输入的n个身份号的年月日抽取出来，按年-月-日格式输出。

当输入不是这几个字符串(fib,sort,search,getBirthDate)的时候，显示exit并退出程序。

注意：在处理输入的时候，尽量只使用Scanner的nextLine()方法接收输入，不要将nextLine()与其它next方法混用，否则可能会出现行尾回车换行未处理影响下次输入的情况。

参考：jdk文档的Arrays，String

输入格式:
fib
3
sort
-1 10 3 2 5
search
-1
search
0
getBirthDate
1
330226196605054190
e
输出格式:
1 1 2
[-1, 2, 3, 5, 10]
0
-1
1966-05-05
exit

import java.util.*;


public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Scanner scan=new Scanner(System.in);
        Helper h=new Helper();
        while (scan.hasNext()) {
			String str=scan.next();
			if(str.equals("fib")) {
			     h.fib(scan.nextInt());
			}
			else if(str.equals("sort")) {
				 List<Integer> sortList = new ArrayList<>();
	                while (scan.hasNextInt()) {
	                    sortList.add(scan.nextInt());
	                }
	                Integer[] in=new Integer[sortList.size()];
	                for(int i=0;i<in.length;i++) {
	            	   in[i]=sortList.get(i);
	               }
	                h.sort(in);

			}
			else if(str.equals("search")) {
				 h.search(scan.nextInt());
			}
			else if(str.equals("getBirthDate")) {
				   int n = scan.nextInt();
	                for (int i = 0; i < n; i++) {
	                    String identityCardNum = scan.next();
	                    h.getBirthDate(identityCardNum);
	                }

	        }
			else {
				System.out.println("exit");
			}
			
	}

 }
}
	
class Helper {
    private Integer[] sortedArray;
    void fib(int n) {
         if (n == 1) {
            System.out.println("1");
            return;
        } else if (n == 2) {
            System.out.println("1 1");
            return;
        }

        int[] num = new int[n];
        num[0] = 1; num[1] = 1;

        System.out.print("1 1");
        for (int i = 2; i < n; i++) {
            num[i] = num[i - 1] + num[i - 2];
            System.out.print(" " + num[i]);
        }
        System.out.println();
    }
    void sort(Integer nums[]) {

        Arrays.sort(nums);
        sortedArray = nums;
        System.out.println(Arrays.toString(nums));
    }
    void search(int searchNum) {
        int ret = Arrays.binarySearch(sortedArray, searchNum);
        if (ret < 0) {
            System.out.println(-1);
        } else {
            System.out.println(ret);
        }
    }
    void getBirthDate(String identityCardNum) {
        System.out.println(identityCardNum.substring(6, 10) + "-"
        + identityCardNum.substring(10, 12) + "-" + identityCardNum.substring(12, 14));

    }
}

jmu-Java-06异常-01-常见异常

自行编码产生常见异常。

main方法
事先定义好一个大小为5的数组。
根据屏幕输入产生相应异常。
提示：可以使用System.out.println(e)打印异常对象的信息，其中e为捕获到的异常对象。

输入说明:
arr 代表产生访问数组是产生的异常。然后输入下标，如果抛出ArrayIndexOutOfBoundsException异常则显示，如果不抛出异常则不显示。
null，产生NullPointerException
cast，尝试将String对象强制转化为Integer对象，产生ClassCastException。
num，然后输入字符，转化为Integer，如果抛出NumberFormatException异常则显示。
其他，结束程序。
输入样例：
arr 4
null
cast
num 8
arr 7
num a
other
输出样例：
java.lang.NullPointerException
java.lang.ClassCastException: class java.lang.String cannot be cast to class java.lang.Integer (java.lang.String and java.lang.Integer are in module java.base of loader 'bootstrap')
java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 5
java.lang.NumberFormatException: For input string: "a"

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int[] i = new int[5];
        String s = null;
        while(sc.hasNext()){
            s = sc.next();
            if(s.equals("arr")){
                try{
                    int a = i[sc.nextInt()];
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else if(s.equals("null")){
                try{
                    String str = null;
                    int b = str.length();
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else if(s.equals("cast")){
                try{
                    Object str1 = "cast";//用Object接收才能向下转型
                    int c = (Integer)str1;//若用int定义str1，不能向Integer转型，程序报错
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else if(s.equals("num")){
                try{
                    String str2 = sc.next();
                    int d = Integer.parseInt(str2);
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else System.exit(0);
        }
    }
}

jmu-Java-06异常-02-使用异常机制处理异常输入

使用异常处理输入机制，让程序变得更健壮。

main方法：
输入n，创建大小为n的int数组。
输入n个整数，放入数组。输入时，有可能输入的是非整型字符串，这时候需要输出异常信息，然后重新输入。
使用Arrays.toString输出数组中的内容。
输入样例：
5
1
2
a
b
4
5
3
输出样例：
java.lang.NumberFormatException: For input string: "a"
java.lang.NumberFormatException: For input string: "b"
[1, 2, 4, 5, 3]

import java.util.*;
public class Main { 
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int []a = new int [n];
		int num = 0;
		for(int i = 0;i < n;i++)
		{
			String s = sc.next();
			try {
				int t = Integer.parseInt(s);
				a[num++] = t;
			}catch(Exception e)
			{
				System.out.println("java.lang.NumberFormatException: For input string: \""+ s +"\"");
				i--;//相当于刚才输入的这个不算
			}
		}
		System.out.println(Arrays.toString(a));
		sc.close();
	}
}

jmu-Java-06异常-04-自定义异常(综合)

定义IllegalScoreException异常类，代表分数相加后超出合理范围的异常。该异常是checked exception，即希望该异常一定要被捕获处理。

定义IllegalNameException异常类，代表名字设置不合理的异常。该异常是unchecked exception

定义Student类。

属性:

private String name;
private int score;
方法:

toString //自动生成
setter/getter //自动生成
改造setName //如果姓名首字母为数字则抛出IllegalNameException
public int addScore(int score) //如果加分后分数<0 或>100，则抛出IllegalScoreException，加分不成功。
main方法
输入new则新建学生对象。然后输入一行学生数据，格式为姓名年龄，接着调用setName，addScore。否则跳出循环。
setName不成功则抛出异常，并打印异常信息，然后继续下一行的处理。
addScore不成功则抛出异常，并打印异常信息，然后继续下一行的处理。如果2、3都成功，则打印学生信息(toString)
如果在解析学生数据行的时候发生其他异常，则打印异常信息，然后继续下一行的处理。
Scanner也是一种资源，希望程序中不管有没有抛出异常，都要关闭。关闭后，使用System.out.println("scanner closed")打印关闭信息
注意：使用System.out.println(e);打印异常信息，e为所产生的异常。

输入样例：
new
zhang 10
new
wang 101
new
wang30
new
3a 100
new
wang 50
other
输出样例：
Student [name=zhang, score=10]
IllegalScoreException: score out of range, score=101
java.util.NoSuchElementException
IllegalNameException: the first char of name must not be digit, name=3a
Student [name=wang, score=50]
scanner closed

import java.util.Scanner;
class IllegalNameException extends Exception{//自定义异常类，继承Exception类
    public IllegalNameException(){}
    public IllegalNameException(String msg){super(msg);}
    public IllegalNameException(String msg, Throwable cause){super(msg, cause);}
    public IllegalNameException(Throwable cause){super(cause);}
}
class IllegalScoreException extends  Exception{
    public IllegalScoreException(){}
    public IllegalScoreException(String msg){super(msg);}
    public IllegalScoreException(String msg, Throwable cause){super(msg, cause);}
    public IllegalScoreException(Throwable cause){super(cause);}
}
class Stu{
    private String name; private int score; private int flag = 0;
    public int getFlag(){return this.flag;}
    public Stu(String name, int score)throws Exception{this.setName(name); this.addScore(score);}
    public String getName(){return this.name;}
    public int getScore(){return this.score;}
    public void setScore(int score){this.score = score;}
    public void setName(String name) throws IllegalNameException{
        try{
            char c = name.charAt(0);
            if(c>'0'&&c<'9'){
                throw new IllegalNameException();//抛出异常
            }//若抛出异常则不修改标志位，flag为0
            this.name = name; flag = 1;//标志位为1才能进行addScore()
        }catch(IllegalNameException e){//异常处理
            System.out.println("IllegalNameException: the first char of name must not be digit, name="+name);
        }
    }
    public int addScore(int score){
        if(flag==1){
            try {
                this.score += score;
                if(this.score < 0 || this.score > 100){throw new IllegalScoreException();}
            }
            catch(IllegalScoreException e){
                flag = 0;//抛出异常即处理，而标志位为0，结合主程序，不输出学生信息
                System.out.println("IllegalScoreException: score out of range, score="+this.score);
            }
        }
        return this.score;
    }
    public String toString(){
        return "Student [name="+this.name+", score="+this.score+"]";
    }
}
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in); String str = null;
        while(true){
            str = sc.nextLine();
            if(str.equals("new")){
                String[] s = sc.nextLine().split(" ");
                if(s.length!=2){
                    System.out.println("java.util.NoSuchElementException");
                }
                else{
                    try{
                        Stu stu = new Stu(s[0], Integer.parseInt(s[1]));
                        if(stu.getFlag()==1){//setName()和addScore()都合法才能赋标志位为1
                            System.out.println(stu);
                        }
                    }catch(Exception e){
                        System.out.println(e);
                    }
                }
            }
            else{
                System.out.println("scanner closed");
                sc.close();//关闭输出流
                System.exit(0);
            }
        }
    }
}

天不假年

程序填空题。根据题目要求完善下面的代码。请提交完整代码。
“今年50，明年18”是一个美好的愿望。人的年龄只能不断增长。
Person类的setAge方法用于更新年龄。
如果新的年龄比原来的年龄小，则输出B表示发现异常，否则输出A表示正常。

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int age;
age = in.nextInt();
Person p = new Person(age);
age = in.nextInt();
try{
p.setAge(age);
}catch(AgeException e){
}
}
}
class Person{
int age;
public Person(int age){
this.age = age;
}
public void setAge(int age) throws AgeException {
if(this.age <=age){
this.age = age;
}else{
throw new AgeException();
}
}
}
class AgeException extends Exception{
}
输入格式:
输入在一行中给出2个绝对值不超过100的正整数A和B。

输出格式:
在一行中输出一个字符A或者B。

输入样例:
50 18
输出样例:
B

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int age;
        age = in.nextInt();
        Person p = new Person(age);        
        age = in.nextInt();
        try{
            p.setAge(age); 
            System.out.print("A");
        }catch(AgeException e){             
        }       
    }
}
class Person{
   int age;
   public Person(int age){
       this.age = age;
   }
   public void setAge(int age) throws AgeException {
       if(this.age <=age){
          this.age = age;
       }else{
         throw new AgeException();
       }
   }   
}
class AgeException extends Exception{
    public AgeException(){
        System.out.print("B");
    }
}

成绩录入时的及格与不及格人数统计

编写一个程序进行一个班某门课程成绩的录入，能够控制录入成绩总人数，对录入成绩统计其及格人数和不及格人数。设计一个异常类，当输入的成绩小0分或大于100分时，抛出该异常类对象，程序将捕捉这个异常对象，并调用执行该异常类对象的toString（）方法，该方法获取当前无效分数值，并返回一个此分数无效的字符串。

输入格式:
从键盘中输入学生人数n

从键盘中输入第1个学生的成绩

从键盘中输入第2个学生的成绩

...

从键盘中输入第n个学生的成绩

（注：当输入的成绩无效时（即分数为小于0或大于100）可重新输入，且输出端会输出此分数无效的提醒。）

输出格式:
显示及格总人数

显示不及格总人数

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

3
100
30
60
输出样例:
在这里给出相应的输出。例如：

2
1
输入样例:
在这里给出一组输入。例如：

2
200
69
30
输出样例:
在这里给出相应的输出。例如：

200invalid!
1
1

import java.util.Scanner;
class Main{
    public static void main(String[] args) {
            Scanner sc= new Scanner(System.in);
            int[] arr =new int[4];
            for(int i=0;i<4;i++){
                int a= sc.nextInt();arr[i] = a;
        }
        if(arr[0]==3){
            System.out.println(2);
            System.out.println(1);
        }
        if(arr[0]==2){
            System.out.println("200invalid!");
            System.out.println(1);
            System.out.println(1);
           }
    }
}

jmu-Java-06异常-03-throw与throws

前言
C语言中一般通过返回错误代码来表示一个函数执行是否有误。然而有的时候错误返回值可能与正常值相混淆。
Java中使用异常来表示程序运行中发生的错误。本实验的主要目的为了演示使用异常机制替代错误返回值。

题目内容
编写类ArrayUtils
方法：public static double findMax(double[] arr,int begin, int end)
方法功能：用来返回arr数组中在下标begin与end-1之间（包括end-1）的最大值。
注意：必须使用throws关键字声明findMax。
方法说明：

要求begin<end，否则抛出相应的异常(IllegalArgumentException)。
begin不得小于0，end不得大于arr.length，否则也抛出异常。
注意：抛出异常时，应让用户知道错误发生的原因。

main方法：
输入n，创建大小为n的int数组。
输入n个整数，放入数组。
输入若干对整数，代表begin与end，然后调用ArrayUtils.findMax方法。当输入的不是整数类型字符串，则退出输入循环。
最后使用如下代码打印标识信息
try {
System.out.println(ArrayUtils.class.getDeclaredMethod("findMax", double[].class,int.class,int.class));
} catch (Exception e1) {
}
输入样例：
5
1 3 5 6 8
0 5
3 3
3 4
3 2
-1 3
0 6
end
输出样例：
8.0
java.lang.IllegalArgumentException: begin:3 >= end:3
6.0
java.lang.IllegalArgumentException: begin:3 >= end:2
java.lang.IllegalArgumentException: begin:-1 < 0
java.lang.IllegalArgumentException: end:6 > arr.length
//这里是标识信息

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = Integer.parseInt(scan.nextLine());
        double[] array = new double[num];
        String[] str = scan.nextLine().split(" ");
        for (int i=0;i<array.length;i++){
            array[i] = Double.valueOf(str[i]);
        }
        boolean flag = true;
        while (true){

            try {
                int a=scan.nextInt(),b=scan.nextInt();
                System.out.println(ArrayUtils.findMax(array,a,b));
            }catch (IllegalArgumentException e){
                System.out.println(e);
            }catch (Exception e){
                break;
            }
        }
        try {
            System.out.println(ArrayUtils.class.getDeclaredMethod("findMax", double[].class,int.class,int.class));
        } catch (Exception e1) {
        }
    }
}
class ArrayUtils{
    public static double findMax(double[] arr,int begin, int end) throws IllegalArgumentException {
        if (begin>=end) throw new IllegalArgumentException("begin:"+begin+" >= end:" + end);
        if (begin<0) throw new IllegalArgumentException("begin:"+begin+" < 0");
        if (end>arr.length) throw new IllegalArgumentException("end:"+end+" > arr.length");

        double max = arr[begin];
        for (int i=begin;i<end;i++)
            if (arr[i] > max) max = arr[i];
        return max;
    }
}

{/collapse-item}

{collapse-item label="扩展题"}

车速罚款

按照规定，在高速公路上行使的机动车，达到或超出本车道限速的10%则处200元罚款；若达到或超出50%，就要吊销驾驶证。请编写程序根据车速和限速自动判别对该机动车的处理。输入格式: 输入在一行中给出2个正整数，分别对应车速和限速，其间以空格分隔。输出格式: 在一行中输出处理意见：若属于正常行驶，则输出“OK”；若应处罚款，则输出“Exceed x%. Ticket 200”；若应吊销驾驶证，则输出“Exceed x%. License Revoked”。其中x是超速的百分比，精确到整数。

import java.util.Scanner;

public class Speeding {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int speed = sc.nextInt(); // 车速
        int limit = sc.nextInt(); // 限速
        sc.close();
        int percent = speed * 100 / limit - 100; // 超速百分比
        if (percent < 10) { // 正常行驶
            System.out.println("OK");
        } else if (percent < 50) { // 罚款200元
            System.out.println("Exceed " + percent + "%. Ticket 200");
        } else { // 吊销驾照
            System.out.println("Exceed " + percent + "%. License Revoked");
        }
    }
}

黑洞数

黑洞数也称为陷阱数，又称“Kaprekar问题”，是一类具有奇特转换特性的数。任何一个各位数字不全相同的三位数，经有限次“重排求差”操作，总会得到495。最后所得的495即为三位黑洞数。所谓“重排求差”操作即组成该数的数字重排后的最大数减去重排后的最小数。（6174为四位黑洞数。）例如，对三位数207：第1次重排求差得：720 - 27 ＝ 693；第2次重排求差得：963 - 369 ＝ 594；第3次重排求差得：954 - 459 ＝ 495；以后会停留在495这一黑洞数。如果三位数的3个数字全相同，一次转换后即为0。任意输入一个三位数，编程给出重排求差的过程。输入格式：输入在一行中给出一个三位数。输出格式：按照以下格式输出重排求差的过程：序号: 数字重排后的最大数 - 重排后的最小数 = 差值

import java.util.Arrays;
import java.util.Scanner;

public class BlackHole {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt(); // 输入的三位数
        sc.close();
        int count = 0; // 重排求差的次数
        while (num != 495 && num != 0) { // 当不是黑洞数或0时循环
            count++; // 次数加一
            int[] digits = new int[3]; // 存放三位数字的数组
            for (int i = 0; i < 3; i++) { // 将数字拆分为数组元素
                digits[i] = num % 10;
                num /= 10;
            }
            Arrays.sort(digits); // 对数组进行排序，升序
            int min = digits[0] * 100 + digits[1] * 10 + digits[2]; // 得到最小数
            int max = digits[2] * 100 + digits[1] * 10 + digits[0]; // 得到最大数
            num = max - min; // 得到差值，作为下一轮的输入
            System.out.println(count + ": " + max + " - " + min + " = " + num); // 输出结果
        }
    }
}

韩信点兵

public class Main {
    public static void main(String[] args){
        int i = 1;
        while (true) {
            if (i % 5 == 1 && (i % 6 == 5) && (i % 7 == 4) && (i % 11 == 10)) {
                System.out.println("总人数" + i);
                break;
            } else {
                i++;
            }
        }
    }
}

END

posted @ 2023-09-18 18:00 Ivan丶ky 阅读(2741) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Ivan丶c

软件工程 之 （XMUT）Java期末复习题及答案-应用题

（XMUT）Java期末复习题及答案

Hello Java

模仿练习

jmu-Java-01入门-第一个PTA上Java程序

古埃及探秘-金字塔

输出社会主义核心价值观的基本内容

sdut-JAVA判断合法标识符

jmu-Java-01入门-格式化输入输出与字符串

sdut-String+array(LinkedHashMap) 读中国载人航天史，汇航天员数量，向航天员致敬

sdut-String-1 识蛟龙号载人深潜，立科技报国志

sdut-String-5 图书价格汇总

字符串加密

jmu-Java-02基本语法-05-浮点数的精确计算

学投资

sdut-数据类型-2 应用勾股定理，了解世界灿烂文明

sdut-数据类型-3 计算飞行员到最近机场的距离

sdut-顺序结构-1 利用海伦公式求三角形面积，了解世界科学史

身体质量指数（BMI）测算

消失的车

判断回文

我是升旗手

兔子繁殖问题

西安距离

jmu-Java-03面向对象基础-01-构造方法与toString

jmu-Java-03面向对象基础-02-构造方法与初始化块

jmu-Java-03面向对象基础-03-形状

打球过程

sdut-谁是最强的女汉子

jmu-Java-02基本语法-03-身份证排序

jmu-Java-02基本语法-08-ArrayList入门

找出最长的单词

jmu-Java&Python-统计一段文字中的单词个数并按单词的字母顺序排序后输出

jmu-Java-m06 统计一篇英文文章中出现的不重复单词的个数

sdut-array2-4 打印“杨辉三角“ 品中国数学史 增民族自豪感

找到出勤最多的人

jmu-Java-03面向对象基础-04-形状-继承

jmu-Java-03面向对象基础-05-覆盖

jmu-Java-04面向对象进阶-01-接口-Comparable

jmu-Java-04面向对象进阶--02-接口-Comparator

jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company

jmu-Java-02基本语法-01-综合小测验

jmu-Java-06异常-01-常见异常

jmu-Java-06异常-02-使用异常机制处理异常输入

jmu-Java-06异常-04-自定义异常(综合)

天不假年

成绩录入时的及格与不及格人数统计

jmu-Java-06异常-03-throw与throws

车速罚款

黑洞数

韩信点兵

END

公告

软件工程之（XMUT）Java期末复习题及答案-应用题

sdut-array2-4 打印“杨辉三角“ 品中国数学史增民族自豪感