PTA函数题和编程题
文章目录
- 前言:一个java菜鸟想过期中考试的代码整理，仅此而已
- 一、pandas是什么？
- 二、使用步骤
- 1.引入库
- 2.读入数据
- 总结
一个java菜鸟想过期中考试的代码整理，仅此而已
6-1 学生类 (20 分)
注：indexOf：返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
有一个学生类的结构如下：
class Student {
private int no;
private String name;
private int score;
public Student(int _no, String _name, int _score) {
no = _no;
name = _name;
score = _score;
}
public int getNo() {return no;}
public String getName() {return name;}
public int getScore() {return score;}
public void print(){
System.out.println(no + " "+name+" "+score);
}
}请构造main函数完成如下功能： 从键盘中读入三个学生的信息，比较他们的成绩，按照成绩由高到低排列输出
裁判测试程序样例：
/*你的代码被嵌在这里*/
class Student {
private int no;
private String name;
private int score;
public Student(int _no, String _name, int _score) {
no = _no;
name = _name;
score = _score;
}
public int getNo() {return no;}
public String getName() {return name;}
public int getScore() {return score;}
public void print(){
System.out.println(no + " "+name+" "+score);
}
}我的代码：
import java.util.Scanner;
public class Main {
public static void main(String []args)
{
Scanner in=new Scanner(System.in);
Student a=new Student(in.nextInt(),in.next(),in.nextInt());
Student b=new Student(in.nextInt(),in.next(),in.nextInt());
Student c=new Student(in.nextInt(),in.next(),in.nextInt());
if(a.getScore()>b.getScore()&&a.getScore()>c.getScore())
if(b.getScore()>c.getScore())
{a.print();b.print();c.print();}
else
{a.print();c.print();b.print();}
if(b.getScore()>a.getScore()&&b.getScore()>c.getScore())
if(a.getScore()>c.getScore())
{b.print();a.print();c.print();}
else
{b.print();c.print();a.print();}
if(c.getScore()>a.getScore()&&c.getScore()>b.getScore())
if(a.getScore()>b.getScore())
{c.print();a.print();b.print();}
else
{c.print();b.print();a.print();}
}
}6-2 人口统计 (10 分)
本题运行时要求键盘输入10个人员的信息（每一个人信息包括：姓名，性别，年龄，民族），要求同学实现一个函数，统计民族是“汉族”的人数。
裁判测试程序样例：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
final int HUMANNUM=10;
String persons[]=new String[HUMANNUM];
Scanner in=new Scanner(System.in);
for(int i=0;i我的程序：
public static int numofHan(String data[]){
String s = "汉族";
int num = 0;
for(String s_t: data){//取data元素中的每一个元素，每次循环就依次取一个元素赋值给s_t,直到取完为止
if( s_t.indexOf(s) >= 0 ){
num ++;
}
}
return num;
}7-1 java基本语法-整数四则运算 (10 分)
输入2个整数，输出它们的和、差、乘积和准确的商。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
try(Scanner input=new Scanner(System.in)){
int a=input.nextInt();
int b=input.nextInt();
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a*1.0/b);
}
}
}7-2 sdut-数据类型-2 应用勾股定理，了解世界灿烂文明 (10 分)
定义：在平面上的一个直角三角形中，两个直角边边长的平方加起来等于斜边长的平方。如果设直角三角形的两条直角边长度分别是和，斜边长度是，那么可以用数学语言表达：
a2+b2=c2
请编程程序，实现如下功能：输入直接三角形的两个直角边的边长，求它们的斜边边长，结果保留2位小数。
提示：在Java中利用Math类的方法——**Math.sqrt()**求平方根。
java.lang.Math.sqrt(double a) 返回一个double值的正平方根。
代码如下（示例）：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner intput=new Scanner(System.in);
while(intput.hasNext()){
//scanner.hasNext()判断系统输入是否结束
double a=intput.nextDouble();
double b=intput.nextDouble();
double c=Math.sqrt(a*a+b*b);
System.out.printf("%.2f\n",c);//不可以用println
}
}
}printf主要是继承了C语言的printf的一些特性，可以进行格式化输出。 print就是一般的标准输出，但是不换行。 println和print基本没什么差别，就是最后会换行。
7-3 sdut-数据类型-3 计算飞行员到最近机场的距离 (10 分)
当飞机上的仪器出故障时，飞行员常常得估计他们到最近机场的距离。他们的方法是利用他们的高度和他们和机场之间的角度的估计。编写一个程序，帮助飞行员进行计算。
程序应以高度和角度作为输入，输出估计距离。公式为：距离distance=高度hight/ tan(degree)。
说明：tan(degree)为角度为degree的正切值。
提示：在JAVA中，Math类的静态方法tan(double degree)，用于计算弧度为degree的角度的正切值。
在C语言中，函数名: tan， 头文件：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
while(scanner.hasNext()){//不要忘记括号
double h=scanner.nextDouble();
double d=scanner.nextDouble();
System.out.printf("%.2f\n",h/Math.tan(d));
}
}
}6-2 设计一个三角形Triangle类 (10 分)
设计一个三角形Triangle类。这个类包括： 两个名为width和height的double型数据域，它们分别表示三角形的底宽和高。一个为width和height指定初值的构造方法。 一个名为getArea()的方法返回这个三角形的面积。
类名和构造方法：
类名为：Triangle
构造方法为：Triangle ( double w, double h );裁判测试程序样例：
import java.util.Scanner;
/* 你的代码将被嵌入到这里 */
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double w = input.nextDouble();
double h = input.nextDouble();
Triangle myTriangle = new Triangle(w, h);
System.out.println(myTriangle.getArea());
input.close();
}
}我的代码：
class Triangle{
double w;
double h;
public Triangle(double w,double h){
this.w=w;
this.h=h;
}
public double getArea(){
return 0.5*this.w*this.h;
}
}6-3 设计一个Circle类（成员变量为私有） (10 分)
设计一个Circle类，其半径其半径radius设置为私有double型，初始值为1.0。其中设计一个无参的构造方法和一个参数的构造方法，get/set方法分别获取半径值和设置半径值，getArea()和grLengt()分别计算Circle的面积和周长。
我的代码：
class Circle{
private double radius=1.0;
private final static double P=Math.PI;
public Circle() {
}//无参
public Circle (double radius){
this radius=radius;
}//有参
public double getRadius() {
return radius;//获取半径
}
public void setRadius(double radius) {
this.radius=radius;//设置半径
}
public double getArea() {
return radius*radius*PI;
}
public double getLength() {
return radius*PI*2;
}
}
注： 引自Java大数字运算（BigInteger类和BigDecimal类） (biancheng.net)
1.BigInteger 类型的数字范围较 Integer 类型的数字范围要大得多。BigInteger 支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值。
2.要使用 BigInteger 类，首先要创建一个 BigInteger 对象。BigInteger 类提供了很多种构造方法，其中最直接的一种是参数以字符串形式代表要处理的数字。
这个方法语法格式如下：
BigInteger(String val)这里的 val 是数字十进制的字符串。例如，要将数字 5 转换为 BigInteger 对象，语句如下：
BigInteger bi = new BigInteger("5")这里数字 5 的双引号是必需的，因为 BigInteger 类构造方法要求参数是字符串类型。
7-1 大数整除 (10 分)
请编写程序，从键盘输入一个整数n，找出大于long.MAX_VALUE且能被n整除的前3个数字。
输入格式:
输入一个作为除数的整数n，例如： 17
输出格式:
输出大于long.MAX_VALUE且能被n整除的前3个数字，例如下列三个数能被17整除且大于long.MAX_VALUE： 9223372036854775816
9223372036854775833
9223372036854775850
我的程序：
import java.math.BigInteger;//BigInteger 类型可以准确地表示任何大小的整数值。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int n=input.nextInt();
int count=0;
BigInteger j=new BigInteger(String.valueOf(Long.MAX_VALUE));//将Long.MAX_VALUE转化为字符串，String.valueOf（）调用该对象的toString()方法
j=j.add(BigInteger.valueOf(1));//相加（为了找出满足题意的前三个数）
while(count<3){
if(j.mod(BigInteger.valueOf(n)).intValue()==0){//直接进行取余操作来判断是否为输入数的整数倍。int intValue()：转化int，将BigInteger类型数据转为int。
System.out.println(j.toString());
++count;
}
j=j.add(BigInteger.valueOf(1));
}
input.close();
}
}
7-2 求阶乘factorial (10 分)
编程从键盘输入一个整数，计算出阶乘并输出。
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int n = in.nextInt();
BigInteger jiecheng = new BigInteger("1");//字符串类型
while ( n>0) {
jiecheng=jiecheng.multiply(new BigInteger(n+""));//new BigInteger(yuan+"")使用输入数字创建的对象
n--;
}
System.out.println(jiecheng);
in.close();
}
}
注：
1.next()和nextLine()两个都是用来接收用户的输入，区别在于：
next()从遇到第一个有效字符（非空格、换行符）开始扫描，遇到第一个分隔符或结束符（空格’ ‘或者换行符 ‘\n’）时结束。 nextLine()则是扫描剩下的所有字符串知道遇到回车为止。
2. str.length( )是string类对象str调用的成员函数，是求字符串的长度。
7-3 标识符命名方式转换：Camel2Snake (10 分)
在程序设计语言中，标识符都不能包含空格。如果我们需要使用两个或两个以上的单词来命名标识符，目前的工程实际中有两种常用的命名方式：Snake方式和Camel方式。 Snake方式是指单词用小写字母，单词间下划线（“_”）代替空格；Camel方式是指相邻单词首字母用大写表示。
例如，你想定义一个变量表示一个数组数字之和，并且用英文“sum of array”。我们使用Snake方式的变量名为：sum_of_array；用Camel命名方式的变量名为：sumOfArray。
现在请你将一个Camel方式命名的变量，转换成Snake方式命名的变量。
【数据范围】 输入字符串长度不超过255，只包含小写字母和大写字母，第一个和最后一个字符不可能是大写字母，且保证没有两个连续的大写字母出现。
我的程序：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
char[] ch = new char[str.length()];//存在str.length()的长度的char数组里
for(int x = 0;x < str.length();x++) {
ch[x] = str.charAt(x);//对数组中的字母进行索引
if(ch[x] >= 'A' && ch[x] <= 'Z') {
ch[x] += 32;将字符数组中的所有大写字母变成小写字母
System.out.print("_"+ch[x]);//输出的格式要求
}
else{
System.out.print(ch[x]);
}
}
}
}
7-4 日期加减 (10 分)
请编程从键盘输入一个长整型的值，该值表示从1970年1月1日算起的一个特定时间（毫秒数），以此时间构造一个日期对象。再输入一个普通整型值，该值表示天数，加上该天数后，然后输出对应的年、月、日。
import java.text.SimpleDateFormat;//格式化和分析数据的具体类
import java.util.Calendar;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Calendar date = Calendar.getInstance();//是获取一个Calendar对象并可以进行时间的计算
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");//格式化时间
long time = in.nextLong();//输入一个特定时间（毫秒数）
date.setTimeInMillis(time);//根据传递的long值设置由此Calendar表示的Calendars时间。
System.out.println(format.format(date.getTime()));//getTime 方法返回一个整数值，这个整数代表了从 1970 年 1 月 1 日开始计算到 Date 对象中的时间之间的毫秒数。
int day = in.nextInt();
date.add(Calendar.DAY_OF_MONTH, day);
System.out.println(format.format(date.getTime()));
in.close();
}
}
6-1 设计一个矩形类Rectangle (10 分)
设计一个名为Rectangle的类表示矩形。这个类包括： 两个名为width和height的double型数据域，它们分别表示矩形的宽和高。width和height的默认值都为1. 一个无参构造方法。 一个为width和height指定值的矩形构造方法。 一个名为getArea()的方法返回这个矩形的面积。 一个名为getPerimeter()的方法返回这个矩形的周长。
裁判测试程序样例：
import java.util.Scanner;
/* 你的代码将被嵌入到这里 */
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double w = input.nextDouble();
double h = input.nextDouble();
Rectangle myRectangle = new Rectangle(w, h);
System.out.println(myRectangle.getArea());
System.out.println(myRectangle.getPerimeter());
input.close();
}
}我的代码
class Rectangle{
double width = 1;
double heigth = 1;
public Rectangle() {//无参，就是小括号里没有
}
public Rectangle(double width, double heigth) {//有参就是要在小括号里表明类型和名字
this.width = width;//均为固定格式
this.heigth = heigth;
}
public double getArea(){//返回方法在public后面要加上类型
return this.width * this.heigth;
}
public double getPerimeter(){
return ( this.heigth + this.width) * 2;
}
}注：1. double width = 1;
double heigth = 1;就是成员变量
2.有参和无参就是构造方法
3。最后的返回方法就是成员方法。
6-14 定义一个股票类Stock (10 分)
定义一个名为Stock的股票类，这个类包括：一个名为symbol的字符串数据域表示股票代码。一个名为name的字符串数据域表示股票名称。一个名为previousClosingPrice的double数据域，它存储前一日的股票交易价格。一个名为currentPrice数据域，它存储当前的股票交易价格。创建一个有特定代码和名称的股票的构造方法。一个名为changePercent()方法返回从previousClosingPrice变化到currentPrice的百分比。
裁判测试程序样例：
import java.util.Scanner;
/* 你提交的代码将被嵌入到这里 */
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String symbol1=input.next();
String name1=input.next();
Stock stock = new Stock(symbol1, name1);
stock.previousClosingPrice = input.nextDouble();
// Input current price
stock.currentPrice = input.nextDouble();
// Display stock info
System.out.println(stock.name+"price changed: " + stock.changePercent() * 100 + "%");
input.close();
}
}我的代码
class Stock{
String symbol,name;
double previousClosingPrice,currentPrice;//成员变量
Stock(String symbol,String name){//构造方法
this.symbol=symbol;
this.name=name;
}
public double changePercent(){//成员方法
return (currentPrice-previousClosingPrice)/previousClosingPrice;
}
}6-3 模拟题：设计一个BankAccount类 (5 分)
设计一个BankAccount类，这个类包括：
（1）一个int型的balance变量表示账户余额。
（2）一个无参数构造方法，将账户余额初始化为0。
（3）一个带一个参数的构造方法，将账户余额初始化为输入的参数。
（4）一个int型的accountNumber变量表示开户数量，每创建一个BankAccount对象就自动加1。
（5）一个getBalance()方法：返回账户余额。
（6）一个withdraw()方法：带一个int型的amount参数，从账户余额中提取amount指定的款额。 如果amount<0或者大于当前账户余额，则输出“Invalid Amount”。
（7）一个deposit()方法：带一个int型的amount参数，将amount指定的款额存储到该银行账户上。 如果amount<0，则输出“Invalid Amount”。
裁判测试程序样例：
import java.util.Scanner;
/* 请在这里填写答案 */
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
boolean choice1 = scanner.nextBoolean();
//是否创建对象
if (choice1==true)
{
//账户1
BankAccount myAccount1=new BankAccount();
//账户2
BankAccount myAccount2=new BankAccount(100);
//选择操作类型
int choice2 = scanner.nextInt();
switch(choice2){
case 0://存款
int depositAmount=scanner.nextInt();
myAccount2.deposit(depositAmount);
break;
case 1://取款
int withdrawAmount=scanner.nextInt();
myAccount2.withdraw(withdrawAmount);
break;
}
System.out.println(myAccount2.getBalance());
}
System.out.println(BankAccount.accountNumber);
scanner.close();
}
}我的代码
class BankAccount{
int balance;
static int accountNumber = 0;//一定要加static
public BankAccount(){
accountNumber++;
this.balance = 0;
}
public BankAccount(int balance){
accountNumber++;
this.balance = balance;
}
public void setBalance()
{
this.balance=balance;
}
public int getBalance()
{
return balance;
}
public int withdraw(int amount)
{
if((amount<0)||(amount >this.balance)){
System.out.println("Invalid Amount");
return this.balance;
}
this.balance -= amount;
return this.balance;//返回两次
}
public int deposit(int amonut)
{
if(amonut < 0){
System.out.println("Invalid Amount");
return this.balance;
}
this.balance+=amonut;
return this.balance;
}
}注：在返回的地方的写法需要多注意。
6-4 定义Person类 (5 分)
请定义Person类，包含两个属性，根据主方法中的调用形式，定义构造方法，输出方法。对象的年龄在[0,150]之间，超出范围时，年龄为0。
裁判测试程序样例：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Person p1;
String name = sc.next();//这个可以看出成员变量
int age = sc.nextInt();//这个也可以看出是成员变量
p1= new Person(name,age);
p1.show();//从这里可以看出返回的方法名
sc.close();//表示结束了
}
}
/* 请在这里填写答案 */我的代码
class Person{
int age;
String name;
public Person(String name, int age) {
this.name=name;
this.age=age;//有参
}
void show(){
if(age<0||age>150)
System.out.println("name:"+name+"\nage:0");
else
System.out.println("name:"+name+"\nage:"+age);
}
}注：在一个类中，与类名相同的方法就是构造方法。每个类可以具有多个构造方法，但要求它们各自包含不同的方法参数。
类的重用
Overload是重载的意思，Override是覆盖的意思，也就是重写。重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！ 重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
6-21 从shape类扩展出一个正五边形类 (10 分)
从下列的shape类扩展出一个正五边形（regular pentagon）类RPentagon,这个类将正五边形的边长作为私有成员，类中包含初始化这个值的构造方法。
裁判测试程序样例：
import java.util.Scanner;
import java.text.DecimalFormat;
class shape {// 形状类
public double getArea()// 求面积
{ return 0; }
public double getPerimeter()// 求周长
{ return 0; }
}
/* 你提交的代码将被嵌入到这里 */
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数
double side = input.nextDouble();
shape rp = new RPentagon(side);
System.out.println(d.format(rp.getArea()));
System.out.println(d.format(rp.getPerimeter()));
input.close();
}
}我的代码：
class RPentagon extends shape {//从shape类扩展出一个正五边形（regular pentagon）类RPentagon
RPentagon(double side) {
a = side;
}
@Override
public double getArea() {
return 0.25 * a * a * Math.sqrt(25 + 10 * Math.sqrt(5));
}
@Override
public double getPerimeter() {
return 5 * a;
}
private double a;//私有成员
}
接口与多态
接口使用方法-
1.接口不能直接使用，必须有一个 实现类 来 实现 该接口
格式：
public class 实现类名称 implements 接口名称{
//…
}
2.接口的实现必须覆盖重写(实现)所有的抽象类的方法
实现，去掉abstract关键字，加上方法大括号
3.创建实现类的对象，进行使用
6-1 创建一个直角三角形类实现IShape接口 (10 分)
创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。
interface IShape {// 接口
public abstract double getArea(); // 抽象方法 求面积
public abstract double getPerimeter(); // 抽象方法 求周长
}
###直角三角形类的定义：
直角三角形类的构造函数原型如下：
RTriangle(double a, double b);其中 a 和 b 都是直角三角形的两条直角边。
裁判测试程序样例：
import java.util.Scanner;
import java.text.DecimalFormat;
interface IShape {
public abstract double getArea();
public abstract double getPerimeter();
}
/*你写的代码将嵌入到这里*/
public class Main {
public static void main(String[] args) {
DecimalFormat d = new DecimalFormat("#.####");
Scanner input = new Scanner(System.in);
double a = input.nextDouble();
double b = input.nextDouble();
IShape r = new RTriangle(a, b);
System.out.println(d.format(r.getArea()));
System.out.println(d.format(r.getPerimeter()));
input.close();
}
}我的代码：
class RTriangle implements IShape{ //格式：/*public class 实现类名称 implements 接口名称{*/
private double a,b;
public RTriangle(double a, double b) {//接口的实现必须覆盖重写(实现)所有的抽象类的方法
//实现，去掉abstract关键字，加上方法大括号
this.a = a;
this.b = b;
}
public double getArea() {
return 0.5*a*b;
}
public double getPerimeter() {
return a+b+Math.sqrt(a*a+b*b);
}
}6-2 从抽象类shape类扩展出一个圆形类Circle (10 分)
请从下列的抽象类shape类扩展出一个圆形类Circle,这个类圆形的半径radius作为私有成员，类中应包含初始化半径的构造方法。
public abstract class shape {// 抽象类
public abstract double getArea();// 求面积
public abstract double getPerimeter(); // 求周长}
主类从键盘输入圆形的半径值，创建一个圆形对象，然后输出圆形的面积和周长。保留4位小数。
圆形类名Circle裁判测试程序样例：
import java.util.Scanner;
import java.text.DecimalFormat;
abstract class shape {// 抽象类
/* 抽象方法 求面积 */
public abstract double getArea( );
/* 抽象方法 求周长 */
public abstract double getPerimeter( );
}
/* 你提交的代码将被嵌入到这里 */
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数
double r = input.nextDouble( );
shape c = new Circle(r);
System.out.println(d.format(c.getArea()));
System.out.println(d.format(c.getPerimeter()));
input.close();
}
}
我的代码：
class Circle extends shape//抽象类shape类扩展出一个圆形类Circle
{
private double radius;
private final static double PI = 3.1415926535;//final在一个对象类唯一
public Circle(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
return PI*radius*radius;
}
@Override
public double getPerimeter() {
return 2*PI*radius;
}
}
6-20 求正n边形的面积和周长 (10 分)
在一个正n边形（Regular Polygon）中，所有边的边长都相等，且所有角的度数相同（即这个多边形是等边、等角的）。我们已经从下列接口IShape实现了一个正n边形类RegularPolygon。其构造方法为：RegularPolygon(int n,double side); 其中n为边数，side为边长。
从键盘输入正n边形的边数n和边长a，请编程计算该正n边形的面积和周长。
interface IShape {// 接口
double getArea(); // 求面积
double getPerimeter();// 求周长
}
裁判测试程序样例：
interface IShape {// 接口
double getArea(); // 求面积
double getPerimeter();// 求周长
}
/* 这里有正n边形类RegularPolygon的实现*/
public class Main {
public static void main(String[] args) {
/* 你提交的代码将嵌入到这里 */
}
}
### 输入样例：
在这里给出一组输入。例如：
```in
5
7我的代码：
Scanner input = new Scanner(System.in);
DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数
int n=input.nextInt();
double side = input.nextDouble();
double area,Perimeter;
shape rp = new RegularPolygon(n,side);//不要忘记new
area=n*side*side/(Math.tan(Math.toRadians(180/n))*4);
Perimeter=n*side;
System.out.println(d.format(area));//格式化保留的四位小数
System.out.println(d.format(Perimeter));//System.out.println中间的·不要忘记
input.close();注：
1.“import java.util.*”语句表示什么意思？ 1、“import java.util.*;”表示的是把util这个包下的全部类导入到程序中； 2、导入“import java.util.*;”后程序中后面如果要用到util包里面的别的类都不需要再重新导入包了； 3、*表示的是通配符，包括util的所有类。
2.Arrays.sort中文叫数组名，是指sort(byte[] a)和sort(long[] a)两种排序方法，使用这个两种方法可以对数字在指定的范围内排序。这个方法在 java.util这个包里面，所以在用到的时候需要先将它导入。
7-1 找出最大的对象 (10 分)
（找出最大的对象）编写一个方法，返回对象数组中最大的对象。方法签名如下：
public static Object max(Comparable[] a)
所有对象都是Comparable接口的实例。对象在数组中的顺序是由compareTo方法决定的。
编写测试程序，从键盘输入5个字符串和5个整数，创建一个由5个字符串构成的数组、一个由5个整数构成的数组。找出数组中最大的字符串、整数并输出。
输入格式:
输入
Xi'an （输入5个字符串，每行一个）
Beijing
ShangHai
GuangZhou
ShenZhen
8 9 12 7 6 （输入5个整数，以空格分隔）
输出格式:
输出 Max string is Xi'an （输出最大的字符串）
Max integer is 12 （输出最大的整数）
我的程序：
import java.util.*;
public class Main {
public static Object max(Comparable[] a)//Comparable接口,公共静态对象最大可比较的一个
{
Arrays.sort(a);//排序
return a[4];
}
public static void main(String[]args)
{
Scanner in=new Scanner(System.in);
Comparable[] a=new Comparable[5];//公共静态对象最大可比较的一个
Comparable[] b=new Comparable[5];
for(int i=0;i<5;i++)
a[i]=in.next();
for(int i=0;i<5;i++)
b[i]=in.nextInt();
System.out.println("Max string is "+max(a));
System.out.println("Max integer is "+max(b));
in.close();
}
}
6-1 将学生对象按照成绩降序排序 (10 分)
请阅读程序并补全源代码：先从键盘录入5个学生的数据，保存到容器对象ar中，然后按照成绩score从高到低排序之后输出。
本程序将下面的学生类Student对象按照成绩score从高到低排序：
import java.util.*;
class Student {
String number;
String name;
float score;
// Constructor
Student(String number1, String name1, float score1) {
number = number1;
name = name1;
score = score1;
}
// Used to print student details in main()
public String toString() {
return this.number + " " + this.name + " " + this.score;
}
}
public class Main {
public static void main(String[] args) {
ArrayList ar = new ArrayList();
/* 请在这里补全代码，使程序完成指定的功能。 */ 我的代码：
Scanner sc=new Scanner(System.in);
int n=0;
String num;
String name;
float score;
for(int i=0;i<5;i++) {
Student s = new Student(sc.next(), sc.next(), sc.nextFloat());
ar.add(s);
}
ar.sort(new Comparator() {
@Override
public int compare(Student o1, Student o2) {
return (int)(o2.score-o1.score);
//升序只需要return (int)(o1.score-o2.score);
}
});
for(Student elem:ar)
System.out.println(elem.toString());
sc.close();
}
}
7-2 人名地名排序 (10 分)
从键盘输入若干人名、地名或者国家名，要求按照升序排序之后输出。
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner cin = new Scanner(System.in);
int n = cin.nextInt();
String[] name = new String[n];
char[][] str_ch = new char[n][];
for(int i=0;istr_ch[j][k])
{
char[] temp = str_ch[i];
str_ch[i] = str_ch[j];
str_ch[j] = temp;
}
}
}
for(int i=0;i 7-3 查找成绩并折算后输出 (10 分)
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner cin = new Scanner(System.in);
String[] name = new String[1000];
int[] number = new int[1000];
int count=0;
name[0] = cin.next();
for( int i=0; false==name[i].equals("noname"); i++ )
{
number[i] = cin.nextInt();
name[i+1] = cin.next();
count = i;
}
String searchName = cin.next();
boolean flag=false;
for( int i=0; i<=count; i++ )
{
if(name[i].equals(searchName) == true)
{
flag = true;
System.out.print(number[i]*0.21);
break;
}
}
if( flag == false )
System.out.print("Not found.");
cin.close();
}
}7-4 电话号码同步（Java） (10 分)
文件phonebook1.txt和phonebook2.txt中有若干联系人的姓名和电话号码。请你设计一个程序，将这两个文件中的电话号码同步。（所谓同步，就是将两个文件中的电话号码合并后剔除相同的人名和电话号码。请将同步后的电话号码按照姓名拼音顺序排序后保存到文件phonebook3.txt中。）
由于目前的OJ系统暂时不能支持用户读入文件和写文件，我们编写程序从键盘输入文件中的姓名和电话号码，当输入的单词为end时，表示文件结束。将同步后的电话号码按照姓名拼音顺序排序后输出。
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main {
public static void main(String args[]){
Scanner in=new Scanner(System.in);
String string;
String string2;
Set set=new TreeSet();
Set set2=new TreeSet();
Set set3=new TreeSet();
while(in.hasNextLine()){
string=in.nextLine();
if(string.equals("end")){
break;
}
else{
set.add(string);
}
}
while(in.hasNextLine()){
string2=in.nextLine();
if(string2.equals("end")){
break;
}
else{
set2.add(string2);
}
}
set3.addAll(set);
set3.addAll(set2);
Iterator iterator=set3.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}