【Java每日一练】day08_ 4月20日_错题总结

java中关于内存回收的正确说法是

 

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

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

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

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

正确答案： B

 

以下说法错误的是（）

 

 

A 数组是一个对象

B 数组不是一种原生类

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

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

 

正确答案： C

 

 

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

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;
        }finally {
            this.setValue(value);
            System.out.println(value);
        }
    }
}
static class B extends A{
    public B(){
        super(5);
        setValue(getValue()-3);
    }
    public void setValue(int value){
        super.setValue(2*value);
    }
}
public static void main(String[] args) {
    System.out.println(new B().getValue());
}

A 11 17 34

B 22 74 74

C 6 7 7

D 22 34 17

正确答案： D

1.首先看主函数 先执行newB（）调用B构造方法super（5）  ，调用父类A中构造方法setvalue ,但是子类中存在setvalue（），于是优先调用子类中方法此时value：10

2.继续往下setvalue(getValue()-3),先执行getvalue，由于子类中无getvalue（）于是调用父类方法getvalue（），进入方法value值变为11，接着执行finally语句this.setvalue,this指代子类B，于是调用B中setvalue(),value:22.  这时打印第一个数字22，接着返回try语句中return，value值为11。此时setvalue（getvalue()-3）调用B中setvalue，值变为16

3.newB().getvalue(),调用父类方法getvalue(),值为17，进入finally语句调用子类中的setvalue（）方法，值为34，打印出来第二个数字：34

4，接着还回try语句中return，值为17

【删数】有一个数组a[N]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以8个数(N=7)为

例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。

 输入描述：

每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。

 

 输出描述：

一行输出最后一个被删掉的数的原始下标位置。

 

示例1：

输入

8

输出

6

 

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * Created by JiaLe on 2021/4/19 20:14
 */
public class Main3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        if(n > 1000) {
            n = 999;
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(i);
        }
        int j = 0;
        while(list.size() > 1) {
            j = (j + 2) % list.size();
            list.remove(j);
        }
        System.out.println(list.get(0));
    }

}

【n个数里最小的k个】找出n个数里最小的k个

输入描述：

每个测试输入包含空格分割的n+1个整数，最后一个整数为k值,n不超过100。

输出描述：

输出n个整数里最小的k个数。升序输出

示例1：

输入

3 9 6 8 -10 7 -11 19 30 12 23 5

输出

-11 -10 3 6 7

 

import java.util.Arrays;
import java.util.Scanner;

/**
 * Created by JiaLe on 2021/4/19 19:42
 */
public class Main2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        String[] str = s.trim().split(" ");
        int[] arr = new int[str.length - 1];
        int k = Integer.parseInt(str[str.length - 1]);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(str[i]);
        }
        int[] res = quickSearch(arr,0,arr.length - 1,k - 1);
        Arrays.sort(res);
        for (int i = 0; i < res.length - 1; i++) {
            System.out.print(res[i] + " ");
        }
        System.out.println(res[res.length - 1]);
        return;
    }
    public static int[] quickSearch(int[] nums, int low, int high, int k) {
        int j = partition(nums,low,high);
        if(j == k) {
            return Arrays.copyOf(nums,j + 1);
        }
        return j > k ? quickSearch(nums,low,j-1,k) : quickSearch(nums, j+1,high,k);
    }

    public static int partition(int[] nums, int low, int high) {
        int v =nums[low];
        int i = low;
        int j = high + 1;
        while(true) {
            while(++i <= high && nums[i] < v);
            while(--j >= low && nums[j] > v);
            if(i >= j) {
                break;
            }
            int t = nums[j];
            nums[j] = nums[i];
            nums[i] = t;
        }
        nums[low] = nums[j];
        nums[j] = v;
        return j;
    }
}