当前位置：文档库 › java笔试考题3

java笔试考题3

在线考试
1. 编译和运行以下代码的结果为：
public class Hello{
public static void main(String s){
System.out.println("Hello");
}
}

A. 编译错误

B. 运行输出 "Hello"

C. 编译无错，但运行时指示没有定义构造方法

D. 编译无错，但运行时指示没有正确定义main方法

正确答案:D

问题解析:本题考查Java应用入口方法main的正确写法。Java应用程序中main方法
的正确写法如下：
public static void main(String[] s){}
本题中main方法的参数写成了String类型，而正确的方法参数写法为String[]
数组类型。
本题中main方法的定义，为类中普通的静态方法，不是入口方法，编译不会出
现错误，但运行时该类中没有正确的入口方法，会提示没有正确定义main方法。

2. main()方法的返回类型是：

A. int

B. void

C. boolean

D. String

正确答案:B

问题解析:本题考查Java应用入口方法main的正确写法。Java应用程序中main方法
的正确写法如下：
public static void main(String[] s){}
返回值类型为void。

3.下列代码出错的行是:
1) public void modify() {
2) int i, j, k;
3) i = 100;
4) while ( i > 0 ) {
5) j = Ii* 2;
6) System.out.println (" The value of j is " + j );
7) k = k + 1;
8) i--;
9) }
10) }

A.4

B.6

C.7

D.8

正确答案:C

问题解析:本题考查变量的初始化。
Java变量在使用前必须初始化，并赋以确定的初值。
本题中k变量没有初始化就被使用了，因此第7行出现编译错误。

4.下列程序编译或运行的结果是：
public static void main(String[] args) {
for(int i=0;i<=100;i++) {
int num = 100;
}
for(int j=0;j<=100;j++) {
int num = 200;
}
int num = 300;
System.out.println(num);
}

A.输出：100

B.输出：200

C.输出：300

D.编译出错

正确答案:C

问题解析:本题考查变量的作用域。
Java变量有其存在范围，程序运行超出这个范围后，这个变量所占用的空间将
被收回，另外，同名变量，作用域不能重叠。
本题中代码int num = 100;中的num变量的作用域是第一个for循环，代码
int num = 200;中的num变量的作用域是第二个for循环，代码int num = 300;中
的num变量是从该句开始向下，main方法中的所有区域，故三个变量的作用域没有
重叠，正确编译，运行后输出300。

***5.下列程序编译或运行的结果是：
public static void main(String[] args) {

for(int i=0;i<=100;i++) {
int num = 10;
}

System.out.println(num);
}

A.输出：10

B.输出：100

C.输出：201

D.编译出错

正确答案:D

问题解析:本题考查变量的作用域。
Java变量有其存在范围，程序运行超出这个范围后，这个变量所占用的空间将

被收回，另外，同名变量，作用域不能重叠。
本题中代码 int num = 100;中的num变量的作用域是整个main方法。代码
int num = 10;中的num变量的作用域是main方法下的for循环，因此，出现作用域
重叠的现象。

6.下列声明和赋值语句错误的是:

A.double w=3.1415;

B.float z=6.74567;

C.boolean truth=true;

D. int i=128;

正确答案:B

问题解析:本题考查各种数据类型的赋值。
A选项，double存储浮点数，默认的浮点数字面量类型是double类型。代码
double w=3.1415;是正确的。
B选项，float存储浮点数，精度低于double，给float类型变量赋值后加“f”或
是“F”。代码float z=6.74567;的写法不正确，正确写法为：float z=6.74567f;
C选项，boolean存储逻辑变量，取值只能为true或是false，代码
boolean truth=true;是正确的。
D选项，int（32位）存储整数，最大表示范围为：-2的31次幂到2的31次幂减
1，即 -2147483648 ~2147483647。代码int i=128;是正确的。

7.下列不属于基本数据类型的是：

A.整数类型

B.类

C.符点数类型

D.布尔类型

正确答案:B

问题解析:本题考查基本数据类型。
8种基本数据类型分别是：整数类型（byte，short，int，long），浮点类型
（float，double），字符类型（char），布尔类型（boolean）。
类，接口，数组都属于引用类型。

8.下列不属于整型变量的类型是:

A.byte

B.short

