赛码-Java面试题笔记

1.有关接口说法正确的是

• A. 接口中的数据成员为final static
• B. 接口中的数据成员为public abstract
• C. 接口同样存在构造方法
• D. 实现接口的类必须实现该接口的所有抽象方法

AD

C 接口是无法被实例化的，没有构造方法

D 如果是抽象类的话，就不需要。

2.下列程序的输出结果是

public class Test {
    public static void main(String[] args) {
        String [][]s={{"helloworld","hello world"},{"this is","a java program"}};
        System.out.println((new StringTokenizer(s[1][1])).countTokens()>2);
    }
}

• A. 3>2
• B. 2>2
• C. false
• D. true

D

3.使用折半查找算法对含有20个元素的有序表查找的平均查找长度

• A. 2.3
• B. 4.3
• C. 5.1
• D. 3

B

折半查找时间复杂度是 log2(n)，所以 log2(20)=4.3

4.对含有31个元素的序列采用直接选择排序算法排序，在最坏情况下需要进行多少次移动才能完成排序

• A. 31
• B. 30
• C. 60
• D. 90

D

（n-1）次交换，3(n-1)次移动。一次交换，需要三次移动，因为交换需要借助辅助变量。

5.使用二分法在序列1,4,6,7,15,33,39,50,64,78,75,81,89,96中查找元素81时,需要经过（ ）次比较

• A. 4
• B. 3
• C. 2
• D. 12

B

编号：0-13，第一次查找编号6的，即39

39 -> 75 -> 89

6.已知存在8阶对称矩阵，采用压缩存储方式按行序为主序存储，每个元素占一个地址空间。若a22为元素的存储地址为1，每个元素占一个地址空间，则a74的地址为

• A. 11
• B. 23
• C. 32
• D. 33

B

(1,1)

(2,1) (2,2) 1

(3,1) (3,2) (3,3) 3
(4,1) (4,2) (4,3) (4,4) 4
(5,1) (5,2) (5,3) (5,4) (5,5) 5
(6,1) (6,2) (6,3) (6,4) (6,5) (6,6) 6
(7,1) (7,2) (7,3) (7,4) 4

1+3+4+5+6+4=23

7.已知主串S=“ababcabcacbab”，模式T=“abcac”。利用KMP算法进行匹配时，需要进行几次才可以匹配成功

• A. 3
• B. 4
• C. 5
• D. 6

A

关于 KMP算法 参考：http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html

首先计算部分匹配值：
abcac中：
a的前缀为0，后缀为0，前缀和后缀重合的部分为0
ab的前缀为a，后缀为b，前缀和后缀重合的部分为0
abc的前缀为[a,ab]，后缀为[bc,c],前缀和后缀重合的部分为0
abca的前缀为[a,ab,abc]，后缀为[bca,ca,a],前缀和后缀重合的部分为1
abcac的前缀为[a,ab,abc,abca]，后缀为[bcac,cac,ac,c],前缀和后缀重合的部分为0
所以部分匹配值也就是 abcac 对应的next数组为：0 0 0 1 0
即：a b c a c
0 0 0 1 0
移动位数 = 已匹配的字符数 - 对应的部分匹配值
第一次 :
a b a b c a b c a c b a b
a b c a c
匹配个数为2，最后一个匹配的字符为 ‘b’，其next值是0 ， 移动位数=2-0=2
第二次：
a b a b c a b c a c b a b
a b c a c
匹配个数为4，最后一个匹配的字符为 ‘a’，其next值是1， 移动位数=4-1=3
第三次：
a b a b c a b c a c b a b
a b c a c
匹配成功
共需要三次

8.广度优先遍历二叉树的操作可以用哪种数据结构模拟

• A. 栈
• B. 单链表
• C. 队列
• D. 数组

C

深度用栈，广度用队列

9.下列关于二叉排序树说法正确的是

• A. 二叉排序树的查找性能取决于二叉树的形状
• B. 二叉排序树的查找性能取决于序列的大小
• C. 二叉排序树复杂度介于 O(log2n) 和 O(n) 之间
• D. 对二叉排序树进行层序遍历可得到有序序列

AC

10.单C PU系统中通常采用两级处理器调度，以下相关描述正确的是

