答题与解题（4）

Java SE专题

1、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（A）
A、static void method()
B、public void method()
C、final void method()
D、abstract void method()

解题：根据题意，直接调用方法，那么这里面只有static，static用来修饰类或者类的成员，这时不需要创建实例就能访问（而且不能实例化）再被调用的时候自动实例化，且再内存中产生一个实例。当含有静态成员的非静态类实例化出对象后，这些对象公用这些静态成员，通过类名或者对象都能访问它们

2、
类Person和类Student的关系是（）
A、包含关系
B、继承关系
C、关联关系
D、无关系，上述类定义有语法错误

解题：仔细阅读题目，出现了关键字extends，所以对应选择继承关系

3、一个类中，有两个方法名，形参类型，顺序个个数都完全一样，返回值不一样的方法，这种现象叫覆盖（）
A、正确
B、错误

解题：这里主要想考大家对于重载和重写的区别：重载就是同一个类中，有多个方法名相同，但是参数列表不同（这里参数个数和参数类型），与返回值无关，与权限修饰符有关。调用重载的方法时通过传递给它们不同的参数个数和参数类型来决定具体使用哪个方法，这也叫多态。重写就是子类重写基类的方法，方法名，参数列表和返回值都必须相同，否则就不是重写而是重载。权限修饰符不能小于被重写方法的修饰符。重写方法不能抛出新的异常或者是比重写方法声明更加宽泛的检查型异常

4、
A、24
B、16
C、15
D、8

解题：这里说明一下，在Java中的String底层是char数组，它的length（）返回数组大小，而unicode中一个汉字是可以用一个char表示的

5、
A、class A static B static i’m A class class A i’m B class class B
B、class A static i’m A class class A class B static i’m B class class B
C、class A static class B static class A i’m A class class B i’m B class
D、class A static class A i’m A class class B static class B i’m B class

解题：java程序初始化的执行顺序：父类静态变量——父类静态代码块——子类静态变量——子类静态代码块——父类非静态变量——父类非静态代码块——父类构造方法——子类非静态变量——子类非静态代码块——子类构造方法

6、
A、15 0 20
B、15 0 15
C、20 0 20
D、0 15 20

解题：这道题，考察的是值传递与引用传递，Java中原始数据类型都是值传递，传递的是值副本，形参的改变不会影响实际参数的值，
引用传递传递的是引用类型数据，包括String，数组，列表，map，类对象等类型，形参与实参指向的是同一内存地址，因此形参改变会影响实参的值

7、

解题：此题选择D

8、
A、静态块 构造快 构造快 构造快
B、构造快 静态块 构造快 构造快
C、构造块 构造快 静态块 构造快
D、构造快 构造快 构造块 静态块

解题：静态块用static申明，JVM加载类时执行，仅执行一次
构造快类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main>构造快>构造方法

9、下面描述属于java虚拟机功能的是？
A、通过ClassLoader寻找和装载class文件
B、解释字节码成为指令并执行，提供class文件的运行环境
C、进行运行期间垃圾回收
D、提供与硬件交互的平台

解题：此题靠对于JVM虚拟机的认知知识点，这里重点说明一下D选项虚拟机是运行在操作系统之上的，不与硬件交互

10、
A、(su)
B、(st)
C、(s.equals(t))
D、(s.equals(9))
E、(s.equals(new Integer(9)))

解题：int和int之间，用比较，肯定为true。基本数据类型没有equals方法
int和Integer比较，Integer会自动拆箱， 和 equals都肯定为true
int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 和 equals都肯定为true
Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new Integer。
当Integer和Integer进行比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false
当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以为true
Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存中取，否则会new Integer.
所以 Integer和new Integer 进行比较的话，肯定为false ; Integer和new Integer 进行equals比较的话，肯定为true
new Integer和new Integer进行比较的时候，肯定为false ; 进行equals比较的时候，肯定为true
原因是new的时候，会在堆中创建对象，分配的地址不同，比较的是内存地址，所以肯定不同
装箱过程是通过调用包装器的valueOf方法实现的
拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）
总结：Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
而Float和Double则不相等， Boolean的值总是相等的

数组专题

1、以下叙述正确的是（）
A、线性表的线性存储结构优于链表存储结构
B、二维数组是它的每个数据元素为一个线性表的线性表
C、栈的操作方式是先进先出
D、队列的操作方式先进后厨

