《Java程序设计习题精析与实验指导》一3.2　习题解析

3.2　习题解析

一、选择题

1. 以下选项中，合法的赋值语句是______。
   A. ++m!=n--; B. ++ m; C. m=m + 1= 5; D. m = = 1;

答案：B
解析：在上述四个选项中，选项A和D为逻辑表达式而非赋值语句；选项C中的m+1=5的表示是错误的；选项B中实现的功能等同于m=m+1。

1. 下列语句序列执行后，ch1变量中的值为______。
2. ch1='A', ch2='B';

if (ch1 + 2 < ch2) ++ch1 ;
A. 'A' B. 'B' C. A D. B
答案：A
解析：Java的字符比较运算遵循原则：首先将字符转换为Unicode代码（Unicode代码最前面的128个字符与ASCII代码相同），然后再比较其大小。当前ch1为'A'，其Unicode代码值为65，ch2为'B'，其Unicode代码值为66，65+2大于66，故表达式(ch1 + 2 < ch2)的值为false，根据单分支结构语句的运行规则，此时并不进行++ch1的运算，因此ch1的值仍旧为'A'，而字符常量的表示规则为该字符两端必须加上单引号，故答案A正确。

1. 下列语句序列执行后，c变量的值为______。
2. a=2, b=4, c=5;

if (a<--b) c*=a;
A. 5 B. 20 C. 15 D. 10
答案：D
解析：在表达式（a<--b）中先进行--b的运算，由于b的值为4，经运算后b的值为3，故表达式的值为真，因而将进行c=a的运算，其运算的结果等同于c=ca，在a=2，c=5的前提下，显然经运算后c的值为10，故选项D是正确的。

1. 下列语句序列执行后，c 的值是______。
2. a=6, b=3, c=5;

if (a==b) c+=a; else c=++a*c;
A. 15 B. 25 C. 35 D. 45
答案：C
解析：根据双分支结构语句的运行规则，当关系表达式(a==b)的值非真时，执行else后面的语句“c=++a*c;”，由于此时a为6，++a后a的值为7，而c为5，故相乘后值为35，选项C是正确的。

1. 下列语句序列执行后，c的值是______。
2. a=4,b=5,c=9,d=6;

