文章目录
- 前言
- 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
- 题目：判断101-200之间有多少个素数，并输出所有素数。
- 题目：打印出所有的“水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153-1的三次方+5的三次方+3的三次方。
- 题目：将一个正整数分解质因数。例如：输入90，打印出90-2*3*3*5
- 题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
- 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
- 题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
- 题目：求s=a+aa+aaa+aaaa...值，其中a是一个数字。例如2+22+222+2222+22222+222222+...（时共有5个数相加），几个数相加有键盘控制。
- 题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6-1+2+3.编程找出1000以内的所有完数。
- 题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
- 题目：有1、2、3、4四个数字，能组成多少个互不相同且一个数字中无重复数字的三位数？并把他们都输入。
- 题目：输入某年某月某日，判断这一天是这一年的第几天？
- 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
- 题目：两个乒乓球队进行比赛，各出三人。甲队为a，b，c三人，乙队为x.y，z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x.z比，请编程序找出三队赛手的名单。
- 题目：打印出如下图案（菱形）
- 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，2113.求出这个数列的前20项之和。
- 题目：求1!+2!+3!+...+20！的和
- 题目：利用递归方法求5！.
- 题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
- 题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
- 题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
- 题目：对10个数进行排序
- 题目：求一个3*3矩阵对角线元素之和
- 题目：取一个整数a从右端开始的4~7位。
- 题目：打印出杨辉三角形（要求打印出10行如下图）
- 题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
- 题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
- 二分法查找——在a[0] <=a[1] <= ...a[n-1]中，找到x则返回x所在的位置，否则返回-1；
- 附上JAVA期末考试题库
- 题库2
- 总结
前言
JAVA期末复习专用。
题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
思考：题目意思是说第一个月一对兔子，第二个月还是一对兔子，到了第三个月他们生了一对兔子所有现在有两队兔子。到了第四个月有三对兔子，但是到第五个月的时候三个月大的兔子生了一对加上第四个月的兔子生了一对就有五队兔子，按照规律下去就是：
第一个月-----------------1
第二个月-----------------1
第三个月-----------------2
第四个月-----------------3
第五个月-----------------5
第六个月-----------------8
第七个月-----------------13
... ...
这其实是一个斐波拉切数列的问题。
这就好办了，从第三个月开始，前两个月兔子数之后为第三个兔子总数，所以定义一个存放24个月兔子书数组，每个元素存放一个月的兔子总数。
写程序：
public class lianxi01 {
public static void main(String[] args) {
System.out.println("第1个月的兔子对数：1");
System.out.println("第2个月的兔子对数：1");
int f1 = 1; //定义第一个月的兔子数量。
int f2 = 1; // 第二个月的兔子数量。
int f;// 定义一个中间变量。
int M = 12; // 定义12个月。
for (int i = 3; i <= M; i++) {// 从第三个月开始for循环。
f = f2;
f2 = f1 + f2; // 从第三个月开始，每一次循环都是前两个月的兔子的数量相加等于后一个月的兔子的数量。
f1 = f;// 又把f也就是下一个月的数量赋给f1.
System.out.println("第"+i+"个月的兔子对数"+f2+"只。");
}
}
}
输出结果：
题目：判断101-200之间有多少个素数，并输出所有素数。
思路：判断素数的方法：用一个数分别去除2到这个数，如果能被整除，则表明此数不是素数，反之是素数。
程序：
public class Practicet_wo {
public static void main(String[] args) {
int count = 0;
for (int i = 101; i <200 ; i++) {
boolean b = false;
for (int j = 2; j <=Math.sqrt(i) ; j++) {
if (i%j==0) {
b=false;
break;
}else {
b = true;
}
if (b==true) {
count++;
System.out.println(i);
}
}
}
System.out.println("素数的个数是"+count);
}
}
题目：打印出所有的“水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153-1的三次方+5的三次方+3的三次方。
思路：一次定义三个变量用来获取这个三位数的百位、十位和个位。
public class lianxi03 {
public static void main(String[] args) {
int b1, b2, b3;
for (int m = 100; m < 1000; m++) { // 对100到1000进行遍历。
b3 = m / 100; // 除以100取到百分位。
b2 = m % 100 / 10;// 除以100取余得到个位和十位，再除以十得到十位。
b1 = m % 10; // 除以十取余得到个位
if ((b3 * b3 * b3 + b2 * b2 * b2 + b1 * b1 * b1) == m) {
System.out.println(m + "是一个水仙花数。");
}
}
}
}
题目：将一个正整数分解质因数。例如：输入90，打印出90-233*5
思路：可以对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
- 如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
- 如果n<> k，但n能被k整除，则应打印出k的值，并用n除以k的商，作为新的正整数你n，重复执行第一步。
- 如果n不能被k整除，则用k+1作为k的值，重复执行第一步。
代码：
import java.util.Scanner;
public class lianxi04 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in); // 键盘录入
System.out.println("请输入一个正整数：");
int n = s.nextInt();// 接受键盘录入
int k = 2;// 定义一个变量为2用于记录。
System.out.print("分解质因数为："+n + "=");
while (k <= n) {
if (k == n) { // 如果输入的数刚好等于2则直接输出2；
System.out.println(+n);
break;
} else if (n % k == 0) {// 如果不满足前者，但是满足输入的数除以2取余等于0那么久打印这些数相乘的结果。
System.out.print(k + "*");
n = n / k;// 接着继续执行除2赋值给n的操作。
} else k++;// 最后一步使得k不断累加来判断是否满足条件n % k == 0。
}
}
运行截图：
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
思路：此题的解法有多种，这里采用三目运算来解决。
import java.util.Scanner;
public class Practice05 {
public static void main(String[] args) {
char grade;// 定义一个char类型的成绩变量
Scanner s = new Scanner(System.in);
System.out.println("请输入一个成绩");
int x = s.nextInt();
grade = x>=90?'A':x>=60?'B':'C';
System.out.println("等级为"+grade);
}
}
运行截图：
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
思路：在循环中，只要除数不等于0，用较大数除以较小的数，将小的一个数作为下一轮循环的大数，取得的余数作为下一轮循环的较小的数，如此循环直到较小的数的值为0，返回较大的数，此数即为最大公约数，最小公倍数为两数之积除以最大公约数。
代码：
import java.util.Scanner;
public class Practice06 {
public static void main(String[] args) {
int a, b, m;// 定义三个变量分别表示输入的两个数与第三个最大公约数。
Scanner s = new Scanner(System.in);
System.out.println("键入一个整数:");
a = s.nextInt();
System.out.println("再输入一个整数：");
b = s.nextInt();
deff cd = new deff();// 创建这个对象
m = cd.deff(a,b);// 调用对应的方法，把用于键盘接受录入的两个数穿进去。
int n = a*b/m; // 两者相乘再除以最大公约数即为最小公倍数。
System.out.println("两者的最大公约数是:"+m);
System.out.println("两者的最小公倍数是:"+n);
}
}
class deff {
public int deff(int x, int y) {
int t; // 定义了一个中间变量用于交换位置。
if (x < y) {
t = x;
x = y;
y = t;
}
while (y != 0) {
if (x == y)
return x;
else {
int k = x % y; // 两者相除取的余数返回变量k
x = y; // 将第二个数的值赋给x，最后输出x。
y = k;
}
}
return x;
}
}
运行结果：
题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
https://blog.csdn.net/qq_43055855/article/details/116566921
题目：求s=a+aa+aaa+aaaa…值，其中a是一个数字。例如2+22+222+2222+22222+222222+…（时共有5个数相加），几个数相加有键盘控制。
思路：可以使用while循环做，键盘录入要计算的数字与想要相加的项数，然后循环多少项数的次数。每循环一次就让后一项比前一项多一个想要输入的数字即可。
代码：
import java.util.Scanner;
public class Practice08 {
public static void main(String[] args) {
long a, b = 0, sum = 0;
Scanner s = new Scanner(System.in);
System.out.println("输入数字a的值");
a = s.nextInt();
System.out.println("输入相加的项数");
int n = s.nextInt();
int i = 0;
while (i < n) {
b = b + a;
sum = sum+b;
a = a * 10;
++i;
}
System.out.println("2+22+222="+sum);
}
}
输出结果：
题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6-1+2+3.编程找出1000以内的所有完数。
public class Practice09 {
public static void main(String[] args) {
System.out.print("1到1000的完数有:");
for (int i = 1; i <1000 ; i++) {
int t = 0;
for (int j = 1; j <=i/2 ; j++) {
if (i%j==0) {
t = t+j;
}
}
if (t==i){
System.out.print(i+" 、 ");
}
}
}
}
题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
思路：可以定义一个初始高度，因为每一次运行的距离都是原来高度的两倍，然后有十次反弹就可以有一个fori循环来执行球的反弹操作，没循环一次就让距离乘以2，原来的高度减少一半也就是除以2，最后把反弹的高度减去100得到最终的高度。
public class Practice10 {
public static void main(String[] args) {
double h = 100,s = 0;// 定义初始高度，与初始距离。
for (int i = 1; i <=10 ; i++) { // 来一个for循环，执行10次，每一次让距离乘以二，然后高度减少到原来的一半；
s = s +2*h;
h = h/2;
}
s = s -100;
System.out.println("经过路程："+s);
System.out.println("最后高度："+h);
}
}
运行结果：
题目：有1、2、3、4四个数字，能组成多少个互不相同且一个数字中无重复数字的三位数？并把他们都输入。
public class Practice11 {
public static void main(String[] args) {
int count = 0;
for (int i = 1; i <5 ; i++) {
for (int j = 1; j <5 ; j++) {
for (int k = 1; k < 5; k++) {
if (i!=j&&j!=k&&i!=k) {
count++;
System.out.println(i*100+j*10+k);
}
}
}
}
System.out.println("共有"+count+"个三位数");
}
}
运行结果：
题目：输入某年某月某日，判断这一天是这一年的第几天？
思路：这一题其实很简单，不是很多人的方法很复杂还是怎么滴，其实只需要定义三个变量用于接受年月日，然后可以用switch循环语句来对一年中的12个月进行分类，然后再把二月单独罗列出来分析，最后将年月份和日的天数加起来即可。
public class Practice14 {
public static void main(String[] args) {
int year, month, day;
int days = 0;
int d = 0;
int e;
Scanner sc = new Scanner(System.in);
do {
e = 0;
System.out.println("输入年：");
year = sc.nextInt();
System.out.println("输入月：");
month = sc.nextInt();
System.out.println("输入日：");
day = sc.nextInt();
if (year < 0 || month > 12 || day < 0 || day > 31) {
System.out.println("输入错误，请重新输入！");
e = 1;
}
} while (e == 1);
for (int i = 0; i < month; i++) {
switch (i) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
days = 31;
break;
case 4:
case 6:
case 9:
case 11:
days = 30;
break;
case 2:
if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
days = 29;
} else {
days = 28;
}
break;
}
d += days;
}
System.out.println(year+"-"+month+"-"+day+"是这年的第"+(d+day)+"天");
}
}
运行结果：
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
public class Test {
public static void main(String[] args) {
int next = 1; // 第10天 剩1个桃子了。
int prev = 0; //表示前一天的变量prev初始值为0
for(int day = 9;day > 0; day--){ // 从第九天开始依次往前遍历
prev = (1+next)*2; // next 表示后一天
next = prev; //每次循环把每天吃掉的桃子数量赋值给前一天，最后输出最终前一天的桃子数。
}
System.out.println(prev);
}
}
题目：两个乒乓球队进行比赛，各出三人。甲队为a，b，c三人，乙队为x.y，z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x.z比，请编程序找出三队赛手的名单。
思路：有题目的意思可以知道a和z比赛，c和y比赛。如此的话可以把abc和xyz分别放在两个字符数组里面，然后依次对两个数组进行遍历数组，判断如果匹配到了第一个数组的a与第二个数组的b那么久continue终止本次循环跳到下一次循环，再一次循环匹配到了a与y的话也终止本次循环直接跳到下一次循环，紧接着有道c与x、c与z 、b与z、b与y都是continue终止本次循环，最终打印三队的比赛名单。
public class Practice18 {
static char[] m = {'a', 'b', 'c'};
static char[] n = {'x', 'y', 'z'};
public static void main(String[] args) {
for (int i = 0; i < m.length; i++) {
for (int j = 0; j < n.length; j++) {
if (m[i] == 'a' && n[j] == 'x') {
continue;
} else if (m[i] == 'a' && n[j] == 'y') {
continue;
} else if ((m[i] == 'c' && n[j] == 'x') || (m[i] == 'c' && n[j] == 'z')) {
continue;
} else if ((m[i] == 'b' && n[j] == 'z') || (m[i] == 'b' && n[j] == 'y')) {
continue;
} else {
System.out.println("队伍m中的"+m[i] +" "+ "VS" +" "+"队伍n中的"+ n[j]);
}
}
}
}
}
运行结果：
题目：打印出如下图案（菱形）
思路：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重 for循环，第一层控制行，第二层控制列。只是需要注意的是很多然分不清println和print的区别。一个是打印后再换行，一个只是单纯的打印输出。
public class Practice19 {
public static void main(String[] args) {
int H = 7, W = 7;// 高和宽必须是相等的奇数。
for (int i = 0; i < (H + 1) / 2; i++) {// 控制行，前四行，执行四次循环。打出四行。
for (int j = 0; j < W / 2 - i; j++) {// 控制列。内循环控制列。
System.out.print(" ");// 第一行打印三个空格，第二行打印两个空格，第三行打印一个空格。
}// 执行第四次的时候发现j等于4不小于3所以往下走。
// 打印星星*，第一次进来先打三个空格再打印一个星星
for (int k = 1; k < (i + 1) * 2; k++) {// 第一次进来k = 1；k不小于2所以打印星星，k++后k变成了2，循环不满足条件换行。
System.out.print('*');// 这里注意不是 println。只是单纯的打印。
}
System.out.println();//打印出星星以后换行继续。
}
//以下代码为第五行到第七行的打印星星逻辑代码。
for (int i = 1; i <= H / 2; i++) {// 同样的道理，外层控制行，内层控制列。
for (int j = 1; j <= i; j++) {
System.out.print(" ");//第五行前面空一个空格。
}
// 打印星星。
for (int k = 1; k <= W - 2 * i; k++) { // 开始W-2*i为5， i初始值为1， 也就是k小于等于5
System.out.print("*");//所以第五行打印五个星星。
}
System.out.println();
}
}
}
运行截图：
题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，2113.求出这个数列的前20项之和。
思路：这题有点像斐波那契数列一样，分子与分母的和是后一项的分子，然后后一项的分母是前一项的分子。知道这些就好办了，可以定义一个初始值分别为2和1，然后再定义一个sum用来记录总和，遍历20次，每遍历一次就把分子分母同时赋值一遍即可。
代码：
public class lianxi20 {
public static void main(String[] args) {
int x = 2, y = 1, t;// 定义分子分母的初始值。
double sum = 0;
for (int i = 1; i < 20; i++) {// 循环20次
sum = sum + (double) x / y; // 前20项之和。
t = y; // 把分母的值用临时变量t先记录下来
y = x;// 然后将分母的值赋给第二项分子的值
x = y+t;// 最后将第一项分子分母的值加起来赋给第二项的分子。
}
System.out.println("前20项相加之和是："+sum);
}
}
运行结果：
题目：求1!+2!+3!+…+20！的和
public class lianxi21 {
public static void main(String[] args) {
long sum = 0;
long fac = 1;
for (int i = 1; i <=20 ; i++) {
fac = fac*i;
sum+=fac;
}
System.out.println(sum);
}
}
题目：利用递归方法求5！.
思路：自己钓自己嘛，可以定义一个方法，相当于套娃，从前有座山，山上有个和尚和尚再讲故事，和尚说从前有座山上上有座庙，庙里有老和尚，老和尚讲故事…
方法进来后首先判断是不是1，因为1的阶乘就是他本身嘛，如果不是一的话就一个else打出去，再调用这个方法，传入变量减去一。
public class Practice22 {
public static void main(String[] args) {
System.out.println("5的阶乘是："+getSumjiecheng(5));//getSumjiecheng.sout输出即可。
}
public static long getSumjiecheng(int i) {
long value = 0; // 定义的临时变量用于记录最后阶乘运算的结果返回出去。
if (i ==1) {// 如果传进来的是1，则1的阶乘是他本身。
return 1;
}else {
value = i*getSumjiecheng(i-1);// 不断地调用自己，每调用一次i就减去1。
}
return value;
}
}
运行结果：
题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
public class Practice23 {
public static void main(String[] args) {
int age = 10;
for (int i = 2; i <=5 ; i++) {
age = age +2;
}
System.out.println(age);
}
}
题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
思路：使用了长整型最多输入18位。
public class Practice23 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入一个正整数");
long a = s.nextLong();
String ss = (String) Long.toString(a);
char[] ch = ss.toCharArray();
int j = ch.length;
System.out.println(a + "是一个" + j + "位数.");
// 逆序输出
for (int i = j - 1; i >= 0; i--) {
System.out.println(ch[i]);
}
}
}
运行结果：
题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
思路：可以这样想，和上一道题一样，把这个正整数转换成字符串后再转换成字节数组啦，然后从中间开始遍历，判断，如果第一个数和最后一个数相同，第二个数与倒数第二个数相同即j-i-1，第一次i等于0，第二次你等于1，这样就能达到以此遍历的效果。
import java.util.Scanner;
public class Practice25 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
boolean is = true;
System.out.println("请输入一个正整数:");
long a = s.nextLong();
String ss = Long.toString(a);
char[] ch = ss.toCharArray();
int j = ch.length;
for (int i = 0; i <j/2; i++) {
if (ch[i] != ch[j - i - 1]) {//这里是第一位与最后一位比较，j是字符数组的长度，-i-1表示正数与倒数相对应。
System.out.println("你输入的正整数不是回文数。");
break;
} else{
System.out.println("你输入的正整数是回文数。");
return;
}
}
}
}
运行效果：
题目：对10个数进行排序
思路，冒泡排序参考：https://blog.csdn.net/qq_43055855/article/details/113995139
public class Practice29 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入十个数：");
int[] a = new int[10];
for (int i = 0; i < 10; i++) {
a[i] = s.nextInt();
}
for (int i = 0; i < 10; i++) {
for (int j = i + 1; j < 10; j++) {
if (a[i] > a[j]) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
for (int i = 0; i < 10; i++) {
System.out.println("排序后的结果："+a[i]+" ");
}
}
}
题目：求一个3*3矩阵对角线元素之和
思路：双层for循环键盘录入九个整数，放到二维数组里面。来一个判断每三个数的中间下标相等则记录总和。
public class Practice30 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int [] [] a = new int[3][3];
System.out.println("请输入9个整数");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
a[i][j] = s.nextInt();
}
}
System.out.println("输入的3*3矩阵是:");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.println(a[i][j] +" ");
}
System.out.println();
}
int sum = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i==j) {
sum+= a[i][j];
}
}
}
System.out.println("对角线之和是："+sum);
}
}
题目：取一个整数a从右端开始的4~7位。
import java.util.Scanner;
public class Practice32 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入一个7位以上的正整数。");
long a = s.nextLong();
String ss = Long.toString(a);
char[] ch = ss.toCharArray();
int j = ch.length;
if (j<7) {
System.out.println("输入有误");
}else {
System.out.println("截取从右端开始的4-7位是："+ch[j-7]+ch[j-6]+ch[j-5]+ch[j-4]);
}
}
}
题目：打印出杨辉三角形（要求打印出10行如下图）
第一种
六行六列的杨辉三角，二维数组可以想到，从第二行开始，每一行的第一个数与最后一个数都为1。
ublic class Practice33 {
public static void main(String[] args) {
/*
六行六列的杨辉三角
*/
int row = 6; // 行数。
int [][] yanghui = new int[row][row]; //六行六列的数组
for (int i = 0; i < row; i++) { // 遍历了六次，6行
for (int j = 0; j <=i; j++) { // 6列
if (j==0||j==i) { // 第一个数的下表和最后一个数的下表相同。
yanghui[i][j] = 1; // 第一个数和最后一个数都为1.
}else {
yanghui[i][j] = yanghui[i-1][j-1]+yanghui[i-1][j]; // 除了第一个数和最后一个数，中间的数等于前一行的数加前一行得数的后一个数相加的值。
}
System.out.print(yanghui[i][j]+" ");
}
System.out.println();
}
}
第二种：等腰三角形的杨辉三角。
public class YangHui {
public static void main(String[] args) {
/**
* 8行8列的杨辉三角
*/
int row = 6;//行数
int[][] yanghui = new int[row][row];//6行6列数组
for (int i = 0; i < row; i++){//行
for(int j = 0;j<= i;j++){//列
if (j==0 || j==i){
yanghui[i][j]=1;
}else{
yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
}
}
//等腰输出处理
for (int i = 0; i < row; i++){
int num = row -i;
for(int j = 0;j<= num;j++){
System.out.print(" ");
}
for(int k= 0;k<= i;k++){
System.out.print(yanghui[i][k]+" ");
}
System.out.println();
}
}
}
运行效果：
题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
思路：题目的意思似乎不能用length()函数
package Day53;
import java.util.Scanner;
public class Practice38 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入一个字符");
String str = s.nextLine();
System.out.println("字符串的长度:"+str.length());
}
}
题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
思路：我在想n个人围成一圈，我就把n个人放一个boolean类型的数组里面嘛，依次遍历这个数组，boolean类型的数据初始化都是true，定义一个变量countNum来记录每到第三个人就重新赋值0，再定义index索引，然后n的人数减少，直到索引与输入的n人数相同的时候，就再次遍历n个人，比到最后一个了arr[i]的值为true的时候也就是原来排在i+1位的人留了下来了。
import java.util.Scanner;
public class Practice37 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入排成一圈的人数：");
int n = s.nextInt();
boolean[] arr = new boolean[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = true; //因为数组赋值都为true
}
int leftCount = n; // 总共有n个人嘛。
int countNum = 0 ;// 用来计数的，以3为一个基准。
int index = 0;// 索引，用来往下数数。
while (leftCount>1) {
if (arr[index]==true) {
countNum++; // 记一个数。
if (countNum==3){ // 如果数到第三个人了的话。
countNum =0; // 就把计数变量清零，继续执行，把这个人拖出去。
arr[index] = false;
leftCount--; // 总人数减少一个。
}
}
index++; // 索引++， 一次往下移动
if (index==n) {
index = 0;
}
}
for (int i = 0; i < n; i++) {
if (arr[i] ==true) {
System.out.println("原来排在第"+(i+1)+"位的人留了下来。");
}
}
}
}
运行效果：
二分法查找——在a[0] <=a[1] <= …a[n-1]中，找到x则返回x所在的位置，否则返回-1；
第一种方法：因为JAVA里面自带了一个binarySearch二分查找的方法，可以直接拿过来用就好了，定义一个数组，输入要查找数的位置，最后打印出开即可。
// Like public version, but without range checks.
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
import static java.util.Arrays.binarySearch;
public class BinarySearch {
public static void main(String[] args) {
int [] a = {0,1,3,6,7,10,21,34,36,40,76};
int x = 34; // 设置要查找的数
int position = binarySearch(a, 34);
System.out.println(x+"在数组中的位置是"+position);
}
第二种自己写：可以定义一个二分查找的方法，参数就设置为数组和想要查找数组元素的值的索引。定义一个左节点和右结点，可以来一个循环，以为中间索引为界限，划分开来，如果这个数刚还等于中间的数，那么中间索引就直接返回，如果大于中间的数，则把中间结点的索引加一再赋给相当于排了一个序，左边大的数放到了右边，反之右边大的数就放到了左边。
public class BinarySearch {
// 在a[0] <=a[1] <= ...a[n-1]中
// 找到x则返回x所在的位置，否则返回-1；
// int left = 0;
// int right = a.length-1;
public static int binarySearch(int[] a, int x) {
int left = 0;
int right = a.length - 1;
while (left <= right) {
int midddle = (left + right) / 2;
if (x == a[midddle])
return midddle;
if (x > a[midddle])
left = midddle + 1;
else
right = midddle - 1;
}
return -1;
}
public static void main(String[] args) {
int[] a = {0, 1, 3, 6, 7, 10, 21, 34, 36, 40, 76};
int x = 34; // 设置要查找的数
int position = binarySearch(a, x);
System.out.println(x + "在数组中的位置是" + position);
}
}
运行结果：
附上JAVA期末考试题库
1．下列语句序列执行后，k 的值是( B )。
int m=3, n=6, k=0;
while( (m++) < ( – n) )
++k;
A) 0 B) 1 C) 2 D) 3
2．设 i、j 为int型变量名，a 为int型数组名，以下选项中，正确的赋值语句是( B )。
A) i = i + 2 B) a[0] = 7;
C) i++ - --j; D) a(0) = 66;
3．Java语言的类间的继承关系是( B )。
A) 多重的 B) 单重的 C) 线程的 D) 不能继承
4．设有定义 int i = 6 ;，则执行以下语句后，i 的值为( C )。
i += i - 1;
A) 10 B) 121 C) 11 D) 100
5．下列选项中，用于在定义子类时声明父类名的关键字是( C )。
A）interface B) package C) extends D) class
6．若已定义 byte[ ] x= {11,22,33,-66} ;
其中0≤k≤3，则对x数组元素错误的引用是( C )。
A) x[5-3] B) x[k] C) x[k+5] D) x[0]
7．下列语句序列执行后，ch1 的值是( B )。
char ch1=‘A’,ch2=‘W’;
if(ch1 + 2 < ch2 ) ++ch1;
A) ‘A’ B) ‘B’ C) ‘C’ D) B
8．下列语句序列执行后，i 的值是( D )。
int i=8, j=16;
if( i-1 > j ) i–;
else j–;
A) 15 B) 16 C) 7 D) 8
9．下列语句序列执行后，k 的值是( C )。
int i=10, j=18, k=30;
switch( j - i )
{ case 8 : k++;
case 9 : k+=2;
case 10: k+=3;
default : k/=j;
}
A) 31 B) 32 C) 2 D) 33
10．下面语句执行后，i 的值是( B )。
for( int i=0, j=1; j < 5; j+=3 )
i=i+j;
A) 4 B) 5 C) 6 D) 7
11．设有定义 float x=3.5f, y=4.6f, z=5.7f；则以下的表达式中，值为true的是( B )。
A) x > y || x > z B) x != y
C) z > ( y + x ) D) x < y & ! ( x < z )
12．下列语句序列执行后，i的值是( D )。
int i=16;
do { i/=2; } while( i > 3 );
A) 16 B) 8 C) 4 D) 2
13．以下由 for 语句构成的循环执行的次数是( B )。
for ( int i = 0; true ; i++) ;
A) 有语法错，不能执行 B) 无限次
C) 执行1次 D) 一次也不执行
14．定义类头时能使用的修饰符是(C )。
A) private B) static C) abstract D) protected
15．设int 型变量 a、b，float 型变量 x、y，char 型变量 ch 均已正确定义并赋值， 正确的switch语句是D )。
A) switch (x + y) B) switch ( ch + 1 )
{ … } { … }
C) switch ch D) switch ( a + b );
{ … } { … }
- 下列最终属性 i 的定义中，正确的是( )。
A) static final int i=100;
B) final int i=1.2;
C) final i=‘w’;
D) final char i;
- 下列类定义中，不正确的是(C )。
A) class x { … }
B) class x extends y { … }
C) static class x implements y1,y2 { … }
D) public class x extends Applet { … } - 设 x、 y为已定义的类名，下列声明x类的对象x1的语句中正确的是( )。
A) static x x1;
B) public x x1=new x(int 123);
C) y x1;
D) x x1=x( ); - 设 i、j、k 为类 x 中定义的 int 型变量名，下列类 x 的构造函数中不正确的是( B )。
A) x( int m){ … }
B) void x( int m){ … }
C) x( int m, int n){ … }
D) x( int h,int m,int n){ … } - 下列方法定义中，正确的是( A )。
A) int x( ){
char ch=‘a’;
return (int)ch;
}
B) void x( ){
…return true; }
C) int x( ){ …
.return true; }
D) int x( int a, b){
return a+b; } - 用于定义类成员的访问控制权的一组关键字是( D )。
A) class, float, double, public
B) float, boolean, int, long
C) char, extends, float, double
D) public, private, protected - 不能构成循环的语句是( C )。
A) for 语句 B) while 语句 C) switch 语句 D) do__while 语句 - 下列程序段执行后 b3 的结果是( D )。
boolean b1=true, b2, b3;
24= b1 ? b1 : b2;
A) 0 B) 1 C) true D) false
25 下面数据结构中，属于非线性的是( B )。
A) 线性表 B) 树 C) 队列 D) 堆栈 - 设有定义 int i=123; long j=456; 下面赋值不正确的语句是( D )。
A) j=i; B) j=(long)i; C) i=(int)j; D) i=j;
填空题： - 构造函数_没__有返回值。
- Java语言中的浮点型数据根据数据存储长度和数值精度的不同，进一步分为float和 ___ double _______两种具体类型。
- 创建类对象的运算符是__ new。
- 当整型变量n的值不能被13除尽时，其值为 false 的Java语言表达式是__n%13==0___________ 。
- 在Java语言中，所有的数组都有一个lenght属性，这个属性存储了该数组的__元素个数。
- 定义类就是定义一种抽象的______父类______，它是所有具有一定共性的对象的抽象描述。
- 在Java语言中，使用__平台无关___、___java虚拟机___等技术，实现软件重用。
- 表达式3/6 * 5的计算结果是____0____ 。
9.下面是一个类的定义:
public class _int Myclass___________
{
int x, y;
Myclass ( int i, ___=0____) // 构造函数
{
x=i;
y=j;
}
}
10.下面是一个Java Application 的主类的定义，其功能是输出所有命令行参数。
import java.io.*;
public class MyClass
{
public static void main(String args[ ])
{
if( args.length !=_0__)
for(int i=0; i < args.length; i++)
System.out.println(_"i="+i__________);
else System.out.println(没有命令行参数);
}
}
11下面是一个小程序的主类myprogram的定义, 其中A、B是该主类所在源程序中已定义的另两个类的类名:
import java awt.；
import java applet.；
public class myprogram extends Applet//定义小程序的主类
{
A a; B b;
public _____ myprogram ___ init( )
{ a=new A( )； b=new B( ); }
}
12. Java的复合数据类型有 : 类、数组和___接口____等。 Java的简单数据类型有 : 数值类型（整形和浮点类型），自负类型和布尔类型
13. 表达式3/6 * 5的计算结果是_0______ 。
14.定义初值为10的10次方的长整型变量 lvar 的语句是：long lvar=1e10____________。
15. 顺序结构、分支结构(或称选择结构)、__循环结构__________是结构化程序设计的三种基本流程控制结构。
16. 以下方法 m 的功能是求两参数之积的整数部分。
int m ( float x, float y )
{ _______k=(int)xy___________; }
17. Java 源程序文件编译后产生的文件称为____字节码____文件,其扩展名为 .class____ 。
程序分析：
- 下面是一个排序的程序:
import java.io.*;
public class Test56_Sort
{
public static void main(String args[ ])
{
int[] a={42,99,5,63,95,36,2,69,200,96};
System.out.println(排序前的数据序列:);
ShowArray(a);
Sort(a);
System.out.println(排序后的数据序列:);
ShowArray(a);
}
public static void Sort(int[] x)
{
int w;
for(int i=1; i<x.length; i++)
{
for(int j=0; j<x.length-1; j++)
if(x[j]>x[j+1])
{ w=x[j]; x[j]=x[j+1]; x[j+1]=w; }
/* if(i==1||i==2) ShowArray(x);
if(i==2) break; */
}
}
public static void ShowArray(int b[])
{
for(int i=0; i<b.length; i++)
System.out.print("b[i"+i+"]=" +b[i]);
System.out.println( );
}
}
问题： 如果将方法Sort( )中的一对注释符（/* */）去掉，程序输出的结果是什么?
排序前的数据序列:
b[0]=42b[1]=99b[2]=5b[3]=63b[4]=95b[5]=36b[6]=2b[7]=69b[8]=200b[9]=96
b[0]=42b[1]=5b[2]=63b[3]=95b[4]=36b[5]=2b[6]=69b[7]=99b[8]=96b[9]=200
b[0]=5b[1]=42b[2]=63b[3]=36b[4]=2b[5]=69b[6]=95b[7]=96b[8]=99b[9]=200
排序后的数据序列:
b[0]=5b[1]=42b[2]=63b[3]=36b[4]=2b[5]=69b[6]=95b[7]=96b[8]=99b[9]=200
- 请写下程序的输出结果：
public class Test52
{
String str1="Hello, Java world! \t";
String str2="Hello, students!" ;
public static void main(String args[])
{
System.out.print(str1);
System.out.println(str2);
}
}
输出结果：
3. 请写下程序的输出结果：
public class T2_4 {
public static void main(String[] args)
{
int i,j;
char c='*';
for(i=0;i<5;i++)
{
for(j=0;j<=i;j++)
System.out.print("* ");
System.out.println();
}
}
}
输出结果：
4、请写下程序的输出结果：
public class ex2_2
{
public static void main (String args[ ] )
{
int x , y ;
byte b = 6;
float z = 1.234f ;
double w = 1.23;
boolean flag;
x = 12 ;
y = 300;
flag=x>y;
System.out.println("x>y=="+flag);
flag=z>w;
System.out.println("z>w=="+flag);
}
}
四、问答题：（每题5分，）
1. Java的接口和C++的虚类的相同和不同处。
由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是
public static，所有方法默认情况下是public.一个类可以实现多个接口。
2. 垃圾回收的优点和原理。并考虑2种回收机制。
Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
3，谈谈final， finally， finalize的区别。
Final－修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为
abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
Finally－再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch
子句就会执行，然后控制就会进入 finally 块（如果有的话）。 Finalize－方法名。Java 技术允许使用
finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在
Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize（）
方法以整理系统资源或者执行其他清理工作。finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。
4，数组有没有length（）这个方法？ String有没有length（）这个方法？举例说明使用方法？
数组没有length（）这个方法，有length的属性。 String中有length（）这个方法。
- Java中的异常处理机制的简单原理和应用。
当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界，会引发IndexOutOfBoundsException；访问null的对象时会引发
NullPointerException.另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用
throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。
五、程序设计：（每题11分，共33分）
1、编程：编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"，6，应该输出为"我ABC"而不是"我ABC+汉的半个"。
package Practice;
import java.util.Scanner;
public class TestAgricuter {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入字符串");
String str1 = sc.next();
System.out.println("请输入需要截取的字符");
int n = sc.nextInt();
str_split(str1, n);
}
}
public static void str_split(String str1, int n) {
if (str1 == null) {
System.out.println("请输入值");
return;
}
int byte_all = 0;
byte_all = str1.length();
byte byte_[] = str1.getBytes();
if (n > byte_all)
n = byte_all;
if (byte_[n - 1] < 0) {
System.out.println("subStr=" + new String(byte_, 0, n - 1));
} else {
System.out.println("subStr=" + new String(byte_, 0, n));
}
}
}
2、编程求解：所有两位整数能被3整除的数的和，以及不能被3整除的数的各位数字之和。
package Practice;
public class Sums {
public static void main(String[] args) {
System.out.println("输出0-100能被3整除的数的和");
int num = 1;
int sum = 0;
while (num<100) {
if (num%3==0) {
sum = sum+num;
System.out.println("这个数是："+num+"和为："+sum);
}
num+=1;
}
System.out.println("程序执行结束了");
}
}
题库2
1、关于Java语言叙述错误的是：（ C ）
A．Java语言具有跨平台性
B．Java是一种面向对象的语言
C．Java语言中的类可以多继承
D．Java的垃圾收集机制自动回收程序已不再使用的对象
2、以下叙述正确的是：（ B ）
A．构造方法必须是public方法
B．main方法必须是public方法
C．Java应用程序的文件名可以是任意的
D．构造方法应该声明为void类型
3、关于Java中数据类型叙述正确的是：（ B ）
A、整型数据在不同平台下长度不同
B．boolean类型数据只有2个值，true和false
C．数组属于简单数据类型
D．Java中的指针类型和C语言的一样
4、设 int x=1,float y=2，则表达式 x / y的值是：（ D ）
A．0
B．1
C．2
D．以上都不是
5、以下语句有语法错的是：（ A ）
A．int x=1；y=2；z=3
B．for (int x=10,y=0；x>0；x++);
C．while (x>5);
D．for(; );
6、关于类和对象的叙述正确的是：（ A ）
A．Java的类分为两大部分：系统定义的类和用户自定义的类
B．类的静态属性和全局变量的概念完全一样，只是表达形式不同
C．类的成员至少有一个属性和一个方法
D．类是对象的实例化
7、以下有关构造方法的说法，正确的是：（ A ）
A．一个类的构造方法可以有多个
B．构造方法在类定义时被调用
C．构造方法只能由对象中的其它方法调用
D．构造方法可以和类同名，也可以和类名不同
8、以下有关类的继承的叙述中，正确的是：（ D ）
A．子类能直接继承父类所有的非私有属性，也可通过接口继承父类的私有属性
B．子类只能继承父类的方法，不能继承父类的属性
C．子类只能继承父类的非私有属性，不能继承父类的方法
D．子类不能继承父类的私有属性
9、下列属于容器的组件有：（ B ）
A．JButton
B．JPane
C．Canvas
D．JTextArea
10、void 的含义：（ C ）
A．方法体为空
B．定义的方法没有形参
C．定义的方法没有返回值
D．方法的返回值不能参加算术运算
11、关于Java中异常的叙述正确的是：（ D ）
A．异常是程序编写过程中代码的语法错误
B．异常是程序编写过程中代码的逻辑错误
C．异常出现后程序的运行马上中止
D．异常是可以捕获和处理的
12、所有的异常类皆继承哪一个类？（ C ）
A．java.io.Exception
B．java.lang.Throwable
C．java.lang.Exception
D．java.lang.Error
13、下面哪个不是java语言中的关键字？（ B ）
A．long
B．sizeof
C．instanceof
D．const
14、为实现进程之间的通信，需要使用下列那种流才合适？（D）
A．Data stream
B．File stream
C．Buffered stream
D．Piped stream
15、在复选框中移动鼠标，然后单击一选项，要捕获所选项必需实现哪个接口？（D）
A．ActionListener
B．MouseListener
C．MouseMotionListern
D．ItemListener
二、填空题（每空1分，共20分）
1、面向对象程序设计所具有的基本特征是：抽象性，封装性__，继承性_，多态性_
2、数组x定义如下
int x[ ][ ]=new int[3][2]
则 x…length 的值为____3________，
x[0].length 的值为_____2_______。
3、Java中实现多线程一般使用两种方法，一是___继承Thread类_________，二是_____实现Runnable方法__________
4、Java的图形用户界面设计中，有很多布局管理器用来摆放组件的位置，一般用到的布局管理器有（列出四种即可）FlowLayout___，GridLayout__，BorderLayout___，CardLayout____
5、Applet常用的方法是：__init()_、run（）、__stop()__和destroy()。
三、阅读程序，写出程序的输出结果（每题5分，共20分）
class A{
private int privateVar;
A(int _privateVar){
privateVar=_privateVar;
}
boolean isEqualTo(A anotherA){
if(this.privateVar == anotherA.privateVar)
return true;
else
return false;
}
}
public class B{
public static void main(String args[]){
A a = new A(1);
A b = new A(2);
System.out.println(a.isEqualTo(b));
}
}
程序的输出结果为：false_
class A {
double f(double x, double y) {
return x * y;
}
}
class B extends A {
double f(double x, double y) {
return x + y;
}
}
public class Test {
public static void main(String args[]) {
B obj = new B();
System.out.println("The program output is " + obj.f(4, 6));
}
}
程序的输出结果为：__ The program output is 10_
public class Unchecked {
public static void main(String[] args) {
try {
method();
} catch (Exception e) {
System.out.println("A");
} finally {
System.out.println("B");
}
}
static void method() {
try {
wrench();
System.out.println("C");
} catch (ArithmeticException e) {
System.out.println("D");
} finally {
System.out.println("E");
}
System.out.println("F");
}
static void wrench() {
throw new NullPointerException();
}
}
程序的输出结果为：
E
A
B
第四题：
public class Test {
public static void main(String[] args) {
int x;
int a[] = { 0, 0, 0, 0, 0, 0 };
calculate(a, a[5]);
System.out.println("the value of a[0] is " + a[0]);
System.out.println("the value is a[5] is " + a[5]);
}
static int calculate(int x[], int y) {
for (int i = 1; i < x.length; i++)
if (y < x.length)
x[i] = x[i - 1] + 1;
return x[0];
}
}
程序的输出结果为：
the value of a[0] is 0
the value is a[5] is 5
- 下面哪些是short型的取值范围 [C]
A. -27 – 27-1
B. 0 – 216-1
C. -215 – 215-1
D. -231 – 231-1 - 下面哪些是合法的标识符 [ABE]
A. $persons
B. TwoUsers
C. *point
D. this
E. _endline - 哪些是将一个十六进制值赋值给一个long型变量 [D]
A. long number = 345L;
B. long number = 0345;
C. long number = 0345L;
D. long number = 0x345L; - 下面的哪些程序片断可能导致错误。 [BD]
A.
String s = “Gone with the wind”;
String t = " good ";
String k = s + t;
B.
String s = “Gone with the wind”;
String t;
t = s[3] + “one”;
C.
String s = “Gone with the wind”;
String standard = s.toUpperCase();
D.
String s = “home directory”;
String t = s - “directory”; - 在// point x处的哪些声明是合法的 [DE]
class Person {
private int a;
public int change(int m){ return m; }
}
public class Teacher extends Person {
public int b;
public static void main(String arg[]){
Person p = new Person();
Teacher t = new Teacher();
int i;
// point x
}
}
A. i = m;
B. i = b;
C. i = p.a;
D. i = p.change(30);
E. i = t.b;
6. 当Frame的大小被改变时, Frame中的按钮的位置也可能被改变，请问此时使用的是什么布局管理器 [B]
A. BorderLayout
B. FlowLayout
C. CardLayout
D. GridLayout
7. 给出下面的代码片断
1 public void create() {
2 Vector myVect;
3 myVect = new Vector();
4 }
下面的哪些陈述是正确的? [ADE]
A. 第二行的声明不会为变量myVect分配内存空间。 //指的是堆空间,只是在栈 中分配;这里不用较真.自己理解就好;
B. 第二行的声明分配一个到Vector对象的引用的内存空间。
C. 第二行语句创建一个Vector类对象。
D. 第三行语句创建一个Vector类对象。
E. 第三行语句为一个Vector类对象分配内存空间。
//分配栈空间,相当于指针,但是不分配"到Vector对象的引用的空间";选项二的意思是分配了堆空间;
8. 下面的哪些答案可以用以表示八进制值8? [A]
A. 010
B. 0x10
C. 08
D. 0x8
9. 哪些不是Java关键字 [AB]
A. TRUE
B. sizeof
C. const
D. super
E. void
10. 下面的哪些叙述为真。 [AD]
A. equals()方法判定引用值是否指向同一对象。 //不说是谁的就是默认的
B. == 操作符判定两个分立的对象的内容和类型是否一致。
C. equals()方法只有在两个对象的内容一致时返回true。
D. 类File重写方法equals()在两个分立的对象的内容和类型一致时返回true。 //当两个独立的对象的内容和类型一致;
11. 下面关于继承的哪些叙述是正确的。 [AD]
A. 在java中只允许单一继承。
B. 在java中一个类只能实现一个接口。
C. 在java中一个类不能同时继承一个类和实现一个接口。
D. java的单一继承使代码更可靠。
12. 第十行的声明将调用哪些方法. [D]
1 class Person {
2 public void printValue(int i, int j) { }
3 public void printValue(int i){ }
4 }
5 public class Teacher extends Person {
6 public void printValue() { }
7 public void printValue(int i) {}
8 public static void main(String args[]){
9 Person t = new Teacher();
10 t.printValue(10);
11 }
12 }
A. 第2行的方法
B. 第3行的方法
C. 第6行的方法
D. 第7行的方法
13. 下面哪些不是java的原始数据类型 [BC]
A. short
B. Boolean
C. unit
D. float
14. 下面的哪些关键字通常用来对对象的加锁，该标记使得对对象的访问是排他的? [B]
A. transient
B. synchronized
C. serialize
D. static
15. main()方法的返回类型是什么？ [B]
A. int
B. void
C. boolean
D. static
16. 给出以下关于一个使用适当的字符间距的字体的TextField的表达式
TextField t = new TextField(“they are good”,40);//40指的是像素
哪些叙述是对的？ [D]
A. 被显示的字符串可以使用多种字体。
B. 一行中最大的字符数是40
C. 显示的宽度正好是40个字符宽。
D. 用户可以编辑字符。
- 关于垃圾收集的哪些叙述是对的? [B]
A. 程序开发者必须自己创建一个线程进行内存释放的工作。
B. 垃圾收集将检查并释放不再使用的内存。
C. 垃圾收集允许程序开发者明确指定并立即释放该内存。
D. 垃圾收集能够在期望的时间释放被java对象使用的内存。 - 给出下面的代码
1 public class Test {
2 int m, n;
3 public Test() {}
4 public Test(int a) { m=a; }
5 public static void main(String arg[]) {
6 Test t1,t2;
7 int j,k;
8 j=0; k=0;
9 t1=new Test();
10 t2=new Test(j,k);
11 }
12 }
在编译时哪行将导致一个错误? [D]
A. 第3行
B. 第5行
C. 第6行
D. 第10行
19. Thread的方法resume()负责恢复哪些线程的执行? [D]
A. 通过调用stop()方法而停止的线程。
B. 通过调用sleep()方法而停止运行的线程。
C. 通过调用wait()方法而停止运行的线程。
D. 通过调用suspend()方a法而停止运行的线程。 //已经过期了
20. 有关线程的哪些叙述是对的? [BD]
A. 一旦一个线程被创建，它就立即开始运行。
B. 使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
C. 当一个线程因为抢先机制而停止运行，它被放在可运行队列的前面。//比它 优先级高的进程抢占了cpu，它运行的时间根据操作系统而定；
D. 一个线程可能因为不同的原因停止并进入就绪状态。//可运行状态
21. 给出下面的不完整的方法
1
2 { success = connect();
3 if (success==-1) {
4 throw new TimedOutException();
5 }
6 }
已知TimedOutException 不是一个RuntimeException。下面的哪些声明可以被加入第一行完成此方法的声明 [BC]
A. public void method()
B. public void method() throws Exception
C. public void method() throws TimedOutException
D. public void method() throw TimedOutException
E. public throw TimedOutException void method()
- 给出下面的代码
class Person {
String name,department;
public void printValue(){
System.out.println("name is "+name);
System.out.println("department is "+department);
}
}
public class Teacher extends Person {
int salary;
public void printValue(){
// 完成父类代码中printValue()相同的工作
System.out.println("salary is "+salary);
}
}
下面的哪些表达式可以加入printValue()方法的注释部分? [D]
A. printValue();
B. this.printValue();
C. person.printValue();
D. super.printValue();
23. 下面的哪些赋值语句是错的? [A]
A. float f = 11.1;
B. double d = 5.3E12;
C. double d = 3.14159;
D. double d = 3.14D;
24. 给出下面的不完整的类代码
class Person {
String name, department;
int age;
public Person(String n){ name = n; }
public Person(String n, int a){ name = n; age = a; }
public Person(String n, String d, int a) {
// 完成Person(String n, int a)的逻辑
department = d;
}
}
下面的哪些表达式可以加到构造方法中的注释处? [C]
A. Person(n,a);
B. this(Person(n,a)); //构造函数的名字不能当方法名调用;
C. this(n,a);
D. this(name,age); //构造方法的参数也不能直接传实例变量名
25. 下面关于变量及其范围的陈述哪些是对的? [ACD]
A. 实例变量是类的成员变量。
B. 实例变量用关键字static声明。
C. 在方法中定义的局部变量在该方法被执行时创建
D. 局部变量在使用前必须被初始化。
26. 给出下面的代码
public void test() {
try {
oneMethod();
System.out.println("condition 1");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("condition 2");
} catch(Exception e) {
System.out.println("condition 3");
} finally {
System.out.println("finally");
}
}
在oneMethod()方法运行正常的情况下将显示什么? [AD]
A. condition 1
B. condition 2
C. condition 3
D. finally
27. 给出下面的代码
public class Test {
void printValue(int m){
do {
System.out.println("The value is"+m);
}while( --m > 10 );
}
public static void main(String arg[]) {
int i=10;
Test t= new Test();
t.printValue(i);
}
}
输出将是什么？ [C]
A. 8
B. 9
C. 10
D. 11
28. 下面的有关声明的哪些叙述是对的? [BC]
A. 对原始数据类型例如boolean,byte的变量的声明不会为该变量分配内存空间。
B. 对原始数据类型例如boolean,byte的变量的声明将为之分配内存空间。
C. 非原始数据类型例如String,Vector的变量的声明不会为该对象分配内存。
D. 非原始数据类型例如String,Vector的变量的声明会为该对象分配内存。
//该对象指的是堆空间的对象;指向该对象的引用只能叫变量;
29. 类的设计要求它的某个成员变量不能被外部类直接访问。应该使用下面的哪些修饰符获得需要的访问控制? [D]
A. public
B. 不加修饰符
C. protected
D. private //面向对象编程P196页的表格,private一行有错误
30. 给出下面的代码片断
1 String str = null;
2 if ((str != null) && (str.length() > 10)) {
3 System.out.println(“more than 10”);
4 }
5 else if ((str != null) & (str.length() < 5)) {//空指针异常
6 System.out.println(“less than 5”);
7 }
8 else { System.out.println(“end”); }
哪些行将导致错误? [C]
A. 第1行
B. 第2行
C. 第5行
D. 第8行
31. 下面有关java代码安全性的叙述哪些是对的? [BCD]
A. 字节码校验器加载查询执行需要的所有类。
B. 运行时解释器执行代码。
C. 在运行时，字节码被加载，验证然后在解释器里面运行。
D. 类加载器通过分离本机文件系统的类和从网络导入的类增加安全性。
- 给出下面的代码
public class Person{
int arr[] = new int[10];//非静态属性
public static void main(String a[]) {
System.out.println(arr[1]);//静态方法不能访问非静态属性
}
}
哪些叙述是对的? [A]
A. 编译时出错。
B. 编译时正确而运行时出错。
C. 输出0。
D. 输出null。 - 给出下面的代码
public class Parent {
public int addValue( int a, int b) {
int s;
s = a+b;
return s;
}
}
class Child extends Parent {
}
哪些方法可以加入类Child中? [BC] //方法的覆盖
A. int addValue( int a, int b ){// do something…}
B. public void addValue (){// do something…}
C. public int addValue( int a ){// do something…}
D. public int addValue( int a, int b )throws Exception {//do something…} - 公有成员变量MAX_LENGTH是一个int型值，变量的值保持常数值100，定义这个变量的代码为? [CD]
A. public int MAX_LENGTH=100;
B. final int MAX_LENGTH=100;
C. final public int MAX_LENGTH=100; //修饰符的顺序可以交换
D. public final int MAX_LENGTH=100; - 下面的哪些java源文件代码片断是对的? [ACD]
A. package testpackage;
public class Test{//do something…}
B. import java.io.;
package testpackage;
public class Test{// do something…}
C. import java.io.;
class Person{// do something…}
public class Test{// do something…}
D. import java.io.;
import java.awt.;
public class Test{// do something…} - 给出下面的类
public class Sample{
long length;
public Sample(long l){ length = l; }
public static void main(String arg[]){
Sample s1, s2, s3;
s1 = new Sample(21L);
s2 = new Sample(21L);
s3 = s2;
long m = 21L;
}
}
哪个表达式返回true? [B]
A. s1 == s2;
B. s2 == s3;
C. m == s1;
D. s1.equals(m);
37. 给出下面有关java.awt.List的表达式
List l = new List(6,true);//第二个参数是false的话只能选一个
其中哪些叙述是正确的? [AC]
A. 在没有其它的约束的条件下该列表将有6行可见。
B. 一行的最大字符数是6
C. 列表将允许用户多选
D. 列表只能有一项被选中
- 给出下面的代码
class Parent {
String one, two;
public Parent(String a, String b){
one = a;
two = b;
}
public void print(){ System.out.println(one); }
}
public class Child extends Parent {
public Child(String a, String b){
super(a,b);
}
public void print(){
System.out.println(one + " to " + two);
}
public static void main(String args[]){
Parent p = new Parent("south", "north");
Parent t = new Child("east", "west");
p.print();
t.print();
}
}
下面的哪些情况或输出的结果正确? [E]
A. 编译时出错
B. south
east
C. south to north
east to west
D. south to north
east
E. south
east to west
39. 类Teacher和Student都是类Person的子类
Person p;
Teacher t;
Student s;
若p,t和s都是非空值
if(t instanceof Person) { s = (Student)t; }
这个语句导致的结果是什么? [C] // 默认new时声明的都是本类;
A. 将构造一个Student对象
B. 表达式合法
C. 编译时非法
D. 编译时合法而在运行时可能非法
- 给出下面的代码
String s= “hello”;
String t = “hello”;
char c[] = {‘h’,‘e’,‘l’,‘l’,‘o’};
下列选项里，哪些返回true？ [ACD]
A. s.equals(t);
B. t.equals©;
C. st;
D. t.equals(new String(“hello”));
E. tc;
8.下列语句序列执行后，k 的值是( )。
int x=2, y=5, k=0;
switch( x%y ) {
case 0: k=x+y; break;
case 1: k=x-y; break;
case 2: k=x*y; break;
default: k=x/y; break;
}
System.out.println(k);
A) 2 B) 5 C) 10 D) 0 【答案】C
9. 下面的程序输出的结果是（ ）
public class A implements B {
public static void main(String args[]) {
int i;
A c1 = new A();
i= c1.k;
System.out.println("i="+i);
}
}
interface B {
int k = 10;
}
A) i=0 B) i=10 C) 程序有编译错误 D) i=true
【答案】B
10．应用程序的main方法中有以下语句，则输出的结果是 ( )。
int b[][]={{1, 2, 3}, {4,5}, {6,7}};
int sum=0;
for(int i=0;i<b.length;i++) {
for(int j=0;j<b[i].length;j++) {
sum+=b[i][j];
}
}
System.out.println("sum="+sum);
A) 28 B)6 C) 9 D) 13 【答案】A
11. 有整型数组：int[] x={12,35,8,7,2};,则调用方法Arrays.sort(x)后，数组x中的元素值依次是( ).
A) 2 7 8 12 35 B) 12 35 8 7 2 C) 35 12 8 7 2 D) 8 7 12
35 2
【答案】A
12.编译和运行下面的应用程序，并在命令行界面输入12345，则回车后屏幕输出的结果是( ).
public class A {
public static void main(String args[]) throws IOException{
BufferedReader buf=new BufferedReader(
new InputStreamReader(System.in));
String str=buf.readLine();
int x=Integer.parseInt(str);
System.out.println(x/100);
}
}
A) 45 B)5 C) 123 D) 12345 【答案】C
13.下面的程序段执行后输出的结果是( )。
StringBuffer buf=new StringBuffer(“Beijing2008”);
buf.insert(7,"@");
System.out.println(buf.toString());
A) Beijing@2008 B) @Beijing2008 C) Beijing2008@ D) Beijing#2008 【答案】A
14. 下面的程序编译运行后输出的结果是( )。
public class A implements Runnable {
public static void main(String argv[]) {
A a = new A();
Thread t = new Thread(a);
t.start();
}
public void run() {
while(true) {
try{
Thread.currentThread().sleep(1000);
}catch(InterruptedException e){
System.out.println(e.toString());
}
System.out.println("looping while");
}
}
}
A) 在屏幕上重复输出"looping while"。
B) 在屏幕上输出一次"looping while"。
C) 没有结果输出。
D) 以上说法都错误。
【答案】A
15.下面的程序段创建了BufferedReader类的对象in，以便读取本机d盘my文件夹下的文件1.txt。File构造函
数中正确的路径和文件名的表示是( )。
File f=new File(填代码处);
file=new FileReader(f);
in=new BufferedReader(file);
A) “1.txt” B) “d:\my\1” C) “d:\my\1.txt” D) “d:\ my\1.txt”
【答案】C
二、多选题（本大题10小题，每小题2分，共20分）
1.下面的说法正确的是( )。
A) Java 语言是面向对象的、解释执行的网络编程语言。
B) Java 语言具有可移植性，是与平台无关的编程语言。
C) Java 语言可对内存垃圾自动收集。
D) Java 语言编写的程序虽然是“一次编译，到处运行”，但必须要java的运行环境。
【答案】ABCD
2.下面main()方法的定义哪些是正确的( )？
A)public static void main(String args[]) {}
B)public static void main(String[]) {}
C)public static void main(String[] args) {}
D)public static void main(String [] x) {}
【答案】ACD
3.定义变量如下:
char c=‘w’;
int i=8;
long L=15;
float f=8.9f;
以下赋值语句正确的是( )。
A) i=c+i; B) c=c+i; C) L=f+L; D) f=i+L+f;
【答案】AD
4.下面哪些关键字能用来控制对类成员的访问( )？
A)public B)protected C)private D)default
【答案】ABC
5.面向对象程序设计的基本特征是( )。
A)抽象 B)封装 C)继承 D)多态 【答案】ABCD
6.下面关于类的说法正确的是( )。
A)类是 Java 语言中的一种复合数据类型。 B)类中包含数据变量和方法。
C)类是对所有具有一定共性的对象的抽象。 D) Java 语言的类只支持单继承。 【答案】ABCD
7. 编译并运行下面的程序，运行结果为( ).
public class T1 {
public static void main (String[] args){
T1 a=new T1();
a.method(8);
a.method(1.2f);
}
void method(float i) {
System.out.println("float: "+i);
}
void method(long i) {
System.out.println("long: "+i);
}
}
A)程序有编译错误，因为两个method()方法必须定义为静态（static）的。
B)程序可以编译运行，输出结果为：
long: 8
float: 1.2
C)程序可以编译运行，输出结果为：
float: 1.2
long: 8
D) 程序中定义的两个参数不同的method方法称为方法重载。 【答案】BD
8.下面是在命令行运行Java应用程序A，怎样才能在main(String args[])方法中访问单词"first" ( )?
java A the first snow , the first snow came.
A)args[0] B)args[1] C)args[2] D)args[5]
【答案】BD
9.编译并运行下面的程序，运行结果为( ).
public class A {
public static void main (String[] args) {
A a=new B( );
a.test();
}
void test() {
System.out.print ("A");
}
}
class B extends A {
void test() {
super.test();
System.out.println("B");
}
}
A)子类B定义了与父类A中同名的方法test，java中称为方法的覆盖。
B)代码可以编译运行，并输出结果：AB。
C)代码可以编译运行，并输出结果：A。
D)子类B定义了与父类A中同名的方法test，java中称为方法的重载。
【答案】AB
10.下面哪个说法正确( )？
A)如果某公共的接口被声明在一个源文件中，则接口必须与源文件具有相同的名字。
B)如果源文件包含import语句，则该语句必须是除空行和注释行外的第一个语句行。
C)如果某源文件包含package语句，则该语句必须是第一个非空、非注释行。
D)接口中的方法必定是抽象方法，但可以不用关键字abstract修饰。 【答案】ABCD
三、填空题（本大题10小题，每小题1分，共10分）
- 创建类的对象时，使用运算符____new_______给对象分配内存空间。
- 定义类的构造方法不能有返回值类型，其名称与__类___名相同。
- Java语言中关键字__double___表示双精度类型。
- 若有定义：float b={1.1f, 3.5f, 6.8f};，则b.length()的值是___3____。
5．若有类定义：
class B extends A{
…
}
则类B是类A的__子类____。
6．接口中的成员只有静态常量和___抽象方法___。
7. 在子类中使用关键字___super____做前缀可调用被子类覆盖的父类中的方法。
8. 关键字__import____用于导入包中的类到程序中，供程序中使用。
9. Java语言中, 通常把可能发生异常的方法调用语句放到try块中，并用紧跟其后的__catch___块来捕获和处理异
常。
10. 程序中实现多线程的方法有两种：继承_ Thread____类和实现Runnable接口。
【答案】
1.new
2.类
3.double
4. 3
5.子类
6. 抽象方法
7.super
8. import
9. catch
10. Thread
四、阅读程序，回答问题（本大题5小题，每小题5分，共25分）
- (5分)
1: public class Output1 {
2: public static void main(String arge[]) {
3: int i=0;
4: for ( char ch = 97; ch<113; ch++,i++) {
5: if( i % 8 == 0 )
6: System.out.println(" ");
7: System.out.print("\t" +ch);
8: }
9: }
10: }
(1)程序第5、6行的if语句的功能是什么？ (2分) (2)程序输出的结果有几行？(3分)
【答案】 (1)每打印8个字符，则换行。(2)输出的结果有2行。
2. (5分)
1: import java.util.Arrays;
2:
3: public class SortArray {
4: public static void main(String args[]) {
5: String[] str = {"size", "abs","length","class"};
6: Arrays.sort(str);
7: for (int i=0; i<str.length; i++)
8: System.out.print(str[i]+" ");
9: }
10: }
(1)写出程序运行后的结果。(2分)
(2)方法调用str[0].length()的返回结果是多少？(3分)
【答案】(1) abs class length size (2) 4
3. (5分)
1: //TestKeyListener.java
2: import java.applet.Applet;
3: import java.awt.*;
4: import java.awt.event.*;
5:
6: public class TestKeyListener extends Applet {
7:
8: Color clr;
9:
10: public void init() {
11:
12: addKeyListener(
13: new KeyAdapter() {
14: public void keyTyped( KeyEvent e ) {
15: if(e.getKeyChar()=='r'||e.getKeyChar()=='R')
16: clr=Color.red;
17: else if(e.getKeyChar()=='g'||e.getKeyChar()=='G')
18: clr=Color.green;
19: else if(e.getKeyChar()=='b'||e.getKeyChar()=='B')
20: clr=Color.blue;
21: else
22: clr=Color.black;
23: setBackground(clr);
24: }
25: });
26: }
27: }
(1)程序第15、16行实现的功能是什么？(2分)
(2)编译该程序，并编写嵌入该程序字节码文件的网页后，通过支持java的浏览器打开网页。如果敲击键盘的
‘b’键，有什么结果？(3分)
【答案】(1) 如果敲击键盘的‘r’键，则将颜色对象的值赋为红色。(2) 小程序的背景颜色变为蓝色。
4.定义类A和类B如下. (5分)
class A
{
int a=1;
double d=2.0;
void show( )
{
System.out.println("Class A: a="+a +"\td="+d);
}
}
class B extends A
{
float a=3.0f;
String d="Java program.";
void show( )
{
super.show( );
System.out.println("Class B: a="+a +"\td="+d);
}
}
(1) 若在应用程序的main方法中有以下语句：
A a=new A();
a.show();
则输出的结果如何？(2分)
(2) 若在应用程序的main方法中定义类B的对象b：
A b=new B();
b.show();
则输出的结果如何？(3分)
【答案】
(1) Class A: a=1 d=2.0
(2) Class A: a=1 d=2.0
Class B: a=3.0 d=Java program.
5. (5分)
import java.util.*;
public class W {
static String[] s={"甲","乙","丙","丁"};
public static void main(String[] args) {
Stack stk=new Stack();
for(int i=0;i<s.length;i++) {
stk.push(s[i]+" ");
}
int k=0;
while(k<3) {
System.out.print(stk.pop());
k++;
}
}
}
(1)堆栈的操作规则如何？(2分) (2)写出程序运行后的结果。(3分)
【答案】 (1) 先进后出 (2) 丁 丙 乙
五、根据题目要求编写程序（本大题2小题，第1小题5分，第2小题10分，共15分）
传送门——https://blog.csdn.net/qq_43055855/article/details/116096039，解析
1.请定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串变量face和suit：分别描述一张牌的牌面值（如：A、K、Q、J、10、9、…、3、2等）和花色（如：“黑桃”、“红桃”、“梅花”和“方块”）。
定义Card类中的public访问权限的构造方法，为类中的变量赋值；定义protected访问权限的方法getFace()，得到扑克牌的牌面值; 定义protected访问权限的方法getSuit()，得到扑克牌的花色; 定义方法toString()，返回表示扑克牌的花色和牌面值字符串（如“红桃A”、“梅花10”等）。
【答案】1．5分
class Card {
private String face;
private String suit;
public Card( String f, String s ) {
face = f;
suit = s;
}
protected String getSuit(){
return suit;
}
protected String getFace(){
return face;
}
public String toString(){
return face + " of " + suit;
}
}
2.若应用程序的main方法中，定义字符串数组f和s: 分别表示扑克牌的牌面值和花色；定义52个元素的Card类型数组deck，用来存放4个花色的52张牌。如下所示。
String f[] = { "A", "2", "3",
"4", "5", "6", "7", "8",
"9", "10", "J", "Q", "K" };
String s[] =
{ "黑桃", "红桃", "梅花", "方块" };
Card [] deck = new Card[ 52 ];
（1）使用Card类的构造方法给deck数组的52张牌赋值，要求数组中先存放黑桃花色的A、2、3、…、K；然后是红桃花色的A、2、3、…、K；梅花花色的A、2、3、…、K；方块花色的A、2、3、…、K。请写出实现上述功能的程序段。
【答案】 （1）5分
for ( int i = 0; i < deck.length; i++ ) {
deck[ i ] = new Card( faces[ i % 13 ], suits[ i / 13 ] );
}
（2）请编写模拟洗牌的程序段，即把数组deck中的扑克牌随机打乱存放顺序。
【答案】（2）5分
for ( int first= 0; first< deck.length; first++ ) {
int second = ( int ) ( Math.random() * 52 );
Card temp = deck[ first];
deck[ first] = deck[ second ];
deck[ second ] = temp;
总结
其实做完这些题，可以发现，无非就是变量的定义语句的循环，中间再加上条件的判断，有排序就必然想到交换位置、冒泡排序、希尔排序等等，如果遇到了递归无非就是自己调自己，每次循环再次计算。又想过来，遇到一个问题管他三七二十一，先把变量、循环、判断条件创建好再说，直接使用基础知识去思考一道题目可能出现一看题就懵的现象会少很多。大一的时候老师讲过令自己至今有记忆犹新的话： 代码本身不是你的，敲的次数多了就成了你的了。 一段代码敲个10遍的话相信自己能够记得更加牢固，代码的路上才能走得更远，以博客的形式记录下自己的代码轨迹。告诫自己要成为更好的自己。遇到了许多的基础编程题目设计到算法的知识，学习基础额知识能够在今后有学习更有难度的知识点上打下牢固的基础，坚定步伐。
扫一扫
2692
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
