一、选择
单选
合并N条长度为M的有序链表，合并后的链表保持有序，时间复杂度为()
- O(N * M * logN)
- B O(N*M)
- C O(N)
- D O(M)
1.建立一个长度 N 的最大 / 最小堆。把这个 N 拿出条链表的第一个元素，建立最小堆，时间复杂:O(N)
2.元素(堆顶)依次从最小堆中取出。此时，堆顶是当前集合的最小值，将链表中的其他元素放入堆中。调整堆的时间复杂性:O(siftDown - N*M*logN)，还需要堆放的元素总数，O(N*M*logN)
总共：建堆 不断调整堆(不断取出堆顶元素) O(N) O(N*M*logN)，取最高阶：O(N*M*logN)
大小为MAX在循环队列中，f对于当前对头元素的位置，r对于当前队尾元素的位置（最后一个元素的位置），队列中的元素数量在任何时候都是
- A r-f
- (r-f MAX 1)%MAX
- C r-f 1
- D (r-f MAX)%MAX
HASH 函数冲突处理方法不包括以下哪一项：
- A 开放定址法
- B 链地址法
- 插入排序法
- D 公共溢出区法
已知小根堆为8、15、10、21、34、16、12 8 之后需要重建堆。在这个过程中，关键词之间的比较次数是() 。
- A 1
- B 2
- 3
- D 4
堆顶与堆的最后一个元素交换，向下调整为小根堆
下列选项中，不可能是快速排序第2趟排序结果的是 （）
- A 二、五、四、六、七
- B 七、五、六、四、三
- 三、五、四、七、六
- D 四、三、五、七、六
每次快速排列，标定点必须在最终位置。快速排列两次，至少有两个元素到达最终位置：
A：2 3 9。B：2 9。C：9。D：5 9
堆排序平均执行时间复杂度和附加存储空间复杂度为()
- A O(N2)和O(1)
- O(Nlog2N)和O(1)
- C O(Nlog2N)和O(N)
- D O(N2)和O(N)
原地堆排序
下面有关JVM内存，错误的说法是什么？
- A 程序计数器是一个相对较小的内存区域，用于指示当前线程执行的字节码执行到第几行，是线程隔离
- B Java该方法用于存储局部变量、操作堆栈、动态链接、方法出口等信息，是线程隔离
- 存储方法区JVM线程隔离加载的类信息、常量、静态变量、即时编译器编译的代码等数据
- D 原则上，所有对象都在堆区上分配内存，线程共享
方法区是线程共享的
以下程序段的输出结果如下：（ ）
public void complicatedexpression_r(){ int x=20, y=30; boolean b; b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60; System.out.println(b); }
- A true
- false
- C 1
- D 0
输入流将数据从文件中输入或其他外部输入设备中加载道内存，在 java 中其对应于抽象类（）及其子类。
- B java.io.OutputStream
- C java.os.InputStream
- D java.os.OutputStream
下面关于程序编译说法正确的是（）
- A java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
- B java编译出来的目标文件与具体操作系统有关
- D java编译出来的目标文件，可以运行在任意jvm上
Java 是半编译半解释型语言
class 是与操作系统无关，面向 JVM 的二进制文件
1、编译：javac，*.java -> *.class。2、运行：java JVM 实际上此时会把 class 文件翻译成系统运行的机器码
JVM 也是有版本的，JDK11 的 class 文件 JDK8 是无法运行的
下面那些情况可以终止当前线程的运行？
- A 当一个优先级高的线程进入就绪状态时
- C 当该线程调用sleep()方法时
- D 当创建一个新线程时
线程的终止： 1、线程的任务执行完毕 (正常终止) 2、线程执行过程中出现异常 (异常终止)
public static void main(String args[]) {
Thread t=new Thread(){
public void run(){
dianping();
}
};
t.run();
System.out.print("dazhong"); }
static void dianping(){
System.out.print("dianping");
}
- A dazhongdianping
- C a和b都有可能
- D dianping循环输出，dazhong夹杂在中间
本题中，线程 t 并没有启动，只是调用了run()方法，直接调用run()，没有启动新的线程，相当于调用普通方法而已。程序中运行的线程依然只有一个，那么程序会按照顺序执行，即先运行run(),run()方法调用dianping()方法输 出"dianping"，程序继续向下执行输出"dazhong"。如果本题中t线程调用start()方法，就会出现C选项的情况。综上所述，正确答案为B。
public interface IService {String NAME=“default”;}
默认类型等价表示是哪一项:
- A public String NAME=“default”;
- B public static String NAME=“default”;
- D private String NAME=“default”;
接口中的变量都是全局常量 public static final
有以下类定义：
abstract class Animal{ abstract void say(); } public class Cat extends Animal{ public Cat(){ System.out.printf("I am a cat"); } public static void main(String[] args) { Cat cat=new Cat(); } }运行后：
- A I am a cat
- C Animal不能编译，Cat能编译
- D 编译能通过，但是没有输出结果
抽象类的子类必须覆写所有的抽象方法 (子类不是抽象类)
在Java中，以下关于方法重载和方法重写描述正确的是？
- A 方法重载和方法的重写实现的功能相同
- B 方法重载出现在父子关系中，方法重写是在同一类中
- C 方法重载的返回值类型必须一致，参数项必须不同
// 向上转型类的返回值可以
class A {
A test() {
return this;
}
}
class B extends A {
B test() {
return this;s
}
}
下列哪些语句关于内存回收的说明是正确的? ( )
- A 程序员必须创建一个线程来释放内存
- **
- C 内存回收程序允许程序员直接释放内存
- D 内存回收程序可以在指定的时间释放内存对象
JVM 垃圾回收由 JVM 来自己执行
下列语句正确的是：
- A 形式参数可被字段修饰符修饰
- B 形式参数不可以是对象
- C 形式参数为方法被调用时真正被传递的参数
A：字段修饰符: 访问权限 public 等。C：实参。D：形式参数可被视为局部变量
在java7中,下列哪个说法是正确的:
- A ConcurrentHashMap使用synchronized关键字保证线程安全
- B HashMap实现了Collection接口
- C Arrays.asList方法返回java.util.ArrayList对象
A：lock。B：Collection 接口是线性表的顶级接口，HashMap 实现 Map 接口。C：List 接口对象
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
关于以下程序段，正确的说法是：（）
String s1="abc"+"def";//1 String s2=new String（s1);//2 if(s1.equals(s2))//3 System.out.println(".equals succeeded");//4 if(s1==s2)//5 System.out.println("==succeeded");//6
- A 行4，行6都不执行
- B 行6执行，行4不执行
- D 行4，行6都将执行
字符串对象比较相等，使用 equals 比较内容，使用 == 比较就是地址
用命令方式运行以下代码的运行结果是（）
public class f{ public static void main(String[] args){ String foo1 = args[1]; String foo2 = args[2]; String foo3 = args[3]; } }命令: java f a b c
- A 程序编译错误
- B a b c
- 程序运行错误
- D f
编译命令：javac 源文件名称.java *.java -> *.class 运行命令：java 主类名称要传递的参数 (传递给main的args中) java f a b c —— args{a, b, c} —— [0-2]
下列说法正确的是
- A 在类方法中可用this来调用本类的类方法
- 在类方法中调用本类的类方法可直接调用
- C 在类方法中只能调用本类的类方法
- D 在类方法中绝对不能调用实例方法
A：this表示当前对象引用，不能调用静态域。B：静态方法没有对象可以直接使用。CD：如果在类方法中创建了对象，仍然可以通过对象来调用实例方法
class Test {
void func() {
};
static void test() {
Test test = new Test();
test.func();
}
}
已知如下类说明：
public class Test{ private float f=1.0f; int m=12; static int n=1; public static void main(String args[]){ Test t=new Test(); } }如下哪些使用是正确的（）
- A t.f = 1.0
- B this.n
- C Test.m
- Test.n
有以下代码:
class A{ public A(String str){ } } public class Test{ public static void main(String[] args) { A classa=new A("he"); A classb=new A("he"); System.out.println(classa==classb); } }请问输出的结果是:
- B true
- C 报错
- D 以上选项都不正确
==比较的是两个引用的地址，classa和classb都是new出来的，地址必然不相等
以下哪项 java类加载过程？
- A 生成java.lang.Class对象
- int类型对象成员变量赋予默认值
- C 执行static块代码
- D 类方法解析
B：成员变量不会被初始化，只有静态变量会被初始化。对象产生时执行，在类加载之后，不属于类加载过程
java中下面哪个能创建并启动线程（）
public class MyRunnable implements Runnable { public void run() { //some code here } }
- A new Runnable(MyRunnable).start()
- B new Thread(MyRunnable).run()
- new Thread(new MyRunnable()).start()
- D new MyRunnable().start()
创建并启动线程的过程为：定义线程->实例化线程->启动线程。 定义线程有两种方式，一种是继承java.lang.Thread类，一种是实现java.lang.Runnable接口。这两种方式实例化线程区别在于，如果是继承了Thread类，直接 new一个对象就可以了，如果是实现了Runnable接口的类，则需要用Thread的构造方法： Thread(Runnable target) Thread(Runnable target, String name) Thread(ThreadGroup group, Runnable target) Thread(ThreadGroup group, Runnable target, String name) Thread(ThreadGroup group, Runnable target, String name, long stackSize) 因此A、D两个选项实例化线程存在错误。B选项中new Runnable(MyRunnable)中的MyRunnable还没有实例化，会导致编译不通过，该选项无论后面是调用 run()还是start()都是错误的。
如果希望监听端口9000，服务器端应该怎样创建socket?
- A new Socket(“localhost”,9000);
- C new Socket(9000);
服务器端使用 ServerSocket(int port)，默认在本地指定端口号监听 TCP 端口 客户端使用Socket来连接服务器 Socket(lP,port)
下列哪个类的声明是正确的？
A abstract final class HI{}
B abstract private move(){}
C protected private number;
java 接口的修饰符可以为（）
- A private
- B protected
- C final
题目指直接在接口定义上使用的修饰符，接口权限都是 public
jre 判断程序是否执行结束的标准是（）
- B 所有的后台线程执行完毕
- C 所有的线程执行完毕
- D 和以上都无关
JRE：Java 运行时环境 JDK：Java开发工具包，包含了 JRE 什么时候 Java 进程认为程序全部执行完毕：所有前台线程(用户线程)执行完毕 手动置为后台线程：setDameon(true) 一般我们创建的线程都是前台线程。后台线程：JVM垃圾回收线程
int i=5; int s=(i++)+(++i)+(i–)+(–i); s=( )//s 的值是什么？
- A 28
- B 25
- C 21
- D 26
- F 23
5 7 7 5
下面不属于Object类中方法的是:
- A hashCode()
- C wait()
- D toString()
finalize() 是 Object 类的方法，用于释放线程资源
下列哪项不属于jdk1.6垃圾收集器？
- A Serial收集器
- B parNew收集器
- C CMS收集器
JDK7之后版本
instanceof运算符能够用来判断一个对象是否为:
- A 一个类的实例
- B 一个实现指定接口的类的实例
- D 一个子类的实例
以下哪项是类实例化的语句？
- A varName ClassName=new varName();
- B ClassName varName=new ClassName(new ClassName);
- C ClassName varName=ClassName();
类名称 引用名称 = new类();
当你编译和运行下面的代码时，会出现下面选项中的哪种情况？
public class Pvf{ static boolean Paddy; public static void main(String args[]){ System.out.println(Paddy); } }
- A 编译时错误
- C 编译通过并输出结果true
- D 编译通过并输出结果null
类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。 本题中Paddy是静态的成员变量，因此它会获得boolean类型的初始值false。
以下叙述正确的是
- A 实例方法可直接调用超类的实例方法
- B 实例方法可直接调用超类的类方法
- C 实例方法可直接调用子类的实例方法
- 实例方法可直接调用本类的实例方法
A：super()。B：类名称。C：子类对象
HashSet子类依靠()方法区分重复元素。
- A toString(),equals()
- B clone(),equals()
- hashCode(),equals()
- D getClass(),clone()
先调用对象hashcode方法将对象映射为数组下标，再通过equlas来判断元素内容是否相同
以下代码在编译和运行过程中会出现什么情况
public class TestDemo{ private int count; public static void main(String[] args) { TestDemo test=new TestDemo(88); System.out.println(test.count); } TestDemo(int a) { count=a; } }
- 编译运行通过，输出结果是88
- B 编译时错误，count变量定义的是私有变量
- C 编译时错误，System.out.println方法被调用时test没有被初始化
- D 编译和执行时没有输出结果
private在类内部可以使用，count是成员变量，通过对象访问
以下程序执行的结果是：
class X{ Y y=new Y(); public X(){ System.out.print("X"); } } class Y{ public Y(){ System.out.print("Y"); } } public class Z extends X{ Y y=new Y(); public Z(){ System.out.print("Z"); } public static void main(String[] args) { new Z(); } }
- A ZYXX
- B ZYXY
- D XYZX
初始化父类中的静态成员变量和静态代码块 ； 初始化子类中的静态成员变量和静态代码块 ； 3.初始化父类的普通成员变量和代码块，再执行父类的构造方法； 4.初始化子类的普通成员变量和代码块，再执行子类的构造方法； 具体过程如下“ （1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y （2）再执行父类的构造方法；输出X （3）初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y （4）再执行子类的构造方法；输出Z 所以选C
有这么一段程序：
public class Test{ public String name="abc"; public static void main(String[] args){ Test test=new Test(); Test testB=new Test(); System.out.println(test.equals(testB)+","+test.name.equals(testB.name)); } }请问以上程序执行的结果是（）
- A true,true
- B true,false
- D false,false
Object提供的equals方法，默认是比较对象地址是否相同。而字符串重写了 equals 方法，比较的是值是否相等。
考虑下面这个简单的例子，让我们看看reflection是如何工作的。
import java.lang.reflect.*; public class DumpMethods{ public static void main(String[] args) { try { Class c=Class.forName(args[0]); Method m[]=c.getDeclaredMethods(); for (int i = 0; i < m.length; i++) { System.out.println(m[i].toString()); } } catch (Throwable e) { System.err.println(e); } } }其中"c.getDeclaredMethods"的作用是:
- A 取得类的公有方法对象
- B 取得类的所有公有方法名称
- C 取得类的所有方法对象
java 的字符类型采用的是 Unicode 编码方案，每个 Unicode 码占用（）个比特位。 A 8 C 32 D 64
以下多线程对int型变量x的操作,哪个不需要进行同步() A ++x B x=y C x++
B：x的赋值依赖于一个变量非原子。D：直接的赋值操作属于原子操作
有如下4条语句：()
Integer i01=59; // 自动装箱 int i02=59; Integer i03=Integer.valueOf(59); // 装箱 Integer i04=new Integer(59); // 在堆上 new 了一个新对象以下输出结果为false的是: A System.out.println(i01==i02); // 将i01自动拆箱，还原为整型 B System.out.println(i01==i03); // true C System.out.println(i03==i04); // 有new就有新空间，i03和i04地址不等 D System.out.println(i02==i04); // 自动拆箱，i04还原为int
A、D选项，当包装类与基本数据类型对比时，包装类会自动拆箱变为基本类型再进行比较，即Integer i01会拆箱为int类型与i02对比。因 此System.out.println(i01==i02);输出为true。 B选项，包装数据类直接赋值，默认调用其对用的valueOf()方法。那么Integer i03=Integer.valueOf(59);就等价于Integer i01=59;valueOf()操作-128 ~ 127 之内的整型，在第一次引用，会在缓存中new一个对象；再次引用，直接从缓存中查找；操作-128 ~ 127之外的整型，则每次都要new一个对象。也就是说如果 已经创建了一个-128 ~ 127之间的整数，使用valueOf创建第二次时，不会使用new关键字，而用已经缓存的对象。因此System.out.println(i01==i03);输出 true。 C选项，包装类是基础数据类型的引用类型，i04的定义使用了new关键字，这会开辟出一块新内存来放置值为59的Integer对象。那么两个地址不同的引用类 型变量进行==判断结果自然是false。答案选择C。
// 原码：
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
在单处理器系统中，如果同时存在有12个进程，则处于就绪队列中的进程数量最多为（）
A 1
B 9
C 10
以下关于多线程的叙述错误的是：
- A 线程同步的方法包括使用临界区，互斥量，信号量等
- B 两个线程同时对简单类型全局变量进行写操作也需要互斥
- 实现可重入函数时，对自动变量也要用互斥量加以保护
- D 可重入函数不可以调用不可重入函数
临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。(临界区可以认为是操作共享资源的一段代码) 互斥量:为协调共同对一个共享资源的单独访问而设计的。信号量:为控制一个具有有限数量用户资源而设计。| 事件:用来通知线程有一些事件已发生，从而启动后继任务的开始
可重入函数: 主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么错误; 不可重入的函数: 由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。 自动变量: 局部作用域变量，定义的时候才被创建，函数返回时，系统回收空问;属于线程私有的
系统死锁的可能的原因是
- A 进程死循环
- 资源循环等待
- C 程序内存访问越界
- D 进程释放资源
整数0x12345678，在采用bigendian中内存的排序序列是（ ）
- 12 34 56 78
- B 78 56 34 12
- C 87 65 43 21
- D 21 43 65 87
bigendian 大端模式，littleenddian 小端模式
使用C语言将一个1G字节的字符数组从头到尾全部设置为字’A’，在一台典型的当代PC上，需要花费的CPU时间的数量级最接近（）
- A 0.001秒
- C 100秒
- D 2小时
单位之间的换算规则是：
1GB = 1024MB 1MB = 1024KB
1KB = 1024B
1B = 8bits 所以1GB = 1,073,741,824B 执行1条语句约 1ns即1/1,00o,000 ,000秒(10^9)，每次赋值1B都要执行一次语句，所以对于1G来说大约是1秒 10^9 * 1,073,741,824
对于普通的计算机，对以下事件的平均耗时从小到大排序为____：
A.读取1KB内存数据 B.从硬盘连续读取1KB数据 C.读取一次L2缓存 D.一次磁盘寻道
- B C,D,A,B
- C D,C,A,B
- D D,A,C,B
缓存是level 2缓存是二级缓存的意思，通过缓存直接与cpu进行数据交互，这个是最快最直接的。
第二个内存读取时间，当通过CPU缓存寻找数据时发现数据在缓存中不存在这时需要通过，到内存中去寻找，但是内存的传输速度就没有缓存这么快了，所以，内存读取数据的时间消耗要大于缓存。
第三个从硬盘连续读取1kb，这个意思就是读取硬盘数据，其中的时间消耗主要由是，，还有三部分时间组成，所以其中的磁盘寻道时间肯定小于总的连续读取时间。
分页式虚拟存储管理系统中，页面的大小与可能产生的缺页中断次数（ ）
- A 成正比
- B 成反比
- D 成固定值
分页式虚拟存步系统: 将 (指内存要操作的数据信息) 的副本存放在磁盘这一类辅助存储器中，当作业被调度投入运行时，并不把作业的程序和数据全部装入主存，而仅仅装入立即使用的那些，，在执行过程中访问到不在主存的页面时，再把它们动态地装入。
用得较多的分页式虚拟存储管理是 (demand Paging)，当需要执行某条指令或使用某个数据，而发现它们并不在主存时，产生一个中断，系
。所以分页式虚拟存储管理系统中，页面的大小与可能产生的缺页中断次数关系不大。
关于子进程和父进程的说法，下面哪一个是正确的？（）
- A 一个父进程可以创建若干个子进程，一个子进程可以从属于若干个父进程
- B 父进程被撤销时，其所有子进程也被相应撤消
- C 子进程被撤销时，其从属的父进程也被撤销
A:一个父进程可以创建多个子进程，但一个子进程只从属于1个父进程 B:如果父进程先退出,子进程还没退出，那么子进程将被托孤给 init进程，并由init进程对它们完成状态收集工作。这时子进程的父进程就是init进程((1号进程)。init进程没有父进程。 C:子进程退出，父进程还可以继续执行 D: init进程没有父进程;一个进程，可以不创建子进程
关于线程和进程，下面说法正确的是（）
- A 终止一个进程比终止一个线程花费的时间少
- B 进程切换比同一进程内部的线程切换花费的时间少
- D 进程和线程都是资源分配和调度的基本单位
进程的创建，切换，终止，耗时/消耗的资源都比线程要高。A B改成高，D 是进程
进程调度时，下列进程状态的变化过程哪一项是不可能发生的？（）
- A 阻塞挂起->阻塞
- B 就绪挂起->就绪
- 就绪挂起->阻塞挂起
- D 阻塞挂起->就绪挂起