C.float

D.long

正确答案:C

问题解析:本题考查哪些是整数类型。
8种基本数据类型分别是：整数类型（byte，short，int，long），浮点类型
（float，double），字符类型（char），布尔类型（boolean）。

9.下列代码的输出结果是：
public static void main(String[] args) {
double money = 3.0;
money -= 2.9;
System.out.println(money);
}

A.0.1

B.0.099

C.0

D.0.10000000000000009

正确答案:D

问题解析:本题考查浮点类型的舍入误差。
由于舍入误差的原因，浮点数不能精确运算。请看下列代码：
double money = 3.0;
System.out.println(money - 2.9);//0.10000000000000009
注意舍入误差的问题，如果需要精确计算，可以使用BigDecimal。

10.下列表达式错误的是:

A.double d=3.4;

B.double d=3.4d;

C.float f=1.2f;

D.float f=1.2;

正确答案:D

问题解析:本题考查浮点类型的赋值。
double存储浮点数，默认的浮点数字面量是double类型，可以在赋值时后加“d”
或是“D”但是也可以不加，例如：double d=3.4;和double d=3.4f;。
float存储浮点数，精度低于double，给float类型变量赋值时必须在其后加“f”
或是“F”，例如：float f=1.2f;。

11.浮点数的字面量的类型是：

A.int

B.float

C.double

D.long

正

确答案:C

问题解析:本题考查浮点型的字面量。
double存储浮点数，默认的浮点数字面量是double类型。

***12.char类型的整数范围是:

A.0 ... 32767

B.0 ... 65535

C. –256 ... 255

D. –32768 ... 32767

正确答案:B

问题解析:本题考查字符型的范围。
字符类型事实上是一个16位无符号整数，范围是0 ... 65535。

13.Java字符类型采用的编码是：

A.Unicode字符集

B.GB2312字符集

C.GBK字符集

D.ASCII字符集

正确答案:A

问题解析:本题考查Java字符类型采用的编码。
Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所
有的字符都是16位。

14.关于下列程序片断，说法正确的是:
1)public class Test
2)｛
3)public static void main（String args[]）
4)｛
5) byte b＝100；
6) int i＝b；
7) int a＝2000；
8) b＝a；
9) System.out.println(b);
}
}

A.b 的值为100

B.b 的值为2000

C.第6行出错

D.第8行出错

正确答案:D

问题解析:本题考查强制类型转换。
小类型到大类型的顺序为：
byte-char（short）-int-long-float-double。
自动类型转换（隐式类型转换）：从小类型到大类型可以自动完成。
强制类型转换：从大类型到小类型需要强制转换符，会造成精度损失或者溢出。
本题中b＝a；b变量是byte类型，a变量是int类型，从大类型到小类型需要做
强制类型转换，故此处会出现编译错误。

15.char,int，long，float，double的范围由低到高的顺序是:

A.int-char-long-float-double

B.long-float-int-double-char

C.int-long-float-double-char

D.char-int-long-float-double

正确答案:D

问题解析:本题考查强制类型转换。
小类型到大类型的顺序为：
byte-char（short）-int-long-float-double。

16.在Java中语句：37/10的运算结果为:

A.3

B.3.70

C.3.7

D.3.0

正确答案:A

问题解析:本题考查Java中的整数除法。
在Java中整数除法会取整数，37/10的运算结果为3.

***17. 以下程序的输出结果为：
public static void main(String args[]) {
int x=1,y=1,z=1;
if (x--==1&&y++==1||z++==1)
System.out.println("x="+x+",y="+y+",z="+z);
}

A.x=0,y=1,z=1

B.x=0,y=2,z=2

C.x=0,y=2,z=1

D.x=1,y=2,z=1

正确答案:C

问题解析:本题考查&&，||以及++，--的用法。
首先“&&”、“||” 具备“短路”的特性：如果通过第一个表达式的值即可得出最后
的结果，则不计算第二个表达式。
其次，++(--)在后时，为先用后加（减）。
最后，++(--)在前时，为先加（减）后用。
本题中首先计算x--==1的值，返回true，x在自身的基础上减1，变成0，接着计
算y++==1的值，返回true，y在自身的基础加1，变成2，

