java经典编程题二及详细答案

2.1 上机练习

? 基本题

1） 编程观察如下输出语句：

System.out.println(\

在“escape”处换上各种转义字符测试输出效果。如何实现如下输出: Hello \ Hello ‘\\test’

2） 设有如下代码段，考虑赋值转换问题：

int a=234; byte b=a;

System.out.println(\

将a,b的类型以及数据进行各种替换，观察什么时候能赋值，什么时候需要使用强制转换，什么时候不能强制转换，什么时候强制转换会丢失数据。

3) 编写一个程序求半径R为10的圆的面积，结果保留2为有效小数。公式为：S=πR2

注：π可用Math类的常量PI表示（即Math.PI）。保留小数请查阅DecimalFormat类

? 提高题

1） 设有一个边长为30的等边三角形，三角形内有一个内切圆，计算除内切圆外三角形内其它部分的面积。

【提示】先算三角形面积，再计算圆的面积，其差即为结果。h是等边三角形的高，内切圆的半径r=h/3，面积s=πh?/9。

2） 调试分析以下程序的运行结果：

public class test {

public static void main(String a[]) { int m=10,n=517;

System.out.println(n % m); System.out.println(n / m); System.out.println(m >> 2);

System.out.println(m & n);

System.out.println(Integer.toBinaryString(m)); System.out.println(Integer.toBinaryString(m >> 2));

} }

注意：Integer.toBinaryString（int）用于将一个整数转化为二进制形式的数字串。在进行位运算

时，注意观察二进制的数据变化规律。

2.2上机练习

? 基本题

1） 从键盘输入4个学生的成绩，找出最高分和最低分。

【提示】引入两个变量分别存放最高分和最低分，根据比较改变这两个变量值。

2) 输入一个百分制分数，输出其对应的五分制成绩，包括：优、良、中、及格、不及格。

? 提高题

1） 设有一元二次方程如下： aX bx c=0

试根据从键盘输入的a，b，c求解方程的根。

【提示】要考虑各种情形：一是a为0的情形，方程根为-c/b。还有就是根据判别式

Δ=b - 4ac进行判断，如果Δ.>0有两个实根；Δ=0，有一个实根；Δ<0，无实数解。

2

2

另外，求x的平方根可用Math.sqrt(x)方法。

2) 输入某人的应纳税所得额，计算个人所得税。税率表如下：

级数 1 2 3 4 5 6 7 8 9 全月应纳税所得额 不超过500元的 超过500元至2000元的部分 超过2000元至5000元的部分 超过5000元至20000元的部分 超过20000元至40000元的部分 超过40000元至60000元的部分 超过60000元至80000元的部分 超过80000元至100000元的部分 超过100000元的部分 税率% 5 10 15 20 25 30 35 40 45 速算扣除法（元） 0 25 125 375 1375 3375 6375 10375 15375 计算公式是：应纳个人所得税税额=应纳税所得额?适用税率-速算扣除数

例：王某当月应纳税所得额6400元。则应纳个人所得税税额=6400?20%-375=905元。

2.3.4 上机练习

? 基本题

1）写一个程序输入一个整数n,输出相应三角形。例如：N=4，则三角形如下：

# ## ### ####

2) 计算算式： 1-1/2 1/3-1/4 1/5-?-1/100 3) 输出九九乘法表,格式如下: 1*1=1 1*1=2 1*3=3 ?? 2*1=1 2*2=2 2*3=3 ?? ??

9*1=1 9*2=18 9*3=27 ??

4） 编写一个程序，用于输出Fibonacci数列的前20项。 5） 编写一个程序，输出90度以内的各度的sin()函数值。

? 提高题

1) 编写一个猜数的应用程序，用随机函数产生一个10到99的随机数。根据猜中使用的次数x计算得分。每次猜完给出是大于还是小于的提示。

注：得分计算办法：110-x*10 ；（其中，x为猜的次数） 2）找出1～100之间拥有除数最多的数。

【提示】在一定范围内找目标数，所以总体上是一个循环问题。对于每个被检测的数，要统计出其拥有除数的个数，这又是个循环问题，也就是在外循环内有内循环。为了求出拥有除数最多的哪个数，还涉及比较问题，所以要引入两个变量记下符合条件的这个数以及最多拥有的除数个数，在每次考察一个数的除数个数后要与最多者进行比较，从而决定是否要修改最多者。