• A. 作业调度是从慢速存储设备中的后备队列中挑选作业加载到主存中。
• B. 作业调度是从慢速存储设备中的就绪队列中挑选作业加载到主存中。
• C. 进程调度是从主存中中的后备队列中挑选进程占用处理器运行。
• D. 进程调度是从主存中中的就绪队列中挑选进程占用处理器运行。

AD

11.一级封锁协议可以

• A. 能够避免不可重复读取问题
• B. 能够避免不读“脏”数据
• C. 不能避免不可重复读取和不读“脏”数据的问题
• D. 可避免更新丢失的问题

CD

12.当需要控制一个类的实例只能有一个，而且客户端只能从一个全局访问点访问它，应该选择何种设计模式:

• A. 观察者模式
• B. 单例模式
• C. 迭代器模式
• D. 享元模式

B

13.原型模式的本质是

• A. 根据状态来分离和选择行为
• B. 封装请求
• C. 克隆生成对象
• D. 触发联动

C

14.TCP协议的拥塞控制就是防止过多的数据注入到网络中，这样可以使网络中的路由器或链路不致过载。常用的方法有

• A. 慢启动、窗口滑动
• B. 慢开始、拥塞控制
• C. 快重传、快恢复
• D. 快开始、快恢复

BC

15.

import java.util.ArrayList;
import java.util.List;
public class Main {
  public static void main(String[] args) {
     List<String> list = new ArrayList<>();
     for(int i=0;i<100;i++){
       list.add("a");
     }
  }
}

JDK1.8中，执行以上程序后，该list进行了几次扩容？

• A. 4
• B. 5
• C. 6
• D. 7

C

jdk 1.8，arrayList默认大小为10，每次扩容1.5倍。

int newCapacity = oldCapacity + (oldCapcity >> 1);

16.

public class Main {
    public static void main(String[] args) {
        System.out.print(fun1());
    }
    public static String fun1() {
        try {
            System.out.print("A");
            return fun2();
        } finally {
            System.out.print("B");
        }
    }
    public static String fun2() {
        System.out.print("C");
        return "D";
    }
}

执行以上程序后，输出结果正确的是

• A. ABCD
• B. ACDB
• C. ACBD
• D. 不确定

C

如果有finally和return，那就在return前进行finally。

本题代码，先执行fun2()方法，获取返回值后，会存到fun1()的局部变量表中，执行finally语句后，再返回这个值。

17.

public class Test {
    public static void main(String[] args) throws Exception{
      ClassLoader classLoader=ClassLoader.getSystemClassLoader();
      Class clazz=classLoader.loadClass("A");
      System.out.print("Test");
      clazz.forName("A");
    }
}
class A{
    static {
        System.out.print("A");
    }
}

• A. TestA
• B. ATestA
• C. ATestA
• D. Test

A

Class clazz=classLoader.loadClass(“A”);

加载class文件到内存中，并没有对类进行首次主动使用，所以没有初始化。

clazz.forName(“A”);

通过反射获取到A的内存中的数据结构对象，对类进行了首次使用，才会触发初始化。

static 静态代码块只在初始化时候执行一次。

对类的主动使用：创建类实例、访问类或接口的静态变量、静态方法、反射、初始化类的子类、被标明为启动类的类

18.针对类的继承，虚拟机会如何进行父类和子类的初始化加载呢

public class Test {
    public static void main(String[] args) {
        System.out.print(B.c);
    }
}
class A {
    public static String c = "C";
    static {
        System.out.print("A");
    }
}
class B extends A{
    static {
        System.out.print("B");
    }
}

• A. AC
• B. ABC
• C. C
• D. BC

A

子类 B引用父类A的静态字段，不会导致子类初始化，只会引发父类初始化。

19.

public class Test {
    public static void main(String[] args) {
        System.out.print(B.c);
    }
}
class A {
    static {
        System.out.print("A");
    }
}
class B extends A{
    static {
        System.out.print("B");
    }
    public final static String c = "C";
}

• A. AB
• B. ABC
• C. C
• D. BC

C

常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用定义常量的类，因此不会触发定义常量的类的初始化。

静态域被访问，而且它不是常量，才触发初始化。

20.JAVA的类加载期负责整个生命周期内的class的初始化和加载工作，就虚拟机的规范来说，以下代码会输出什么结果

public class Test {
    public static void main(String[] args) {
        System.out.println(Test2.a);
    }
}
class Test2{
    public static final String a="JD";
    static {
        System.out.print("OK");
    }
}