接着计算x--==1&&y++==1
的值，返回true，由于该表达式返回true，||具备“短路”的特性，第一个表达式为
true，不去计算第二个表达式的值，也就是不去计算z++==1的值，故z的值还是1。

18.下列代码的运行结果是：
public static void main(String[] args) {
int a = 7;
System.out.println(a % 3);
}

A.2.0

B.2

C.1.0

D. 1

正确答案:D

问题解析:本题考查取余数运算。
7%3的余数为1。

19.下面代码的输出结果是
public class Main {
public static void main(String[] args) {
int n1 = 1;
int n2 = 2;
n1 = n1 + n2;
n2 = n1 - n2;
n1 = n1 - n2;
System.out.println(n1 + "," + n2);
}
}

A.1,2

B.2,1

C.1,3

D.3,2

正确答案:B

问题解析:本题考查两个数的交换。请看如下代码：
int n1 = 1;
int n2 = 2;
n1 = n1 + n2;
n2 = n1 - n2;
n1 = n1 - n2;
以上代码实现了n1的值和n2的值的交换。

20.下列代码段编译和运行的结果是：
public static void main(String[] args) {
String str = "null";
if (str == null) {
System.out.println("null");
} else if(str.length() == 0) {
System.out.println("zero");
} else {
System.out.println("some");
}
}

A.null

B.zero

C.some

D.编译错误

正确答案:C

问题解析:本题是对null值的考查。
引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向
任何对象。
本题中“null”表示的是字符串，并赋值给了变量str，而null表示空值，二者
用==比较的结果为false，另外，字符串str的长度就是字符串“null”的长度为4，
所以最终会执行else分支，输出some。

***21.下列代码段的输出结果是：
public static void main(String[] args) {
int x = 5;
boolean b1 = true;
boolean b2 = false;
if ((x == 4) && !b2)
System.out.print("1 ");
System.out.print("2 ");
if ((b2 = true) && b1)
System.out.print("3");
}

A.2

B.3

C.1 2

D.2 3

正确答案:D

问题解析: 本题考查if语句。if语句的形式如下：
if（关系表达式） {
// 语句块
}
以上if语句形式表示：当关系表达式为true时，执行语句块，否则不执行。另
外还有以下if语句的形式:
if（关系表达式）
// 语句
以上if语句的形式表示：当关系表达式为true时，执行if语句下的一条语
句，否则不执行。
本题中，第一个if语句属于上诉所说的第二种形式。首先计算第一个if分支中
x==4的值，该表达式返回false，由于“&&”具有短路功能，第一个表达式为false，
不会计算第二个表达式的值，即可以计算出表达式(x == 4) && !b2的值为false，
因此第一个if分支中

的语句不会被执行，需要注意的是代
码 System.out.print("2 ");行，不属于第一个if分支中的语句，会执行，并输
出“2”。
第二个if分支也属于上述所说的第二种形式，计算第二个if分支中表达式
(b2 = true) && b1的值，该表达式的值为true，因此执行第二if分支，并输出"3"。

***22.下列代码段编译和运行的结果是：
public static void main(String[] args) {
int value = 0;
boolean setting = true;
String title = "Hello";
if (value || (setting && title == "Hello")) {
System.out.println("one");;
}
if (value == 1 & title.equals("Hello")) {
System.out.println("two");
}
}

A.2

B.1

C.编译错误

D.可以运行，但无输出

正确答案:C

问题解析:本题考查if语句。if语句的形式如下：
if（关系表达式） {
// 语句块
}
以上if语句形式表示：当关系表达式为true时，执行语句块，否则不执行。另
外还有以下if语句的形式:
if（关系表达式）
// 语句
以上if语句的形式表示：当关系表达式为true时，执行
本题中第一个if语句if (value || (setting && title == "Hello"))的条件部
分，不是关系表达式，故会出现编译错误，

23.请看下列代码：
public void testIfA() {
if (testIfB(1)) {
System.out.println("True");
} else {
System.out.println("Not true");
}
}
public boolean testIfB(int type) {
if(type==1){
return true;
}
return false;
}
}
调用testIfA方法，程序的结果是：

A.输出Not true

B.输出True