3) 编写一个人与计算机对拿火柴的游戏程序。利用随机函数Math.random()产生火柴数量（20～50)， 每次最多拿3根，拿到最后一根为胜者。

要求：游戏过程要显示火柴总数，选择谁先拿；每步要显示剩余火柴数量，以及计算机拿的数量，并提示用户输入拿多少；结束时显示谁是胜者。

【解题算法提示】

(1) 产生火柴总数（amount）；

(2) 决定随先拿（whoplay：1--人， 2--计算机）； (3) 定义一个变量保存剩余火柴数量（remain)=amount ； (4) 当remain>0 循环

4.1 根据whoplay的值决定是计算机拿x根还是提示人拿x根；计算机拿时最好带有智能，人拿时要限制输入数量。 4.2 修改 whoplay的值； 4.3 修改remain的值； (5) 根据whoplay的值决定胜者

4）某地刑侦大队对涉及六个嫌疑人的一桩疑案进行分析： A、B至少有一人作案； A、E、F三人中至少有两人参与作案； A、D不可能是同案犯； B、C或同时作案，或与本案无关； C、D中有且仅有一人作案；如果D没有参与作案，则E也不可能参与作案。 试编一程序，将作案人找出来。

2.4 上机练习

? 基本题

1） 利用求n!的方法计算 2！ 4！ 5!的值。分别利用递归和非递归方法实现求n!。 2） 编写根据三条边求三角形面积的方法。利用该方法求以下两个三角形面积。

（1）三条边分别为：3，4，5 （2）三条边分别为：5.3, 6.2, 8

3）从命令行参数获取两个整数，找出两个整数之间的所有素数，每行输出3个数。

? 提高题

1） 利用求素数的方法，就6～20之间的所有偶数验证歌德巴赫猜想： 任何一个大于6的偶数可以分解为两个素数之和。

2） 分别编写一个方法求两个整数的最大公约数和最小公倍数，输入两个整数，计算这两个整的最大公约数和最小公倍数。

2.5上机练习

? 基本题

1）利用随机函数产生20个学生的英语成绩存入一个数组中。

? 输出数组所有元素，每行输出3个数； ? 求最高分、最低分； ? 求平均成绩。

2） 产生Fibonacci数列的头20项存入一个一维数组中，按每行4个输出数组的元素。 3) 利用随机函数产生50～500之间的整数给一个6*6的矩阵赋值.

l 求第3行的元素之和； l 求第2列的最小元素； l 求主对角线上最大元素； l 求数组所有元素之和。

4）利用随机函数产生36个10～30之间的整数给一个6*6的矩阵赋值.

? 求最大元素值，指出其在矩阵中的所有出现位置； ? 求该矩阵的转置矩阵。

5）利用数组元素间的关系输出含8行的杨辉三角形； 杨辉三角形特点：

（1）第1列元素为1，对角线元素为1；

（2）其他元素均为前一行的同一列位置元素和前一行的前一列元素之和。 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）产生20个范围为0～50之间的不重复随机整数存入到一个数组中，将数组中元素按由小到大输出，并求数组所有元素的平均值。

【提示】每产生一个整数要跟前面已产生的数进行比较，如果已存在，则不算，要重新产生，可以用一个循环来控制产生一个新数，只有产生的数未出现过，才能出循环。

2）利用随机函数产生36个随机整数给一个6*6的二维数组赋值。求出所有鞍点，鞍点的条件是该元素在所在行是最大值，在所在列是最小值。

【提示】 先找出行上最大的元素，然后在判断该元素在所在的列上是否是最小的。

3）利用排序算法将一数组按由小到大排列，输入一个数据，查找在数组中是否存在，采用“折半查找”加快查找速度。

所谓“折半查找”就是先与中间位置元素进行比较，如果小于中间位置的元素，则在其上半部的中间位置继续查找，否则在下半部的中间位置查找，该过程反复进行，直到找到或发现不存在为止。

4) 构造一个n阶方阵，方阵的大小从键盘输入,方阵的最外一圈元素为1,以后往内依次为2,3,....n。例如：

