笔试强训day8

一、选择题

1、java中关于内存回收的正确说法是
A 程序员必须创建一个线程来释放内存
B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象
他的回答： B (正确)
正确答案： B
2、A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：

A a0=new A();
A a1=new B();
A a2=new C();

以下哪个说法是正确的？
A 第1行，第2行和第3行的声明都是正确的
B 第1,2,3行都能通过编译，但第2,3行运行时出错
C 第1,2行能通过编译，但第3行编译出错
D 只有第1行能通过编译
他的回答： A (正确)
正确答案： A
3、以下说法错误的是（）
A 数组是一个对象
B 数组不是一种原生类
C 数组的大小可以任意改变
D 在Java中，数组存储在堆中连续内存空间里
他的回答： C (正确)
正确答案： C
**4、Test.main() 函数执行后的输出是（）
**

public class Test {
public static void main(String [] args){
System.out.println(new B().getValue());//17
}
static class A{
protected int value;
public A(int v) {//5
setValue(v);
}
public void setValue(int value){//22 34
this.value = value;//10 22 16 34
}
public int getValue(){
try{
value++;//11 17
return value;//11 17
} catch(Exception e){
System.out.println(e.toString());
} finally {
this.setValue(value);//34
System.out.println(value);//22 34
}
return value;
}
}
static class B extends A{
public B() {
super(5);
setValue(getValue() - 3);//8
}
public void setValue(int value){//5 11 8 17
super.setValue(2 * value);//10 22 16 34
}
}
}

A 11 17 34
B 22 74 74
C 6 7 7
D 22 34 17
他的回答： C (错误)
正确答案： D
5、关于Java的异常处理机制的叙述哪些正确？
A 如果程序发生错误及捕捉到异常情况了，才会执行finally部分
B 其他选项都不正确
C 当try区段的程序发生异常且被catch捕捉到时，才会执行catch区段的程序
D catch部分捕捉到异常情况时，才会执行finally部分
他的回答： C (正确)
正确答案： C
6、如何跳出Array的forEach循环？（ ）
A break
B return true
C return false
D 以上都不是
他的回答： A (正确)
正确答案： A
7、一个以”.java”为后缀的源文件
A 只能包含一个类，类名必须与文件名相同
B 只能包含与文件名相同的类以及其中的内部类
C 只能有一个与文件名相同的类，可以包含其他类
D 可以包含任意类
他的回答： C (正确)
正确答案： C
8、如下Java语句

double x= 3.0;
int y=5;
x/=--y;

执行后， x的值是（）
A 3
B 0.6
C 0.4
D 0.75
他的回答： D (正确)
正确答案： D
9、cnt的值是

public class Test{
static int cnt = 6;
static{
cnt += 9;
}
public static void main(String[] args）{
System.out.println（“cnt =” + cnt);
}
static{
cnt /=3;
};
}

A cnt=5
B cnt=2
C cnt=3
D cnt=6
他的回答： A (正确)
正确答案： A
10、JUnit主要用来完成什么
A 发送HTTP请求
B 建立TCP连接
C 集成测试
D 单元测试
他的回答： A (错误)
正确答案： D

二、编程题

**【两种排序方法】**考拉有n个字符串字符串，任意两个字符串长度都是不同的。考拉最近学习到有两种字符串的排序方法： 1.根据字符串的字典序排序。例如：
“car” < “carriage” < “cats” < “doggies < “koala”
2.根据字符串的长度排序。例如：
“car” < “cats” < “koala” < “doggies” < “carriage”
考拉想知道自己的这些字符串排列顺序是否满足这两种排序方法，考拉要忙着吃树叶，所以需要你来帮忙验证。
输入描述：
输入第一行为字符串个数n(n ≤ 100)
接下来的n行,每行一个字符串,字符串长度均小于100，均由小写字母组成
输出描述：
如果这些字符串是根据字典序排列而不是根据长度排列输出"lexicographically”,
如果根据长度排列而不是字典序排列输出"lengths",
如果两种方式都符合输出"both"，否则输出"none"
示例1：
输入
3
a
aa
bbb
输出
both
【解题思路】：
思路很简单，将接收的字符串都放到String数组中，利用string的compareTo方法来按ascii比较字符串字典序排序，利用string的length方法来比较字符串的长度排序
牛客网ACM模式代码

import java.util.*;
public class Main{
public static void main(String[] args){
       Scanner sc=new Scanner(System.in);
       int n=sc.nextInt();
       String[] str=new String[n+1];
       for(int i=0;i<n+1;i++){
            str[i]=sc.nextLine();
        }
       if(isSortZidian(str)&&isSortLength(str)){
                System.out.println("both");
       }else if(isSortZidian(str)){
                 System.out.println("lexicographically");
              }else if(isSortLength(str)){
                         System.out.println("lengths");
                     }else{
                            System.out.println("none");
                           }
         }
  public static boolean isSortZidian(String[] str){
          for(int i=0;i<str.length-1;i++){
                if(str[i].compareTo(str[i+1])>0){
                       return false;
                  }
            }
       return true;
  }
  public static boolean isSortLength(String[] str){
           for(int i=0;i<str.length-1;i++){
                  if(str[i].length()>str[i+1].length()){
                       return false;
                   }
            }
    return true;
  }
}

【求最小公倍数】
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
1<=a,b<=100000
数据范围：
输入描述：
输入两个正整数A和B。
输出描述：
输出A和B的最小公倍数。
示例1：
输入
5 7
输出
35
【解题思路】：
最小公倍数 = 两数之积除以最大公约数，这里使用碾转相除法进行最大公约数的求解：即a与b的最大公约数可以转化为a、b之间的余数为两者之间最小的数之间的公约数。所以对于输入的两个数进行连续求余，直到余数为0，求余的分母即为结果。

牛客网ACM模式代码

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        int n=sc.nextInt();
        int a=func(m,n);
        System.out.print(m*n/a);
    }
    public static int func(int m,int n){
        if(m==n){
            return m;
        }
        if(m<n){
            int tmp=n;
            n=m;
            m=tmp;
        }
        int count;
        while((count=m%n)>0){
            m=n;
            n=count;
        }
        return n;
    }
}