C.代码 if (testIfB("True")) { 行，编译错误

D.代码 return Boolean.valueOf(str); 行，编译错误

正确答案:B

问题解析: 本题考查if-else语句。if-else语句的形式如下：
if（关系表达式） {
// 语句块 1
} else {
// 语句块 2
}
以上if-else语句的形式表示：当关系表达式为true时，执行语句块1，否则执
行语句块2。
本题中，首先在testIfA方法的if语句中调用testIfB(1)方法，testIfB方法的
返回值为true，该返回值作为testIfA中if语句的条件部分，即是true，因此执行
if语句，并输出True。

***24.下列代码段编译运行的结果是：
public static void main(String[] args) {
String str = ;null；
if (str == null) {
System.out.println("null");
} else if(str.length() == 0) {
System.out.println("zero");
} else {
System.out.println("some");
}
}

A.输出null

B.输出zero

C.输出some

D.编译错误

正确答案:D

问题解析: 本题考查if-else语句。if-else语句的形式如下：
if（关系表达式） {
// 语句块 1
} else {
// 语句块 2
}
以上if-else语句的形式表示：当关系表达式

为true时，执行语句块1，否则执
行语句块2。
本题中多了一个else分支，会出现编译错误。

25.下列语句序列执行后，k 的值是：
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

正确答案:C

问题解析:本题考查switch-case语句。switch-case语句的形式如下：
switch (整型表达式) {
case 整数值1:
语句1
case 整数值2:
语句2
… … …
default :
语句0
}
以上switch-case语句形式表示：判断每一个case表示式的数值是否与整型表
达式相等，如果相等执行case块内语句，然后继续向下执行各个case块内的语句和
defaul块的语句。
本题中，首先计算j-i的值，计算结果为8，该计算结果和case 8：语句块的
整数表达式值相等，执行其块内语句k++，此时k在自身的基础上加1，k的值变成
31；接着向下执行case 9:块中的语句，k的值变成33；接着向下执行case 10:块中
的语句，k的值变成36；接着向下执行default 块中的语句，k的值变成2；

26. 以下由 for 语句构成的循环执行的次数是:
for ( int i = 0; true ; i++) {
System.out.println(i);
}

A.执行3次

B.无限次

C.执行1次

D.一次也不执行

正确答案:B

问题解析:本题考查for循环语句。
for 循环重复执行一个语句或语句块，直到指定的表达式计算为 false 值。
for循环语句的形式如下：
for(表达式1；表达式2；表达式3) {
语句块
}
上述语句执行时，首先计算表达式1，接着执行表达式2，若表达式2的值等于
true，则执行大括号中的语句块，接着计算表达式3，然后再判断表达式2的值。依
次重复下去，直到表达式2的值等于false。
本题中for循环语句的表达式2的值为true，因此循环会一直进行下去，即循
环无限次。

***27.观察以下程序段 :
int i=1,j=10;
do{
if(i++>--j) continue;
} while(i<5);
执行完后， i 、 j 的值分别为：

A.i=6 j=5

B. i=5 j=5

C. i=6 j=4

D.i=5 j=6

正确答案:D

问题解析:本题考查do…while循环的用法。
do {
语句块
} while(boolean表达式);
先执行一次语句块，然后当boolean表达式为true时，执行语句块；否则退出循
环。另外，在循环中，continue 语句用于结束本次循环而开始下一次循环。
程序的执行过程如下：
第一次循环：i=2 j= 9
第二次循环：i=3 j= 8
第三次循环：i=4 j= 7
第四次循环：i=5 j= 6
此时i=5退出循环。

28.下列代码段编译和运行的结果是：
public static void main(String[] args) {
int i=0;
for (; i <= 10; i++) {

if (i > 6)
break;
}
System.out.println(i);
}

A.输出6

B.输出7

C.输出10

D.编译错误

正确答案:B

问题解析:本题考查break语句的用法。
break 语句用于终止最近的封闭循环或它所在的 switch 语句。
本题中当i=7时，执行if块内的语句，退出循环。

***29.请看下列代码：
public void go() {
String str = "";
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 2; y++) {
if (x == 1)
break;
if (x == 2 && y == 1)
break;
str = str + x + y;
}
}
System.out.println(str);
}

000120

调用go方法，程序的输出结果是：

A.00

B.0001

C.000120

D.00012021

正确答案:C