输出：JD

System.out.println(Test2.a); 用类名直接调用静态属性，没有用对象，就没加载对象中的static方法。

常量在编译阶段会存入调用类的常量池中，本质并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

21.

public class Main {
    private static int x = 10;
    private static Integer y = 10;
    public static void updateX(int value) {
        value = 3 * value;
    }
    public static void updateY(Integer value) {
        value = 3 * value;
    }
    public static void main(String[] args) {
        updateX(x);
        updateY(y);
    }
}

执行以上程序后，x和y的值分别是多少

10，10

Java中只有值传递，没有引用传递

Integer是final定义的。

Integer 是引用类型，但是每次对Integer的赋值操作，都是创建一个新的对象，并且给变量赋上新的地址值。

22.

public class Main {
    public static void main(String[] args) {
        System.out.println("A");
        new Main();
        new Main();
    }
    public Main() {
        System.out.println("B");
    }

    {
        System.out.println("C");
    }

    static {
        System.out.println("D");
    }
}

输出结果：DACBCB

静态代码块（先父类后子类）-> 非静态代码块 -> 构造函数

23.以下哪种设备工作在数据链路层？

• A. 中继器
• B. 集线器
• C. 交换机
• D. 路由器

C

物理层：中继器、集线器

数据链路层：交换机

网络层：路由器

24.一颗二叉树的叶子节点有5个，出度为1的结点有3个，该二叉树的结点总个数是

12

度数为0的节点数量 = 度数为2的节点数量 + 1

本题中：5 = x + 1 可得度数为2节点数量：x=4。

所以这颗二叉树的总节点为：5+3+4=12

25.下面linux命令中，可以用来检查内存使用状况的有

• A. sed
• B. free
• C. top
• D. iostat

BC

free 查看内存使用情况。 free -m 以M为单位显示

top 动态命令，查看进程和内存的动态情况。如果此时输入M，按进程使用内存大小排序。如果输入P，按照进程占用CPU的大小排序。

26.下列关于JVM性能调优工具的描述，错误的是

• A. jps主要是用来输出JVM中运行的进程状态信息
• B. jmap是用来查看堆栈内存使用状况
• C. jstack主要是用来查看某个Java进程内的线程堆栈信息
• D. jstat是JVM统计监测工具

C

jps：主要用来输出JVM中运行的进程状态信息

jmap：用来查看堆内存使用状况，一般结合jhat使用

jstack：堆栈跟踪工具，主要用来查看某个Java进程内的线程堆栈信息

jstat ：JVM统计监测工具，查看各个内存和GC的情况

hprof：展现CPU使用率，统计堆内存使用情况

27.某系统中有4个并发进程，多需要同类资源5个，试问该系统无论怎样都不会发生死锁的最少资源数是

17

4*(5-1) + 1

28.

public class Person{
    {
        System.out.println("P1");
    }
    static{
        System.out.println("P2");
    }
    public Person(){
        System.out.println("P3");
    }
}
public class Students extends Person{
    static{
        System.out.println("S1");
    }
    {
        System.out.println("S2");
    }
    public Students(){
        System.out.println("S3");
    }
    public static void main(String[] args){
        new Students();
    }
}

P2S1P1P3S2S3

执行顺序：父类静态代码块 -> 子类静态代码块 -> 父类代码块 -> 父类构造方法 -> 子类代码块 ->子类构造方法

首先 当JVM遇到new Students() 时，会去加载Student类，加载Student类之前要去加载父类Person，加载过程中会初始化变量和去初始化static的东西，所以先父类静态代码块后子类静态代码块，类加载完成后，就需要在内存里创建对象了，创建Student对象需要创建父类People，创建People类对象先执行代码块再执行构造器，父类执行完后执行子类的代码块和构造器。

29.

public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        t.method(null);
    }
    public void method(Object o) {
        System.out.println("Object");
    }
    public void method(String s) {
        System.out.println("String");
    }
}

输出结果：String

Object 和 String 值都可以为null。但存在继承关系，因此会将不确定对象null当作子类型处理。

最精准原则String比Object精确，因为一个String本质也是一个Object，但不是每个Object都可以是String的

30.

public class Arraytest {
    int a[] = new int[6]; 
    public static void main (String arg[]) { 
        System.out.println(a[0]); 
    } 
}

编译时出错

a数组不是静态类型，不能在静态的main方法中直接使用