每日一练Day8

最新推荐文章于 2024-10-01 18:51:18 发布

PJP__00

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量61

点赞数 1

文章标签： java 算法

本文链接：https://blog.csdn.net/m0_65819602/article/details/133819472

版权

一. 单选

1. 以下选项中，对Java关于内存回收的说法正确的是（）

A 程序员必须创建一个线程来释放内存

B 内存回收程序负责释放无用内存

C 内存回收程序允许程序员直接释放内存

D 内存回收程序可以在指定的时间释放内存对象

答案

解析：

JVM的垃圾回收由JVM自己执行

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行能通过编译

答案

3. 以下说法错误的是（）

A 数组是一个对象

B 数组不是一种原生类

C 数组的大小可以任意改变

D 在Java中，数组存储在堆中连续内存空间里

答案

解析：数组的大小是固定的

4. Test.main() 函数执行后的输出是（）

Test.main() 函数执行后的输出是（）
public class Test {  
    public static void main(String [] args){  
        System.out.println(new B().getValue());  
    }  
    static class A{  
        protected int value;  
        public A(int v) {  
            setValue(v);  
        }  
        public void setValue(int value){  
            this.value = value;  
        }  
        public int getValue(){  
            try{  
                value++;  
                return value;  
            } catch(Exception e){  
                System.out.println(e.toString());  
            } finally {  
                this.setValue(value);  
                System.out.println(value);  
            }  
            return value;  
        }  
    }  
    static class B extends A{  
        public B() {  
            super(5);  
            setValue(getValue() - 3);  
        }  
        public void setValue(int value){  
            super.setValue(2 * value);  
        }  
    }  
}

A 11 17 34

B 22 74 74

C 6 7 7

D 22 34 17

答案

注意：这里父类的 getValue 中的 finally 中没有 return

首先，super()函数指的是调用父类的构造方法
①
new B()
执行B的构造函数，第一行是super(5);
此时执行的是A的构造函数，A的构造函数调用的是setValue()方法，由于B重写了A的这个方法，
所以！！！执行的是B的 setValue()方法。
即传入的参数是2*5=10
此时，因为super，所以调用的是父类的 setValue()方法，即value=10
第一行执行完毕。
第二行是 setValue(getValue()-3);
B没有getValue()方法，故执行父类的此方法，
try返回的是value=10+1=11，保存在临时栈中
finally中调用this的方法，这个this指的是B的对象，又重写，故就是B的 setValue()方法
value=2*11=22，第一个打印到屏幕上的数字
接下来参数 getValue()-3=11-3=8
传入B的 setValue()方法
此时value=2*8=16
至此，new B()执行结束
②
new B(). getValue()
B没有 getValue()，故执行A的 getValue()
try返回16+1=17，保存到临时栈中
finally调用B的 setValue()方法
value=17*2=34，第二个打印到屏幕上面的数字
最后主函数打印返回值，也就是try保存到临时栈的17
1
答案就是：22,34,17

5. 关于Java的异常处理机制的叙述哪些正确？

A 如果程序发生错误及捕捉到异常情况了，才会执行finally部分

B 其他选项都不正确

C 当try区段的程序发生异常且被catch捕捉到时，才会执行catch区段的程序

D catch部分捕捉到异常情况时，才会执行finally部分

答案

解析：finally 部分无论是否 catch 部分捕捉到异常都会执行

6. 如何跳出Array的forEach循环？（）

A break

B return true

C return false

D 以上都不是

答案

7. 一个以”.java”为后缀的源文件

A 只能包含一个类，类名必须与文件名相同

B 只能包含与文件名相同的类以及其中的内部类

C 只能有一个与文件名相同的类，可以包含其他类

D 可以包含任意类

答案

8. 如下Java语句

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

执行后， x的值是（）

A 3

B 0.6

C 0.4

D 0.75

答案

解析：-- 是先减再用

9. 下列代码运行后输出结果为（）

public class Test1 {
    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

答案

解析：静态成员在内存中只存在一个，该类的所有对象共用这一个静态成员

10. JUnit主要用来完成什么

A 发送HTTP请求

B 建立TCP连接

C 集成测试

D 单元测试

答案

二. 编程

1. ACM编程题标题：两种排序方法 | 时间限制：1秒 | 内存限制：32768K

考拉有n个字符串字符串，任意两个字符串长度都是不同的。考拉最近学习到有两种字符串的排序方法：

1.根据字符串的字典序排序。例如：

"car" < "carriage" < "cats" < "doggies < "koala"

2.根据字符串的长度排序。例如：

"car" < "cats" < "koala" < "doggies" < "carriage"

考拉想知道自己的这些字符串排列顺序是否满足这两种排序方法，考拉要忙着吃树叶，所以需要你来帮忙验证。

输入描述：

输入第一行为字符串个数n(n ≤ 100)

接下来的n行,每行一个字符串,字符串长度均小于100，均由小写字母组成

输出描述：

如果这些字符串是根据字典序排列而不是根据长度排列输出"lexicographically"

如果根据长度排列而不是字典序排列输出"lengths",

如果两种方式都符合输出"both"，否则输出"none"

示例1:

输入

bbb

输出

both

答案

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) { 
           int n = in.nextInt();
           String[] str = new String[n];
           for(int i = 0; i< n;i++){
                str[i] = in.next();
           }
          boolean dic = isDicSort(str);
          boolean len = isLenSort(str);
          if(dic && len){
              System.out.print("both");
          }else if(dic){
            System.out.print("lexicographically");
          }else if(len){
            System.out.print("lengths");
          }else{
            System.out.print("none");
          }

        }
    }
     public static boolean isDicSort(String[] str){
        for(int i = 0;i< str.length -1;i++){
        // int result = a.compareTo(b); // result的值为-1，因为"apple"在字典序中排在"banana"之前
               if(str[i].compareTo(str[i+1]) > 0){  
                    return false;
               }
        }
        return true;
     }
     public static boolean isLenSort(String[] str){
        for(int i = 0;i< str.length -1;i++){
               if(str[i].length()>str[i+1].length()){
                    return false;
               }
        }
        return true;
     }
}

字典排序还可以这样

将字符串数组转换为集合，调用 Collections.sort(list);(默认是按元素的第一个字母从小到大排序) 再与原来的没有排序的集合进行 equals 比较

2. ACM编程题标题：求最小公倍数 | 时间限制：1秒 | 内存限制：32768K

正整数A和正整数B 的最小公倍数是指能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

数据范围： 1≤a,b≤100000

输入描述：

输入两个正整数A和B。

输出描述：

输出A和B的最小公倍数。

示例1:

输入

5 7

输出

示例2:

输入

2 4

输出

答案

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
         int a = in.nextInt();
         int b = in.nextInt();
         int c = a ; // 记录下a的值方便a做自加运算
         System.out.print(common(a,b,c));
    }
    public static int common(int a,int b,int c){
         if(a % b == 0){  // a累加自身 可以整除a ，直到能整除b
            return a;
         }
         return common(a+c,b,c); // a累加自身
    }
}