问题解析:本题考查break语句的用法。
break 语句用于终止最近的封闭循环或它所在的 switch 语句。
本题中：
当x=0,y=0时,str=00
当x=0,y=1时,str=0001
当x=2,y=0时,str=000120

30.下面程序的输出结果是：
public static void main(String[] args) {
int d = 325;
int sum = 0;
while (d > 0) {
int n = d % 10;
sum += n;
d /= 10;
}
System.out.println(sum);
}

A.10

B.12

C.5

D.32

正确答案:A

问题解析:本题考查while循环语句。while循环语句的形式如下所示：
while（boolean表达式） {
语句块
}
上述while语句的形式表示当boolean表达式为true时，执行语句块；否则退
出循环。
本题需要注意的是：在Java中整数除法的结果取整数。本题循环的过程中
n,d,sum的变化情况如下：：
第一次循环后：n=5,d=32,sum=5
第二次循环后：n=2,d=3,sum=7
第三次循环后：n=3,d=0,sum=10

31.下列代码段的输出结果是：
public static void main(String[] args) {
int x = 12;
while (x < 10) {
x--;
}
System.out.print(x);
}

A.0

B.10

C.12

D.2

正确答案:C

问题解析:本题考查while循环语句。while循环语句的形式如下所示：
while（boolean表达式） {
语句块
}
当boolean表达式为true时，执行语句块；否则退出循环。
本题中第一次判断循环执行的条件表达式x<10，该表达式返回false，不会执行
while语句块内的语句，故x值无变化。

32.关于while和do－while循环，下列说法正确的是：

A.两种循环除了格式不同外，功能完全相同

B.与do－while语句不同的是，while语句的循环至少执行一次

C.do-while语句首先计算终止条件，当条件满足时，才去执行循环体中的语句

D.与while语句不同的是，do-while语句的循环至少执行一次

正确答案:D

问题解析:本题考查的do...while循环和while循环的区别。
do-while与while结构的区别在于：如果循环条件一开始就不满足时while结构
不会执行循环体；而

do-while结构会执行一次循环体。

33.下列代码段的输出结果是：
public static void main(String[] args) {
int x = 0;
int y = 10;
do {
y--;
++x;
} while (x < 5);
System.out.print(x + "," + y);
}

A.5，6

B.5，5

C.6，5

D.6，6

正确答案:B

问题解析: 本题考查do-while循环语句的用法。do-while语句的形式如下：
do {
语句块
} while(boolean表达式);
上述do-while形式表示先执行一次语句块，然后当boolean表达式为true时，
执行语句块；否则退出循环。
本题循环过程中x,y变化情况。
第一次执行循环体后：x=1,y=9
第二次执行循环体后：x=2,y=8
第三次执行循环体后：x=3,y=7
第四次执行循环体后：x=4,y=6
第五次执行循环体后：x=5,y=5

34.下列代码段中，循环执行的次数是：
int x = 10;
do {
x--;
} while (x <=5);

A.10次

B.0次

C.1次

D.超过10次

正确答案:C

问题解析: 本题考查do-while循环语句的用法。do-while语句的形式如下：
do {
语句块
} while(boolean表达式);
上述do-while形式表示先执行一次语句块，然后当boolean表达式为true时，
执行语句块；否则退出循环。
本题中，虽然第一次计算boolean表示时，它的值就是false，但是，由于do-
while语句先执行一次循环体，所以循环的次数是1次。

35.执行完以下代码int [ ] x = new int[25]；后，下列各项正确的是：

A.x[24]为0

B.x[24]未定义

C.x[25]为0

D.x[0]为空

正确答案:A

问题解析: 本题考查Java中数组的初始化。int 数组类型初始化后，数组中的元素
会被自动赋初始值为０值。
本题中选项A正确。
选项B：x[24]的值为0。
选项C：Java 数组的索引从0开始，所以能获取的最大元素索引是数组的长度减
1，因此x[25]超出的x数组的索引范围。
选项D：x[0]的值为0。

36.下列数组定义及赋值，正确的是：

A.int[] ia = new int [15];

B.float fa = new float [20];

C.int ia [][] = (4, 5, 6) (1, 2, 3);

D.float[20] arr= new float[];

正确答案:A