if (a>b||cA. 6 B. 10 C. 8 D. 9
答案：B
解析：根据变量初始化后所赋的值，可知表达式(a>b| |c

1. 设a、b为int类型变量，c、d为float类型变量，ch为char类型变量，且所有变量均已赋值，则下列正确的switch语句是______。
   A. switch (a + b); {...} B. switch (ch + 1) {...}

C. switch ch {...} D. switch (c + d) {...}
答案：B
解析：根据switch语句的使用规则，switch后面的表达式不允许是float类型的数据，故答案D错；表达式必须用括号括起，故答案C错；表达式后面应紧跟复合语句，不允许出现分号，故答案A错；程序运行时，会自动将ch + 1转换为整型数据并完成运算，故选项B是正确的。

1. 下列语句序列执行后，c的值是______。
2. a=10, b=18, c=30;

switch (b-a) {

case  8 :  c++;     
case  9 :  c+=2;
case  10:  c+=3;    
default :c/=b;

}
A. 31 B. 32 C. 2 D. 33
答案：C
解析：根据switch语句的运行规则，当b–a的值为8时执行“case 8 :”行的语句，执行结果为c取值31，由于没有break语句，故程序将继续执行“case 9 :”行语句以及下面的所有语句，当执行到“case 10 :”行语句时，c取值36，故执行“default :”行语句时，36除以18得商为2，故选项C正确。

1. 下列语句序列执行后，a的值为______。
2. a=1;

for ( int i=5; i>0; i-=2 ) a*=i;
A. 0 B. 1 C. 15 D. 60
答案：C
解析：在当前的循环语句中，由于循环变量的增值步长为-2，故循环将被执行3次，分别是当i为5、3和1时；由于a的初值为1，故连续乘以5、3和1之后其值应为15，故选项C正确。

1. 下列语句序列执行后，c的值为______。
2. a=3, b=4, c=0;

while ((a++)<(-- b)) ++c;
A. 0 B. 1 C. 2 D. 3
答案：A
解析：在表达式(a++) < (--b)的运算过程中，变量a是与变量b先比较而后自加，而变量b则反之：先自减而后与变量a比较。数值代入后的表达式为：3<3，表达式显然非真，故本循环其实一次也没有执行，当然c还是维持原来的值：0，故选项A正确。

1. 下面关于数组定义语句不正确的是______。
   A. float f[]=new {2.4f,3.5f,5.7f,7.9f}; B. int a1[]={1,2,3,4,5};

C. double[] d=new double[10]; D. int[] a2;
答案：A
解析：对于Java一维数组的声明，可以有两种形式。标准的声明格式为：
type <数组名>[ ];//声明一维数组
数组名=new type [<元素个数>];//分配内存给数组
而
type <数组名>[ ]=new type [<元素个数>];
可以理解为上面两个语句的缩写形式。
第二种形式是在声明时直接赋值，格式为：
type <数组名>[ ]={<数值1>,<数值2>,…,<数值n>};
两种形式不可混淆使用，故选项A的定义方式是不正确的。

1. 设有定义语句int a[ ]={36,72,99}，则以下对此语句叙述错误的是______。
   A. 该语句定义了一个名为a的一维数组 B. a数组有3个元素

C. 数组中的每个元素是整型 D. a数组的元素的下标为1～3
答案：D
解析：Java的数组一旦声明，下标自动从0开始编号，所以a数组的元素的下标为0～2，选项D的叙述是错误的。

1. 在一个应用程序中定义了数组a：int[ ] a={1,2,3,4,5,6,7,8,9,10}，为了打印输出数组a的最后一个数组元素，下面正确的代码是______。
   A. System.out.println(a[10]); B. System.out.println(a[9]);

C. System.out.println(a[8]); D. System.out.println(a[a.length]);
答案：B
解析：由于当前数组a中有10个元素，而Java的数组下标自动从0开始编号，因此最后一个元素应为a[9]，a[10]在内存中是不存在的，而a.length中返回的是该数组的元素个数，其值为10，故选项B是正确的。

1. 执行下列语句
   int[] lx = {2,3,4,5};

lx[3] = lx[3] == --lx[0]?++lx[1]:lx[2]--;
后，数组lx的元素值分别为______。
A. 1,2,3,4 B. 1,3,3,3 C. 1,2,3,3 D. 1,3,3,4
答案：D
解析：当数组lx中的元素被分别赋值之后，对于表达式：lx[3] == ––lx[0]?++lx[1]:lx[2]––，由于此时lx[0]取值为2，lx[3]取值为5，因此显然lx[3] == ––lx[0]取值非真，根据多元运算符“？:”的运算规则：应将冒号后面的表达式的值（lx[2]––）赋值给lx[3]，由于此时lx[2]取值为4，系统先将该值赋予lx[3]，然后对lx[2]进行自减；由于整个过程中lx[1]并未被引用，因此也不会进行自增的操作。

1. 语句
   String s1 = new String("Hello");

String s2 = new String("Hello");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
执行后的输出结果是______。
A. Hello B. Hello C. Hello D. false

 false         true         Hello         true

答案：D
解析：String类型数据并非Java的基本数据类型，s1和s2是从java.lang中的字符串类中创建的实例对象，对于实例对象而言，“==”所比较的是两者的内存地址而非它们的具体内容，若要比较两者的具体内容是否相同，必须使用其所对应的方法“equals()”，“==”与“equals()”比较的结果均为逻辑值，故答案D正确。

1. 设有如下定义语句：
   String s1="My cat";

int m=s1.compareTo("My a cat");
语句被执行后m的值为______。
A. 2 B. 1 C. 0 D. –2
答案：A
解析：Java语言处理系统对于字符串的比较基于字符串中各个字符的Unicode值。将此 String变量表示的字符序列与参数字符串所表示的字符序列进行逐个比较。如果按字典顺序此String变量在参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String变量位于参数字符串之后，则比较结果为一个正整数。当前String变量s1按字典顺序显然在参数字符串"My a cat"之后，因此比较结果为正值，且c的Unicode代码比a的Unicode代码大2，故选项A正确。

1. 下列方法定义中，正确的是______。
   A. double me(int a, int b) { int r; r=a–b; }

B. double me(a, b ) { return b; }
C. int me(int a, int b) { return a–b; }
D. int me(int a, b) { return (a–b); }
答案：C
解析：对于有返回值的方法的定义，一般都使用return语句将计算值返回至主调程序，故答案A的定义不正确；方法的返回值类型必须与方法声明类型一致，答案B中的变量b没有声明其类型，故该定义也不正确；方法中若有参数，该方法声明时参数必须逐个明确声明，答案D中参数a虽然经过了声明，但参数b却没有声明，故该定义也不正确；显然只有答案C是符合要求的。

1. 下列方法定义中，不正确的是______。
   A. float x( int a,int b ) { return (a–b); }

B. int x( int a,int b) { return a–b; }
C. int x( int a,int b ) { return a*b; }
D. int x(int a,int b) { return 1.2*(a+b); }
答案：D
解析：根据上题所述理由：方法的返回值类型必须与方法声明类型一致，而1.2*(a+b)显然不是整型数值，故答案D的方法定义不正确。

1. 在Java程序中所提到的“递归”的基本概念，其基本思想是______。
   A. 让别人反复调用自己 B. 自己反复调用别人

C. 自己反复调用自己 D. 以上说法都不对
答案：C
解析：Java程序中的方法须经过调用方能得以运行（主方法除外），根据不同的具体需求，Java中的方法一可以调用方法二，方法二可以调用方法三（称为嵌套调用），方法一也可以调用方法一本身（称为递归调用），故答案C正确。
二、程序填空

1. 下面程序的功能是：由键盘输入一个小于“100”的数字字符串（例如“38”），将它转换成整数，然后计算并输出从该整数到100之间所有整数的累加和。请将程序补充完整。

import       (1)        ;
public class NumJa1{
   public static void main(String args[]) throws IOException{
      int num1,s;
      String str;
      BufferedReader buf;
      buf=new BufferedReader(new InputStreamReader(System.in));
      System.out.print("请输入整数:");
      str=        (2)         ;               
      num1=        (3)         ; 
      if (num1>=100)
        System.out.print("输入的数已超出范围");
      else {
                  (4)      ;
          for (       (5)        )
             s=s+i;              
          System.out.println("The sum is "+s);   
        }
    }
}

答案：
（1）java.io.*
（2）buf.readLine();
（3）Integer.parseInt(str);
（4）s=0
（5）int i=num1;i<=100;i++
解析：本程序中使用了键盘输入语句，处理该语句的工具BufferedReader类与InputStreamReader类都被封装于java.io包中，故在程序开始时，必须首先引入这个包以及这个包中所有的类。readLine()是BufferedReader类中封装的方法，用于接收用户从键盘输入的数据，该方法必须由对象加以调用。因此程序首先声明了buf对象，然后通过该对象调用其方法。因为此程序从键盘获得的数据是字符串，因而数据一旦被读入，应立即将其转换为整型数才能对变量num1赋值。当程序开始累加操作时，累加器（此处为变量s）清零是一个必需的过程。按照题目的要求，要设置从num1（键盘输入的数值）开始到100为止、每次循环变量增值为1的循环。

1. 下面Java应用程序接收用户输入的10个整数，将这10个数按从大到小的方式排序并输出，请将程序补充完整。

import java.io.* ;    
public class cxtc2{
  public static void main(String  args[ ])throws IOException{ 
       int arr[]=new     (1)      , i ;
       BufferedReader  br;
       br =new BufferedReader(new InputStreamReader(System.in));
            (2)     {
          arr[i] = Integer.parseInt(br.readLine() ); 
      } 
      for  (i = 0 ; i < 9 ; i ++)  
         for (    (3)     ;j<10;j++)
           if(arr[i]    (4)    arr[j]){
             int t=arr[i];arr[i]=arr[j];    (5)     ;
           }
       System.out.println("排序结果为："); 
       for  ( i = 0 ; i < 10 ; i ++ ) 
          System.out.print(arr[i]+"\t");  
  }
}

答案：
（1）int[10]
（2）for ( i = 0 ; i < 10 ; i ++ )
（3）int j=i+1
（4）<
（5）arr[j]=t
解析：声明数组的标准语法格式在new的后面应该是该数组的数据类型及其长度。一旦数组与变量声明完毕，后面就是逐个处理由用户从键盘输入的数据，既然是逐个处理，显然该处应使用循环语句，且其循环的次数应该与数组的长度相同、循环变量每次增值为1。由于排序要求为从大到小，故本程序采用的方法是：第一次（也就是第一轮循环），取定数组的第一个元素，把它与后面的元素逐个相比较，凡有比该数（即第一个元素）的数值大的，立刻将这两个元素的数值进行交换，此时值较大的元素换到了第一个元素的位置。交换结束后，将第一个元素再继续与刚才交换位置元素后面的元素进行逐个比较，凡有比该数的数值大的，再将这两个元素的数值进行交换，以此类推，当处理完了最后一个元素之后（即第一轮循环结束），第一个元素的数值自然变成了该数组中的最大值元素了；第二次，取定数组的第二个元素，进行与第一次同样的比较操作，当第二轮循环结束时，第二个元素的数值就是该数组中除了第一个元素之外最大的了。如此进行9次循环之后，数组的元素从大到小就依次排好了。抽象地考虑：当进行第i轮循环时，首先应该取定数组的第i个元素，为了与后面的元素比较，因此必须声明与i类型相同的变量（此处为j），作为循环变量进行操作，且该循环变量的初值显然应该是i+1。每一轮的循环中arr[i]是被取定的元素，arr[j]是与之相比较的元素，比较规则是一旦arr[i]< arr[j]，两元素的数值被交换。两个元素数值交换的常用方法是：先把第一个元素的值放到临时变量中暂存（int t=arr[i];），将第二个元素的值赋予第一个元素（arr[i]=arr[j];），再将临时变量中的值赋予第二个元素（arr[j] =t;）。

1. 本程序的功能是：首先建立一个有序数组{18，16，14，12，10，8，6，4，2}，然后将整数13插入该数组中并使数组仍然有序，即插入后的数组为{18，16，14，13，12，10，8，6，4，2}。请将程序补充完整。

public class InsertIn{
   public static void main(String args[])   {
      int i,q=13;
            (1)    
      System.out.println("Before Insert:");
      for (i=0;i<=8;i++) { 
              (2)    
          System.out.print(n[i]+"   ");
       }
      System.out.println();
      System.out.print("After Insert:");
      for (i=8;i>=0;i--) { 
          if (n[i]<=q) { 
                 (3)   
              if (i==0) 
                 (4)   
          }
         else { 
                 (5)   
              break;
           }
       }
      System.out.println();
      for (i=0;i<=9;i++) 
          System.out.print(n[i]+"   ");
   }
}

答案：
（1）int n[]=new int[10];
（2）n[i]=18-2*i;
（3）n[i+1]=n[i];
（4）n[i]=q;
（5）n[i+1]=q;
解析：按照题目的要求首先应该声明数组，数组名应通过仔细观察程序后面所使用到的数组的名称而获得。根据题目要求，数组元素所获得的数值应从递推公式n[i]=18-2*i中产生。当前插入法排序的思想是：将原数组从最后一个元素起，逐个与要插入的数据（此处为q）进行比较，若最后一个元素比q小，则将该元素后移一位（即将n[8]的值赋予n[9]）；然后将倒数第二个元素与q进行比较，若该元素仍然小于q，则同样将该元素后移一位（即将n[7]的值赋予n[8]）；以此类推到倒数第i个元素，若该元素仍然小于q，则同样将该元素后移一位（即将n[i]的值赋予n[i+1]）；若判断下来所有的元素都小于q（此时所有的元素都被后移了一位），则将q的值赋予第一个元素；若判断下来所有的元素都不小于q，则将q的值赋予最后一个元素。事实上，由于原数组本来有序，所以只要将原数组中的最后一个元素与q进行比较，若该元素的值比q大，则前面的元素都不会比q小，所以直接将q的数值赋予最后一个元素即可。

1. 下面程序的运行功能为实现字符串中字符的删除：现有字符串为“zyzmmmazza”，要从中删除字符“z”，程序运行后结果显示为“ymmmaa”。请将程序补充完整。

class TestString{
   static String strip(String s,char c){
      int n=    (1)   ;
      char[] a= new char[n];
      int i=0;
      int j=0;
      while(    (2)    ) {
         char sn=    (3)    ;
         if (sn==c) j++;
         else a[     (4)     ]=sn;
      }
      return new String(a,0,i);
}

public static void main(String[] args){
   String s=new String("zyzmmmazza");
   System.out.println(s);
   s=   (5)    ; 
   System.out.println(s);
   }
}

答案：
（1）s.length()
（2）i+j（3）s.charAt(i+j)
（4）i++
（5）strip(s,'z')
解析：本程序的TestString类中除了主方法之外，还包含另外一个类方法strip()，其中strip()方法含有两个参数，这个方法显然应该在主方法中被调用，而当前主方法中除了该填的空之外没有任何调用方法的语句，因此第5个空应填入含有实参的调用方法表达式；在strip()方法中，n的值用于声明字符数组的长度，在这里，字符数组用于存放被删除所指定字符（此处为'z'）之后所剩的字符串，它的最大长度应等同于主方法中传入的字符串的长度，故在第1个空中应填入“s.length();”，从“if (sn==c) j++”语句可知，变量j用于统计字符串中要删除的字符（此处为'z'）的个数，则变量i显然用于统计原字符串中所有不为'z'的字符的个数，本程序的基本思想是：从原字符串中逐个取字符进行判别，若当前取得的字符为'z'，则变量j增1；若当前取得的字符不为'z'，则将该字符放入a数组中，同时数组下标变量增1，以此类推，直到进行到原字符串的最后一个字符为止，当处理完最后一个字符，此时i+j应等于n，故在第2个空中应填入：i+j