1 1 1 1 1 1 2 2 2 1

1 2 3 2 1 1 2 2 2 1 1 1 1 1 1

详细答案如下：

实验2.1

? 基本题

1）System.out.println(\输出结果是 hello \ System.out.println(\输出结果是hello‘ est’ 2）int a=234; byte b=a;在这种情况下，由于a是int型，b是byte型而int的级别比byte高，故b不能被赋值，若要赋值必需利用强制转换如：byte b=(byte)a; 当a的取值在其范围-128~127内时强制转换不会丢失数据，否则就会丢失数据。

通过各种数据类型的转换可知：当两个数据类型相同或将低级类型数据赋给高级类型时可以直接赋值；由于byte、short、char是平级的不能自动转换，必需使用强制转换，另外由高级到低级时就要用到强制转换；布尔类型不能与其他类型进行转换；在强制转换中，当某一数据超出它所声明的类型的长度范围就会导致溢出或者降低数据精度而丢失数据。 3）程序如下：

import java.text.DecimalFormat; public class Area {

public static void main(String args[]) {

int R=10; String S;

DecimalFormat a= new DecimalFormat(\ S=a.format(Math.PI*R*R);

System.out.println (\圆的面积为: \ } }

结果截图：

? 提高题

1）程序如下： public class Area {

public static void main(String s[]) {

double a1; double a2; double area;

a1=225*Math.sqrt(3); a2=Math.PI*75; area=a1-a2;

System.out.println(\三角形的面积为：\ System.out.println(\内切圆的面积为：\ System.out.print(\余下部分的面积为：\ System.out.print(area); } } 结果截图：

2）调试结果如下：

实验2.2

? 基本题

1）程序如下： import java.io.*; public class MyDemo {

public static void main(String[] args) throws NumberFormatException, IOException {

float[] score=new float[4];

BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); for(int i=0;i

System.out.println(\请输入第\个成绩：\ score[i]=Float.parseFloat(in.readLine()); }

float min=32768; float max=0;

for(int i=0;imax){ max=score[i]; }

if(score[i]

System.out.println(\最高分：\最低分：\ } }

结果截图：

2)程序如下：

import java.util.*; public class GradeRank {

public static void main(String str[]) { Scanner scanner = new Scanner(System.in); System.out.print(\ double grade = scanner.nextInt(); if (grade >= 90) {

System.out.println(\该成绩为优\ } else if (grade >= 80 && grade < 90) { System.out.println(\该成绩为良\ } else if (grade >= 70 && grade < 80) { System.out.println(\该成绩为中\ } else if (grade >= 60 && grade < 70) { System.out.println(\该成绩及格\ } else {

System.out.println(\该成绩不及格\ } }

}结果截图：

? 提高题

1） 程序如下：

import java.util.Scanner; public class fangcheng {

public static void main(String[] args) {

Scanner input = new Scanner(System.in); System.out.println(\请输入a\ double a=input.nextDouble(); System.out.println(\请输入b\ double b=input.nextDouble(); System.out.println(\请输入c\ double c=input.nextDouble(); if(a==0)

{ System.out.println(\对不起该方程不是一元二次方程\ else if(b*b-4*a*c==0)

{System.out.println((-b Math.sqrt(b*b-4*a*c))/(2*a)); } else if (b*b-4*a*c>0) {

System.out.println(\第一个答案为\ System.out.println(\第二个答案为\ } else

{System.out.println(\对不起没有答案\ } }

截图如下：

2） 程序如下：

import java.util.Scanner; public class Tax {

public static void main(String[] args) { double s;

Scanner input = new Scanner(System.in); System.out.println(\请输入所得税额t\ double t=input.nextDouble();; if(t==500)

{System.out.println(\应纳个人所得税税额为:25\ else if(t<=2000) { s=0.1*t-25;

System.out.println(\应纳个人所得税税额为:\ else if (t<=5000) { s=0.15*t-125;

System.out.println(\应纳个人所得税税额为:\

public int compare(int guess, int random){ if(guess==random){

System.out.println(\恭喜你，你猜对了\

System.out.println(\你猜对了. 你的得分是：\ return EQUALS; }else if(guess

System.out.println(\你已经猜了\次了，你的数小了\ return LITTLE_THAN; }else{ count ;

System.out.println(\你已经猜了\次了，你的数大了\ return GREATER_THAN; } }

public static void main(String[] args){ GuessNum gn = new GuessNum();

Scanner scan = new Scanner(System.in); int num = gn.generateNum(); int guess; do{

System.out.println(\请输入一个10到99之间的数字\ guess = scan.nextInt(); }

while(gn.compare(guess, num)!=GuessNum.EQUALS); } }

结果截图：

2）程序如下： import java.util.*; public class count {

public static void main(String[] args) {

int count = 0;

List list = new ArrayList(); int i = 1; while(i <= 100) {

int temp = 0;

for(int j = 1; j <= i; j ) {

if(i %j == 0) { temp ;} }

if(count < temp) {

list.clear();

list.add(new Integer(i)); count = temp; }

else if(count== temp) {list.add(new Integer(i));} i ; }

for(int value: list)

{System.out.println(\除数最多的数是: \除数个数为 :\ } }

结果截图：

3）程序如下： import java.io.*; import java.util.*; public class huochai {

public static void main(String args[]) {

System.out.print(\请按enter键开始游戏 \ byte[] buf2=new byte[20]; String strTemp3=\ try

{ System.in.read(buf2); } catch(IOException e){} strTemp3=new String(buf2);

int a=(strTemp3.trim().compareTo(\ int b=(strTemp3.trim().compareTo(\ int amount=0;

amount=(int)(Math.random()*31 20); if(a==0||b==0)

System.out.print(\火柴数\ System.out.println();

System.out.print(\谁先拿1--人，2--计算机(1或2)？\

byte[] whoplay=new byte[20]; String strTemp2=\ try {

System.in.read(whoplay); }

catch(IOException e) {} strTemp2=new String(whoplay);

int c=(strTemp2.trim().compareTo(\ int d=(strTemp2.trim().compareTo(\ int remain=amount; while(remain>=0) {

if(c==0) {

System.out.print(\人拿火柴\ double x=0; BufferedReader InputStreamReader(System.in)); try {

String s= br.readLine(); x=Double.parseDouble(s); }

catch(IOException e) { } if(x>=1&&x<=3) {

remain-=(int)x;

System.out.println(\剩余火柴数：\ if(remain==0)

{ System.out.print(\人赢！！\ if(remain<=3&&remain>0) {

System.out.print(\计算机拿\ System.out.println(\计算机赢！！\

br=new

BufferedReader(new

} } else

{ System.out.println(\最多只能拿三根！\ continue; }

System.out.print(\计算机拿\ int y=0;

y=(int)(Math.random()*3 1); System.out.println(\ remain-=y;

System.out.println(\剩余火柴数：\ if(remain==0)

{ System.out.print(\人赢！！\ }

if(d==0) {

System.out.print(\计算机拿\ int y=0;

y=(int)(Math.random()*3 1); remain-=y;

System.out.println(\

System.out.println(\剩余火柴数：\ if(remain==0)

{ System.out.print(\计算机赢！！\ break; }

/* while(remain>=0)

{ System.out.print(\人拿火柴\ double x=0; BufferedReader InputStreamReader(System.in)); try {

String s= br.readLine();

br=new

BufferedReader(new

x=Double.parseDouble(s); }

catch(IOException e) { } if(x>=1&&x<=3) { remain-=(int)x;

System.out.println(\剩余火柴数：\ if(remain==0)

{ System.out.print(\人赢！！\ if(remain<=3&&remain>0) {

System.out.print(\计算机拿\ System.out.println();

System.out.println(\计算机赢！！\ break; } } else

{ System.out.println(\最多只能拿三根！\ continue; }

System.out.print(\计算机拿\ y=(int)(Math.random()*3 1); System.out.println(\ remain-=y;

System.out.println(\剩余火柴数：\ if(remain==0)

{ System.out.println(\人赢！！\ break; } } }break;*/ c=0; d=1; } } }

} 结果截图：

4）程序如下：

public class zhencha {

public static void main(String[] args) {

String[] persons = { \ for (int i = 0; i <= 63; i ) { int t = i;

int num[] = new int[6]; int j = 5;

for (; j >= 0; j--) {// 换成二进制数，保存在一个6个元素的一维数组中 if (t / 2 > 0) { num[j] = t % 2; t = t / 2; } else { num[j] = t; break; }

}

// num[0]--num[5]代表A--F // 代表AB至少有一个人作案 if (num[0] num[1] >= 1) { // AEF 至少2个人作案

if (num[0] num[4] num[5] >= 2) {

// AD 不是同案犯。但可能都没作案或其中一个作案 if (num[0] num[3] <= 1) {

// BC 同时作案，或者同时没作案

if ((num[1] num[2] == 0 || num[1] num[2] == 2)) { // CD肯定有一个人作案了 if (num[2] num[3] == 1) {

// 如果D没作案且E也没作案，或者 D作案了了 if (num[3] == 0 && num[4] == 0 || num[3] == 1) for (int index = 0; index < num.length; index ) { if (num[index] == 1) {

System.out.println(\作案人有：\ } } } } } } } } } }

结果截图：

实验2.4

?????基本题

1）程序如下：

public class jiecheng{

public static void main(String[] args) { int two = 2; int four = 4; int five = 5;

int sum = calcFac(two) calcFac(four) calcFac(five); System.out.println(\ }

static int calcFac(int number){ if(number == 1){ return 1; }else{

return calcFac(number - 1) * number; } } }

结果截图：

递归求n!

import java.util.*; public class dgjc {

public static void main(String[] args) { System.out.print(\请输入N值：\ Scanner input = new Scanner(System.in); int N = input.nextInt(); System.out.print(factor(N)); }

public static int factor(int n) {

if(n<1) return 1;

int s=n*factor(n-1); return s; } }

非递归求n!

import java.util.*; public class fdgjc {

public static void main(String args[] ) { System.out.print(\请输入N值：\ Scanner input = new Scanner(System.in); int N= input.nextInt(); int s= 1;

for (int i = 1; i <=N; i ) { s = s * i;}

System.out.println(\则N!=\ } }

2）程序如下：

public class mianji { private double a; private double b; private double c;

public mianji(double a, double b, double c){ this.a = a; this.b = b; this.c = c; }

public static void main(String[] args) { mianji triple = null;

triple = new mianji(3, 4, 5);

double area1 = triple.calcArea(); triple = new mianji(5.3, 6.2, 8); double area2 = triple.calcArea();

System.out.println(\三条边分别为3，4，5的三角形面积是: \ System.out.println(\三条边分别为5.3, 6.2, 8的三角形面积是: \ }

public double calcArea(){ double p = (a b c) / 2;

return Math.sqrt(p * (p - a) * (p- b) * (p - c)); } }

结果截图：

3）程序如下： import java.util.*; public class sushu {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in); System.out.print(\请输入一个整数:\ int x = scan.nextInt();

System.out.print(\请输入一个整数:\ int y = scan.nextInt(); int minNum = Math.min(x, y); int maxNum = Math.max(x, y);

System.out.println(\这两个整数间的素数有：\ for(int i=minNum, count =0; i

boolean isPrimeNumber = true; for(int j = 2; j < i; j ) {

if(i % j == 0) {

isPrimeNumber = false; } }

if(count == 3) {

System.out.println(); count = 0; }

if(isPrimeNumber) {

System.out.print(i \ count ; } } } }

结果截图：

? 提高题

1）程序如下： public class bahe {

// function:判断temp是否为素数 public boolean checkPrime(int temp){ boolean flag=true;

int i=(int)Math.sqrt(temp); for(int j=2;j<=i;j ){ if(temp%j!=0){ continue;

}else{ flag=false; j=i 1; } }

return flag; }

//function:将temp分解为两个素数之和并打印 public void ChangeInt(int temp){ int i=(int)(temp/2); for(int j=2;j<=i;j ){ if(checkPrime(j)){ int k=temp-j; if(checkPrime(k)){

System.out.println(\整数temp\被分解为素数\和素数\之和\ break; } }else{ continue; } } }

public static void main(String []args){ bahe ch=new bahe(); for(int i=6;i<=20;i=i 2){ ch.ChangeInt(i); } } }

结果截图：

2）程序如下： import java.util.*; public class Ex1 {

public static void gongYue(int m, int n) {

if (m > n) {

int h = m; m = n; n = h; }

if (n % m == 0)

{System.out.println(\最大公约数为：\ else {

for (int i = n / 2; i > 1; i--) {

if (m % i == 0 && n % i == 0) {

System.out.println(\最大公约数为：\ break; } } } }

public static void gongBei(int m, int n) {

if (m > n) {

int h = m; m = n; n = h; }

for (int j = n; j <= m* n; j ) {

if (j % m == 0 && j % n == 0) {

System.out.println(\最小公倍数：\ break; } } }

public static void main(String[] args) {

Scanner scan = new Scanner(System.in); System.out.print(\请输入一个整数：x=\ int x = scan.nextInt();

System.out.print(\请输入一个整数：y=\ int y = scan.nextInt(); gongYue(x, y); gongBei(x, y); } }

结果截图：

实验2.5

? 基本题

max = a[0][0];

for(i=0; i

for(j=0; j max){ max = a[i][j]; maxI = i; maxJ = j; } } }

System.out.println(\数组的最大值：\

System.out.println(\位置：(\ reverse(a, b);

System.out.println(\转置矩阵：\ for(i=0; i

for(j=0; j

System.out.print(b[i][j] \ \ }

System.out.println(); } }

public static void reverse(int[][]a, int[][] b){ for(int i=0; i

for(int j=0; j

结果截图：

5）程序如下： public class yanghui

{public static void main(String args[]) {

final int ROW=7;

int a[][]=new int[ROW 1][]; for(int i=0;i<=ROW;i )

{ a[i]=new int[i 1]; //指定每行的列数 } yanghui(a,ROW); }

static void yanghui(int a[][],int ROW) {

for(int i=0;i<=ROW;i )

for(int j=0;j<=a[i].length-1;j ) {

if(i==0||j==0||j==a[i].length-1) a[i][j]=1;

else a[i][j]=a[i-1][j-1] a[i-1][j]; }

for(int i=0;i<=ROW;i ) {

for(int j=0;j<=a[i].length-1;j ) System.out.print(a[i][j] \ System.out.println();

} } }

结果截图：

? 提高题

1）程序如下：

import java.util.Random; public class qushupaixu {

public static void main(String[] args) {

Random r=new Random(); int items=0;

int[] arrs=new int[20]; while(items<20) {

int number=r.nextInt(50);//生成0-50之间的随机数

if(!findKey(arrs,number))//判断有没有重复的值，没有的话添加进数组 { arrs[items ]=number;} }

sort(arrs);

for (int i = 0; i < arrs.length; i ) {System.out.print( arrs[i] \ \ System.out.println(\ avg(arrs); }

//判断有没有重复的值的方法

public static boolean findKey(int[] arrs,int num)

{

for(int i=0;i

if(arrs[i]==num) {return true;} }

return false; }

public static void sort(int[] arrs) { for(int i=0;i

for(int j=i;jarrs[j]) { index = j; } }

swap(arrs,i, index); } }

public static void swap(int[] arrs, int i, int j) { int tmp = arrs[i]; arrs[i] = arrs[j]; arrs[j] = tmp; }

public static void avg(int[] arrs) {

int sum=0; int avg=0;

for (int i = 0; i < arrs.length; i ) { sum =arrs[i];} avg=sum/arrs.length;

System.out.println(\本次产生的随机数组的平均值为：\ } }

结果截图：

2）程序如下：

import java.util.Random; public class andian {

public static void main(String[] args){ int a[][] = new int[6][6]; for(int i = 0;i<6;i ){ for(int j = 0;j<6;j ){

a[i][j]=new Random().nextInt(10); System.out.print(a[i][j] \ \ }

System.out.println(); }

int max = 0; int min = 100; int flag = 0; int flag2 = 0; for(int i=0;i<6;i ){ for(int j=0;j<6;j ){ if(a[i][j]>max){ max=a[i][j]; flag = j; } }

for(int k=0;k<6;k ){ if(a[k][flag]

if(flag2 == i) {

System.out.println(\是鞍点\ System.out.println(\该元素是:\

本文来源：https://www.bwwdw.com/article/jobg.html