解题：A: 线性表查找复杂度为O(1),添加删除元素复杂度为O(n)，而链表查找复杂度为O(n)，添加删除元素时空复杂度为O(1)，所以二者无法直接比较，在不同***作下各有优缺点
B：二维数组可以看多一个一维数组，而一维数组的每一个元素都是另一个一位数组，所以是一个相对的二维数组，B选项正确。
C：由于栈的结构是只有一个出口，先进的元素在栈底部无法先出栈，所以先进后出
D：由于队列的结构前面是入口，后面是出口，先进的元素会优先从队尾出栈，所以是先进先出

2、有一个 100 × 90 的稀疏矩阵，非 0 元素有 10 ，设每个整型数占 2 个字节，则用三元组表示该矩阵时，所需的字节数是 。
A、20
B、66
C、18000
D、33

解题：三元组方式存储数据的策略是只存储非零元素。但是稀疏矩阵中非零元素的分布是没有任何规律的，在这种情况下，存储方案是：
1.存储非零元素
2.同时存储该非零元素所对应的行下标和列下标
3.稀疏矩阵中的每一个非零元素需由一个三元组(i, j,aij)唯一确定,稀疏矩阵中的所有非零元素构成三元组线性表，三元组中的i就是行下标，j是列下标，aij是对应的元素值。
此题10个非零元素：1032=60字节。
剩下的6个字节：分配给行数、列数、总元素数 即3*2=6字节
总字节数目：60+6=66字节

3、设二维数组A[1…m]1…n按行存储在数组B[1…m*n]中,则二维数组元素A[i][j]在一维数组B中的下标为()
A、(i-1)*n+j
B、(i-1) *n+j-1
C、i *(j-1)
D、j *m+i-1

解题：A[ i, j ]在i 行前有 i - 1 行，就有(i - 1) * n 个元素，再加上它是在 j 列，所以就是 (i - 1) * n + j，注意这里数组下标是从1开始的，所以不需要减1

4、对于一维整形数组a，以下描述正确的是（）
A、int a(10)
B、int n=10,a[n]
C、int n
scanf(“%d”, &n)
int a[n]
D、#define SIZE 10
int a[SIZE]

解题：A选项不符合数组定义规则，B选项也不符合数组定义规则，C选项也不符合数组定义规则，定义一个数组使用[]确定其大小，[]中的值须为定制，define宏定义的值也为定值，可以用来定义数组若需要定义不确定长度的则使用new进行分配，int *a=new int[size];

5、假设有60行70列的二维数组A[1……60,1…70]以列序为主序顺序存储,其基地址为10000,每个素占2个存储单元,那么第32行第58列的元素A[32,58]的存储地址为( )。(无第0行第0列元素)
A、16902
B、16904
C、14454
D、其他选项均不对

解题：题目要求该二维数组是按列优先存储的。
因此32行58列的元素地址计算方式是10000+(58-1)602+31*2=16902

数组编程题

1、给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在众数。

分析图：

详细说明一下，定义一个常量num=num[0],定义个变量count=1用来计数，我们可以理解为从数组再拿出下一个元素，如果跟常量num相等，我们就给它count++，如果是不一样的数我们就count–，相当于一直进行比较，当count等于0时，说明没有元素跟它进行比较，那么这个元素肯定是最多的，答案也就出来了。
代码实现：

class Solution {
    public int majorityElement(int[] nums) {
        int num = nums[0];
        int count = 1;
        for(int i = 1;i < nums.length;i++){
            if(nums[i] == num){
                count++;
            } else{
                count--;
                if(count == 0){
                    num = nums[i];
                    count = 1;
                }
            }
        }
        return num;
    }
}

2、给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。


分析图：

详解：首先我们需要两个参数，一个是给定的数组，另一个是需要删除的元素值是多少，同样我们需要一个新的角标从0开始，用来替换元素，遍历数组从第一个元素开始，只要是它不等于要删除的元素，就将它给新角标，依次类推，那么代码就好写了。
代码实现：

package com.study.力扣练习;

public class Test27 {

	public static void main(String[] args) {
		int[] nums = {0,1,2,2,3,0,4,2};
		int val = 2;
		Test27 t = new Test27();
		int i = t.removeElement(nums, val);
		System.out.println(i);
	}

	public static int removeElement(int[] nums, int val) {
		int i = 0;
		for(int j=0;j<nums.length;j++) {
			if(nums[j]!=val) {
				nums[i]=nums[j];
				i++;
			}
		}
		return i;

	}

}