问题解析:本题考查Java中数组的定义及赋值。
选项A正确。
选项B：定义一个数组，在类型名后跟随一对空方括号即可：int[] ia;也可以
将方括号置于标识符后面：int ia[];
选项C：多维数组及数组中的元素，要写在大括号中int ia []
[] = {{ 4, 5, 6, },{ 1, 2, 3, }};
选项D：指定数组的长度，要在数组实例化时指定，例如：
float[] arr= new float[20];

37.下面关于Java语言中方法的说法错误的是:（）。

A.在调用方法时，必须保证传递参数的类型和个数符合方法的声明

B.方法在声明时必须指定返回值的类型，如果方

法没有返回值，需将返回值类型声
明为void。

C.方法的三个要素是方法名、参数列表和返回值

D.如果方法定义为返回void，则方法中不能出现return语句

正确答案:D

问题解析: 本题考查方法的要素。方法的三个要素是方法名、参数列表和返回
值。在使用方法时，请注意以下几点：
a.方法在声明时必须指定返回值的类型,如果方法没有返回值（即方法不需要
返回数据），需将返回值类型声明为void。
b.return语句的作用在于结束方法和返回数据。如果方法定义为返回void，
那么在方法中可以出现return ；表示方法执行结束。
c.在调用方法时，必须保证传递参数的类型和个数符合方法的声明

***38.下列代码编译和运行的结果是：
public static void main(String[] args) {
String[] names = { "Oscar", "Edgar", "Frank", "Laurent",
"Hugo","Jacob", "Aaron", "Gino", "Angus", "Ken" };
String[] names1 = new String[5];
System.arraycopy(names, 3, names1, 1, 5);
System.out.println(Arrays.toString(names1));
}

A.编译错误

B.抛出运行时异常

C.输出：[Laurent, Hugo, Jacob, Aaron, Gino]

D.输出：[Frank, Laurent, Hugo, Jacob, Aaron]

正确答案:B

问题解析:本题考察的是数组的复制。
arraycopy方法是从指定源数组中复制一个数组，复制从指定的位置开始，到
目标数组的指定位置结束。

***39.以下是插入排序的部分代码，请把<填入代码>处补充完整
public static int[] insertSort(int[] ary) {
for (int i = 1; i < ary.length; i++) {
<填入代码>
}
return ary;
}

A.int temp = ary[i+1];
int j;
for (j = i - 1; j >= 0 ; j--) {
if(tempary[j + 1] = ary[j];
}else{
break;
}
}
ary[j + 1] = temp;

B. int temp = ary[i];
int j;
for (j = i - 1; j >= 0 ; j--) {
if(tempary[j + 1] = ary[j];
}else{
break;
}
}
ary[j + 1] = temp;

C. int temp = ary[i];
int j;
for (j = i ; j >= 0 ; j--) {
if(tempary[j + 1] = ary[j];
}else{
break;
}
}
ary[j + 1] = temp;

D.int temp = ary[i-1];
int j;
for (j = i - 1; j >= 0 ; j--) {
if(tempary[j + 1] = ary[j];
}else{
break;
}
}
ary[j + 1] = temp;

正确答案:B

问题解析:本题考查对插入排序原理的理解和代码的实现。
本题考查对插入排序原理的理解和代码的实现。插入排序原理如下：
假定这个数组的顺序是排好的，然后从头往后，如果有数比当前外层元素的
值大，则将这个数的位置往后挪，直到当前外层元素的值大于或等于它前面的位置
为止。具体算法描述如下：
⒈ 从第一个元素开始，该元素可以认为已经被排

序
⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描
⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置
⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
⒌ 将新元素插入到下一位置中
⒍ 重复步骤2

***40.序列[78,45,98,46,23,55,12]进行插入排序时，第三趟排序的结果是：

A.[45, 78, 98, 46, 23, 55, 12]

B.[23, 45, 46, 55, 78, 98, 12]

C.[23, 45, 46, 78, 98, 55, 12]

D.[45, 46, 78, 98, 23, 55, 12]

正确答案:D

问题解析:本题考查对插入排序原理的理解和代码的实现。
本题考查对插入排序原理的理解和代码的实现。插入排序原理如下：
假定这个数组的顺序是排好的，然后从头往后，如果有数比当前外层元素的
值大，则将这个数的位置往后挪，直到当前外层元素的值大于或等于它前面的位置
为止。具体算法描述如下：
⒈ 从第一个元素开始，该元素可以认为已经被排序
⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描
⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置
⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
⒌ 将新元素插入到下一位置中
⒍ 重复步骤2

***41.下面的代码使用二分法在有序的int类型数组arry查找元素key，如果找到,输出
元素在数组中的下标，否则输出-1，<填入代码>处应该填入的代码是：
public static void main(String[] args) {
int key = 16;
int[] arry = { 1, 3, 5, 7, 8, 10, 12, 15, 16 };
int low = 0;
int high = arry.length - 1;
while (low <= high) {
<填入代码>
else {
System.out.println(mid);
return;
}
}
System.out.println(-1);
}

A. int mid = (low + high) >>> 1;
if (arry[mid] > key)
low = mid + 1;
else if (arry[mid] < key)
high = mid - 1;

B.int mid = (low + high) >>> 1;
if (arry[mid] < key)
low = mid;
else if (arry[mid] > key)
high = mid - 1;

C. int mid = (low + high) >>> 1;
if (arry[mid] < key)
low = mid + 1;
else if (arry[mid] > key)
high = mid;

D. int mid = (low + high) >>> 1;
if (arry[mid] < key)
low = mid + 1;
else if (arry[mid] > key)
high = mid - 1;

正确答案:D

问题解析:本题考查二分法查找算法原理和代码实现。
二分法查找，必须对已经排好序的序列进行查找，假设现在有一个递增序列，
取中间位置的数及序号，然后将一个序列折成两半进行查找。如果目标元素和中间
位置相等，则找打，如果如果大于中间元素，则在后一个区间查找，否则在前一个
区间查找。如此反复，直到找到目标元素

***4

2.使用递归算法求10的阶乘，下列选项正确的是：

A. public static int method(int n) {
if (n < 1) {
return 0;
}
if (n == 1)
return 1;
else
return n * method(n - 1);
}

B. public static int method(int n) {
if (n < 1) {
return 0;
}
if (n == 1)
return 1;
else
return n * (n - 1);
}

C.public static int method(int n) {
if (n < 1) {
return 0;
}
if (n> 1)
return 1;
else
return n * method(n - 1);
}

D.public static int method(int n) {
if (n < 1) {
return 0;
}
if (n > 1)
return 1;
else
return n * (n - 1);
}

正确答案:A

问题解析: 本题考查对递归调用的理解和运用。
首先找出求阶乘的规律：每个数字的阶乘都等于其本身乘以前一个数的阶
乘，即：
F（n）＝ n * F（n-1）
然后找出递归结束的条件：1的阶乘为1，比1小的整数则不用计算阶乘。因
此，可以定义方法来使用递归算法计算阶乘问题。
使用递归计算阶乘的代码如下：
public static int method(int n) {
if (n < 1) {
return 0;
}
if (n == 1)
return 1;
else
return n * method(n - 1);
}

***43.台阶问题。一个楼梯有50个台阶，每一步可以走一个台阶，也可以走两个台
阶。使用递归算法，计算共有多少种不同的走法，下列选项正确的是：（）

A. public static int t(int n) {
if (n < 1) {
return -1;
} else if (n == 1)
return 1;
else if (n > 2)
return 2;
else
return t(n - 1) * t(n - 2);
}

B. public static int t(int n) {
if (n < 1) {
return -1;
} else if (n == 1)
return 1;
else if (n > 2)
return 2;
else
return t(n - 1) + t(n - 2);
}

C. public static int t(int n) {
if (n < 1) {
return -1;
} else if (n == 1)
return 1;
else if (n == 2)
return 2;
else
return t(n - 1) * t(n - 2);
}

D. public static int t(int n) {
if (n < 1) {
return -1;
} else if (n == 1)
return 1;
else if (n == 2)
return 2;
else
return t(n - 1) + t(n - 2);
}

正确答案:D

问题解析:本题考查对递归调用的理解和运用。
本题中，假设走完k个台阶有f(k)种走法。
k = 1时，f(k) = 1
k = 2时，f(k) = 2
k = n时，第一步走一个台阶，剩n-1个台阶，有f(n - 1)种走法。第一
步走两个台阶，剩n-2个台阶，有f(n - 2)种走法。所以共有f(n - 1) + f(n - 2)
种走法。于是有如下公式：
f(1)=1
f(2)=2
f(n)=f(n-1)+f(n+1)
递归算法实现的代码如下：
public static int t(int n) {
if (n < 1) {
return -1;
} else if (n == 1)
return 1;
else if (n == 2)
return 2;
else
return t(n - 1) + t(n - 2);

}

***44.下列代码的输出结果是：
int a=10;
System.out.println(a<<2);

A.2

B.4

C.40

D.42

正确答案:C

问题解析:本题考查左移位。
按二进制形式把所有的数字向左移动对应的位数，高位移出(舍弃)，低位的空
位补零。
整数10的二进制为（前边24位0没有写出来）：
00001010向左移2为，变成00101000，在转换成10进制数为：0+0+0+8+0+32=40

***45.00101010&00010111按位与的结果为：

A.00000010

B.11111111

C.00111111

D.11000000

正确答案:A

问题解析:本题考查按位与。
按位逻辑运算（& 按位与、| 按位或、^ 按位异或、~ 按位非），对整数类型（包
括char）按照二进制位逐位进行逻辑运算。
操作数1 操作数2 & | ^
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0

题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....
1 1 2

fn = f(n-1) +f(n-2)

2014/8/13
*/

package https://www.wendangku.net/doc/f812871356.html,.flywater.FiftyAlgorthm;
public class FirstRabbit {
public static final int MONTH = 15;
public static void main(String[] args) {
long f1 = 1L, f2 = 1L;
long f;
for(int i=3; if = f2;
f2 = f1 + f2;
f1 = f;
System.out.print("第" + i +"个月的兔子对数: ");
System.out.println(" " + f2);
}
}

}
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
1.程序分析：(a>b)?a:b这是条件运算符的基本例子。 */
package https://www.wendangku.net/doc/f812871356.html,.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class FifthCondition {
//public static final int S1 = 90;
//public static final int S2 = 60;
static int grade;
public static void main(String[] args) {
Scanner str = new Scanner(System.in);
int s = str.nextInt();
FifthCondition fc = new FifthCondition();
grade = https://www.wendangku.net/doc/f812871356.html,pare(s);
if(grade == 1) {
System.out.print('A');
} else if(grade == 2) {
System.out.print('B');
} else {
System.out.println('C');
}
}
public int compare(int s) {
return s > 90 ? 1
: s > 60 ? 2
:3;
}
}

题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
1.程序分析：利用辗除法。 */
/*
* 在循环中，只要除数不等于0，用较大数除以较小的数，将小的一个数作为下一轮循环的大数，取得的余数作为下一轮循环的较小的数，如此循环直到较小的数的值为0，返回
* 较大的数，此数即为最小公约数，最小公倍数为

两数之积除以最小公倍数。
* */
package https://www.wendangku.net/doc/f812871356.html,.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class SixthCommonDiviser {
public static void main(String[] args) {
int a, b;
Scanner s1 = new Scanner(System.in);
Scanner s2 = new Scanner(System.in);
a = s1.nextInt();
b = s2.nextInt();
SixthCommonDiviser scd = new SixthCommonDiviser();
int m = scd.division(a, b);
int n = a * b / m;
System.out.println("最大公约数: " + m);
System.out.println("最小公倍数: " + n);
}
public int division(int x, int y) {
int t;
if(x < y) {
t = x;
x = y;
y = t;
}

while(y != 0) {
if(x == y) return 1;
else {
int k = x % y;
x = y;
y = k;
}
}
return x;
}
}
题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
*/
/*
* 这个程序写得很不好，是知道结果后拼凑起来的，还不如直接写输出语句加上结果来的好。
*/
package https://www.wendangku.net/doc/f812871356.html,.flywater.FiftyAlgorthm;
public class EighteenthPingpong {
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[i] + " vs " + n[j]);
}
}
}
}

1-5 DBCCD
6-10 BBCDD

11-15 CBADD
16-20 ACDBC

21-25 DCBDC
26-30 BDBCA

31-35 CDBCA
36-40 ADBBD

41-45 DADCA