【牛客网专项练习题】

12月22日

1.下面哪个行为被打断不会导致InterruptedException：（ ）？
正确答案: E 你的答案: A (错误)

Thread.join

Thread.sleep

Object.wait

CyclicBarrier.await

Thread.suspend

抛InterruptedException的代表方法有：(1)java.lang.Object 类的 wait 方法
(2) java.lang.Thread 类的 sleep 方法； (3)java.lang.Thread 类的 join 方法

CyclicBarrier是一个屏障类，它的await方法可以简单的理解为：等待多个线程同时到达之后才能继续进行，在此之前它就是这些线程的屏障，线程不能继续进行，而对于失败的同步尝试，CyclicBarrier 使用了一种要么全部要么全不 (all-or-none) 的破坏模式：如果因为中断、失败或者超时等原因，导致线程过早地离开了屏障点，那么在该屏障点等待的其他所有线程也将通过 BrokenBarrierException（如果它们几乎同时被中断，则用 interruptedException）以反常的方式离开。因此它被中断也是可以抛出interruptedException的.

suspend 方法已过时。 该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用 resume 之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。

2.下面哪一项不是加载驱动程序的方法？
正确答案: A 你的答案: C (错误)

通过DriverManager.getConnection方法加载

调用方法 Class.forName

通过添加系统的jdbc.drivers属性

通过registerDriver方法注册

分析：.总结加载驱动的三种方式：1.Class.forName(“com.mysql.cj.jdbc.Driver”);
2. DriverManager.registerDriver(new com.mysql.jdbc.Driver());
3.System.setProperty(“jdbc.drivers”, “com.mysql.jdbc.Driver”);
DriverManager.getConnection方法得到的是Connection连接对象；会先加载所需要的的驱动，才得到连接；
3. 如果Child extends Parent，那么正确的有（）？
正确答案: B C D 你的答案: B C (错误)

如果Child是class，且只有一个有参数的构造函数，那么必然会调用Parent中相同参数的构造函数

如果Child是interface，那么Parent必然是interface

如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface

如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数

分析：A选项：可以调用父类无参的构造函数，子类的有参构造函数和是否调用父类的有参数的构造函数无必然联系。在子类中默认会执行super()调用父类的无参构造；如果直接子类没有无参构造，则需要子类显式调用所需要的构造方法；
4.关于ThreadLocal类 以下说法正确的是
正确答案: D E 你的答案: C D E (错误)

ThreadLocal继承自Thread

ThreadLocal实现了Runnable接口

ThreadLocal重要作用在于多线程间的数据共享

ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本

ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

分析：查看API：该类提供了线程局部变量；当访问某个变量通过set或get方法时，每个线程都有自己的局部变量，它是独立于变量的初始化副本的；ThreadLocal实例通常是private static 字段的，希望将状态与某一个线程进行绑定；
public class ThreadLocalextends Object；
5.面向对象程序设计方法的优点包含：
正确答案: A B C 你的答案: A B C D (错误)

可重用性

可扩展性

易于管理和维护

简单易懂
6. 下面的类哪些可以处理Unicode字符?
正确答案: A B C 你的答案: B C (错误)

InputStreamReader

BufferedReader

Writer

PipedInputStream

分析：
字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter ；

12月23日

1.以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( )
正确答案: A B 你的答案: A B D (错误)

String a = “hello”; String b = “hello”;

Integer a; Integer b = a;

int a = 1; Integer b = new Integer(1);

int a = 1; Integer b = 1;

分析：D选项，int型的值它是在常量池中，是没有引用地址的，虽然说a == b返回值是true，那是因为Integer会自动拆箱为int，进行值比较；
2.关于Java的一些概念，下面哪些描述是正确的：( )
正确答案: B F 你的答案: B C E (错误)

所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeException

通过try … catch … finally语句，finally中的语句部分无论发生什么异常都会得到执行

java中所有的数据都是对象

Java通过垃圾回收回收不再引用的变量，垃圾回收时对象的finallize方法一定会得到执行

Java是跨平台的语言，无论通过哪个版本的Java编写的程序都能在所有的Java运行平台中运行

Java通过synchronized进行访问的同步，synchronized作用非静态成员方法和静态成员方法上同步的目标是不同的

分析：所有的Java异常和错误的基类是Throwable;基本数据类型不是对象，他们有对应的包装类；程序中的其他线程的优先级远远高于执行finalize（）函数线程的优先级；Java是跨平台的，但是平台无关并不意味着版本无关，对于高版本编译器编写的java程序可能无法在低版本的java平台中运行；最后一个选项，一个是对对象加锁，一个是对类加锁；
3.java8中，下面哪个类用到了解决哈希冲突的开放定址法
正确答案: C 你的答案: A (错误)

LinkedHashSet

HashMap

ThreadLocal

TreeMap

threadlocalmap使用开放定址法解决haah冲突，hashmap使用链地址法解决hash冲突；ThreadLocal 继承了ThreadLocalmap；
4. 在Java中,下列说法错误的有（ ）
正确答案: B C D 你的答案: C D (错误)

数组是一种对象

数组属于一种原生类

int number = []{31,23,33,43,35,63};

数组的大小可以任意改变

分析：基本数据类型也叫原生类或是内置类型；数组的大小一旦给定，则不能更改
5. 下面有关 Java ThreadLocal 说法正确的有？
正确答案: A B C D 你的答案: B C (错误)

ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递

线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收

在Thread类中有一个Map，用于存储每一个线程的变量的副本。

对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式

分析：

12月24日

1. 对文件名为Test.java的java代码描述正确的是()
   class Person {
   String name = “No name”;
   public Person(String nm) {
   name = nm;
   }
   }
   class Employee extends Person {
   String empID = “0000”;
   public Employee(String id) {
   empID = id;
   }
   }
   public class Test {
   public static void main(String args[]) {
   Employee e = new Employee(“123”);
   System.out.println(e.empID);
   }
   }
   正确答案: C 你的答案: B (错误)

输出：0000

输出：123

编译报错

输出：No name

如果子类构造器没有显示地调用超类的构造器，则将自动地调用超类默认（没有参数）的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中有没有显示地调用超类的其他构造器，则Java编译器将报告错误。使用super调用构造器的语句必须是子类构造器的第一条语句。

2.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
package algorithms.com.guan.javajicu;
public class Inc {
public static void main(String[] args) {
Inc inc = new Inc();
int i = 0;
inc.fermin(i);
i= i ++;
System.out.println(i);

} 
void fermin(int i){ 
   i++; 
} 

}
正确答案: A 你的答案: B (错误)

0

1

2

3

分析：Java使用了中间变量缓存机制；就相当于与设置了一个临时变量temp = i;将初始值保留；i = i++;就是 i = 1; i = temp;也就是0；所以最后还是0，这道题很容易错。
4.下列说法错误的有（ ）
正确答案: A C D 你的答案: A C (错误)

在类方法中可用this来调用本类的类方法

在类方法中调用本类的类方法时可直接调用

在类方法中只能调用本类中的类方法

在类方法中绝对不能调用实例方法

分析：static方法是属于类的，没有对象，所以不能使用this，在类方法中也可以调用其他类的类方法；在类方法中可以使用创建对象的方式调用实例方法。
5. 有以下代码片段：

String str1=“hello”;

String str2=“he”+ new String(“llo”);

System.out.println(str1==str2);

请问输出的结果是：
正确答案: D 你的答案: A (错误)

true

都不对

null

false

分析：我把它当做字符串拼接，所以选了true，看了他人的分析："he"字符串是在常量池中的，而“llo”它是在堆中创建的，在编译时，jvm也不知道he+new String(“llo”)的引用地址，所以不会将地址赋给str2，所以str2指向的是堆内存中的hello;
6.下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader
正确答案: A B E 你的答案: A E (错误)

Thread

Number

Double

Math

ClassLoader

分析：Number类可以被继承，Integer，Float，Double等都继承自Number类 ；
通过继承ClassLoader，用户可以自定义类加载器，继承Thread，启动线程；
7.下面这段程序的输出结果是（）
public class Main {
public static void main(String[] args) {
split(12);
}
public static int split(int number) {
if (number > 1) {
if (number % 2 != 0)
System.out.print(split((number + 1) / 2));
System.out.print(split(number / 2));
}
return number;
}
}

正确答案: A 你的答案: D (错误)

12136

63121

61213

11236

分析：就是递归调用，过程如下：
split（12）{
split(6) = {
split(3) = {
split(2) = {
split(1)//输出1
return 2}//输出2

        //第二部分：
    split(1)//输出1
    return 3; 输出 3；
}
return 6 //输出6；

}
return 12 答案是这个并没有让打印输出；
} 最终结果为12136

12月25日

1. 在 applet 的方法中 , 可关闭小应用程序并释放其占用资源的是（ ）
   正确答案: D 你的答案: D (正确)

stop()

paint()

init()

destroy()
分析：init()方法是 Applet 运行的起点，初始化任务；stop()是让applet停止执行，destroy()方法是回收applet的所有资源；
2.ava中基本的编程单元为：
正确答案: A 你的答案: A (正确)

类

函数

变量

数据

分析：Java中基本的编程单元是类，我们写的函数，方法都是在一个类里面写的；Java中基本的存储单元是变量；
3. 类方法中可以直接调用对象变量？
正确答案: B 你的答案: B (正确)

正确

错误

分析：static静态方法中不能调用对象的变量，因为我们的静态方法是在类加载的时候初始化的，而对象变量需要在创建对象后才初始化，也就是静态方法初始化早于对象变量，而此时引用就会报错的。
4.下面程序的结果是
public class Demo {
public static String sRet = “”;
public static void func(int i)
{
try
{
if (i%2==0)
{
throw new Exception();
}
}
catch (Exception e)
{
sRet += “0”;
return;
}
finally
{
sRet += “1”;
}
sRet += “2”;
}
public static void main(String[] args)
{
func(1);
func(2);
System.out.println(sRet);
}
}

正确答案: B 你的答案: C (错误)

120

1201

12012

101
分析：1 % 2 ！= 0，所以执行finally语句及下面的代码，Sret = “12”; 2 % 2 = 0;会抛出异常，执行catch语句代码，Sret = “120”;由于下面一句为return语句，所以先执行finally中的代码，Sret =“1201” ，然后执行return语句，程序结束，输出结果为1201；
5.Java1.8之后，Java接口的修饰符可以为（）
正确答案: D 你的答案: D (正确)

private

protected

final

abstract

分析：接口是比抽象类还抽象的抽象类；它的内部只能是抽象方法，它存在的目的就是让所有public的类来实现它，所以ABC都错，都说是比抽象类还抽象的，那自然abstract可以使用了。
6.@SuppressWarnings(“deprecation”)的功能是什么？
正确答案: A 你的答案: C (错误)

屏蔽不赞同使用的类和方法的警告

屏蔽在强制类型转换的时候编译器给出的警告

关闭所有警告信息

当在可序列化的类上缺少serialVersionUID定义的警告

Override 注解
指明被注解的方法需要覆写超类中的方法.
如果某个方法使用了该注解,却没有覆写超类中的方法(比如大小写写错了,或者参数错了,或者是子类自己定义的方法),编译器就会生成一个错误.
Deprecated 注解
可以修饰类、方法、变量，在java源码中被@Deprecated修饰的类、方法、变量等表示不建议使用的，可能会出现错误的，可能以后会被删除的类、方法等，如果现在使用，则在以后使用了这些类、方法的程序在更新新的JDK、jar包等就会出错，不再提供支持。 个人程序中的类、方法、变量用@Deprecated修饰同样是不希望自己和别人在以后的时间再次使用此类、方法。 当编译器编译时遇到了使用@Deprecated修饰的类、方法、变量时会提示相应的警告信息。
Suppresswarnings 注解
可以达到抑制编译器编译时产生警告的目的，但是很不建议使用@SuppressWarnings注解，使用此注解，编码人员看不到编译时编译器提示的相应的警告，不能选择更好、更新的类、方法或者不能编写更规范的编码。同时后期更新JDK、jar包等源码时，使用@SuppressWarnings注解的代码可能受新的JDK、jar包代码的支持，出现错误，仍然需要修改。
抑制警告的关键字

12月26日

1. 一个抽象类并不需要其中所有的方法都是抽象的。（ ）
   正确答案: A 你的答案: A (正确)

正确

错误
分析：抽象类中是可以有非抽象方法，但如果一个类中有抽象方法，那这个类一定是抽象类；
2. 观察以下代码：

class Car extends Vehicle
{
public static void main (String[] args)
{
new Car(). run();
}
private final void run()
{
System. out. println (“Car”);
}
}
class Vehicle
{
private final void run()
{
System. out. println(“Vehicle”);
}
}

下列哪些针对代码运行结果的描述是正确的？
正确答案: A 你的答案: D (错误)

Car

Vehicle

Compiler error at line 3

Compiler error at line 5

Exception thrown at runtime

分析：final修饰的方法是不能被重写的，但是本题父类Vechicle的run()方法不进有final修饰，还有private修饰，private修饰的变量或是方法它对子类是不可见的。所以控制台输出Car；
3.下列哪种异常是检查型异常，需要在编写程序时声明？
正确答案: C 你的答案: C (正确)

NullPointerException

ClassCastException

FileNotFoundException

IndexOutOfBoundsException

分析：
4.以下JAVA程序的输出是什么（）
public class HelloSogou{
public static synchronized void main(String[] a){
Thread t=new Thread(){
public void run(){Sogou();}
};
t.run();
System.out.print(“Hello”);
}
static synchronized void Sogou(){
System.out.print(“Sogou”);
}
}
正确答案: B 你的答案: B (正确)

HelloSogou

SogouHello

Hello

结果不确定
分析：虽然创建了Thread对象并且实现了它的run()方法，但是并没有调用start()方法启动线程，所以就相当于调用了一个普通的run()方法，按代码顺序执行，所以先打印Sogou，再打印Hello；

调用main函数（一个线程），main函数开启另一个线程，并启动，但是main函数和Sogou方法是同一个锁，所以main函数执行完毕后才会释放锁，Sogou方法才会执行，这就是为什么，换成start，是HelloSogou。
第三，将Sogou方法的锁改为其他.class锁，那么，HelloSogou和SogouHello都可能出现。因为没有互斥现象了，变为抢占式的了。

5.若需要定义一个类，下列哪些修饰符是允许被使用的？（ ）
正确答案: A C D 你的答案: A C D (正确)

static

package

private

public

分析：B选项是包；内部类可以使用修饰成员变量的的访问修饰符；
6.以下哪个不能用来处理线程安全
正确答案: D 你的答案: D (正确)

synchronized关键字

volatile关键字

Lock类

transient关键字
分析：

7.已知String a=“a”,String b=“b”,String c=a+b,String d=new String(“ab”) 以下操作结果为true的是
正确答案: A D 你的答案: A B D (错误)

(a+b).equals©

a+b==c

c==d

c.equals(d)
分析： c = a+b 在堆中创建新的对象； new String()在堆中创建新的对象
8.jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些
正确答案: C D E 你的答案: B E (错误)

栈空间满

年轻代空间满

老年代满

持久代满

System.gc()

1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将触发Full GC。

9.类之间存在以下几种常见的关系：
正确答案: A B C 你的答案: B C (错误)

“USES-A”关系

“HAS-A”关系

“IS-A”关系

“INHERIT-A”关系

分析：is-a 继承；Has-a:聚合关系，动物可以分为水生，陆生动物等； users-a：依赖关系，表现为在A类中有的方法将B类作为参数；

12月28日

1. 有程序片段如下，以下表达式结果为 true 的是（ ）

Float s=new Float(0.1f);

Float t=new Float(0.1f);

Double u=new Double(0.1);
正确答案: B 你的答案: B (正确)

s==t

s.equals(t)

u.equals(s)

t.equals(u)

分析：s,t是Float包装类型，因为是new，所以是在堆中的两个对象；所以A错，我们的每个包装类型都重写了equals方法，首先判断是否是同一种类型，再判断值是否相等，所以选B；
2.在为传统面向对象语言的程序做单元测试的时候,经常用到mock对象。Mock对象通过反射数。请问反射最大程度破坏了面向对象的以下哪个特性？
正确答案: A 你的答案: A (正确)

封装

多态

继承

抽象
分析：Java因为有反射而强大，反射使得我们可以拿到原本私有的方法或者属性，破坏了Java的封装性；
3. 有如下4条语句：()
Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);
以下输出结果为false的是:
正确答案: C 你的答案: C (正确)

System.out.println(i01==i02);

System.out.println(i01==i03);

System.out.println(i03==i04);

System.out.println(i02==i04);

分析：首先：看下Integer.valueOf()底层；

public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.*[i + (-IntegerCache.low)];
return new Integer(i);
}
** 它有一个缓存的为-128-127；当值在这个范围内时，并不会去创建对象，会从常量池去拿；但是new是开辟一个内存空间，创建新的对象的；对于int与Integer类型比较时，比较的是值，Integer会自动拆箱；
4.下列哪项不属于jdk1.6垃圾收集器？
正确答案: D 你的答案: D (正确)

Serial收集器

parNew收集器

CMS收集器

G1收集器

1.Serial收集器
单线程收集器，收集时会暂停所有工作线程（我们将这件事情称之为Stop The World，下称STW），使用复制收集算法，虚拟机运行在Client模式时的默认新生代收集器。

2.ParNew收集器
ParNew 收集器就是Serial的多线程版本，除了使用多条收集线程外，其余行为包括算法、STW、对象分配规则、回收策略等都与Serial收集器一摸一样。对 应的这种收集器是虚拟机运行在Server模式的默认新生代收集器，在单CPU的环境中，ParNew收集器并不会比Serial收集器有更好的效果。

3.Parallel Scavenge收集器
Parallel Scavenge收集器（下称PS收集器）也是一个多线程收集器，也是使用复制算法，但它的对象分配规则与回收策略都与ParNew收集器有所不同，它是 以吞吐量最大化（即GC时间占总运行时间最小）为目标的收集器实现，它允许较长时间的STW换取总吞吐量最大化。

4.Serial Old收集器
Serial Old是单线程收集器，使用标记－整理算法，是老年代的收集器，上面三种都是使用在新生代收集器。

5.Parallel Old收集器
老年代版本吞吐量优先收集器，使用多线程和标记－整理算法，JVM 1.6提供，在此之前，新生代使用了PS收集器的话，老年代除Serial Old外别无选择，因为PS无法与CMS收集器配合工作。

6.CMS（Concurrent Mark Sweep）收集器
CMS 是一种以最短停顿时间为目标的收集器，使用CMS并不能达到GC效率最高（总体GC时间最小），但它能尽可能降低GC时服务的停顿时间，这一点对于实时或 者高交互性应用（譬如证券交易）来说至关重要，这类应用对于长时间STW一般是不可容忍的。CMS收集器使用的是标记－清除算法，也就是说它在运行期间会 产生空间碎片，所以虚拟机提供了参数开启CMS收集结束后再进行一次内存压缩。

5.以下描述正确的是
正确答案: B 你的答案: B (正确)

CallableStatement是PreparedStatement的父接口

PreparedStatement是CallableStatement的父接口

CallableStatement是Statement的父接口

PreparedStatement是Statement的父接口

分析：PreparedStatement 继承自Statement，防止SQL注入，CallableStatement继承自PreparedStatement，它是用于调用事物的；
6.关于sleep()和wait()，以下描述错误的一项是（ ）
正确答案: D 你的答案: D (正确)

sleep是线程类（Thread）的方法，wait是Object类的方法；

sleep不释放对象锁，wait放弃对象锁

sleep暂停线程、但监控状态仍然保持，结束后会自动恢复

wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态

分析：wait后，获得对象锁是notify和notifyAll；而且之后进入的是就绪状态；
7. 如下代码的输出结果是什么？

public class Test {
public int aMethod(){
static int i = 0;
i++;
return i;
}
public static void main(String args[]){
Test test = new Test();
test.aMethod();
int j = test.aMethod();
System.out.println(j);
}
}

正确答案: D 你的答案: B (错误)

0

1

2

编译失败
分析：静态变量是属于类的，所以不能在方法块中进行创建；
8.下面有关servlet的层级结构和常用的类，说法正确的有?
正确答案: A B C D 你的答案: B C (错误)

GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。

大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现

ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象

HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息

12月29日

1. 有以下程序片段，下列哪个选项不能插入到第一行 。（ ）。

2.public class A{

3.//do sth

4. }
   正确答案: A 你的答案: A (正确)

public class MainClass{ }

package mine;

class ANotherClass{ }

import java.util.*;

分析：一个Java文件下public修饰的类只能有一个；
2.下列程序执行后输出结果为（ ）
class BaseClass {
public BaseClass() {}

{
    System.out.println("I’m BaseClass class");
}

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

}

public class Base extends BaseClass {
public Base() {}

 {
     System.out.println("I’m Base class");
 }

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

 public static void main(String[] args) {
     new Base();
 }

}

正确答案: D 你的答案: D (正确)

static BaseClass
I’m BaseClass class
static Base
I’m Base class

I’m BaseClass class
I’m Base class
static BaseClass
static Base

I’m BaseClass class
static BaseClass
I’m Base class
static Base

static BaseClass
static Base
I’m BaseClass class
I’m Base class

分析：加载顺序：父类静态代码块》子类静态代码块》父类普通代码》父类构造代码块》子类普通代码块》子类构造函数
3.在开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运行时性能会变得更好。（）
正确答案: B 你的答案: B (正确)

正确

错误

泛型的优点
1，类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
2，消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
3，潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。

4.下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：( )
正确答案: A E 你的答案: A E (正确)

java.util.ConcurrentHashMap

java.util.Map

java.util.TreeMap

java.util.SortMap

java.util.Hashtable

java.util.HashMap

分析：hashtable concurrentHashMap synchronizedMap线程安全；
5. 下列说法正确的是（）？
正确答案: A B 你的答案: B D (错误)

对于局部内部类，只有在方法的局部变量被标记为final或局部变量是effctively final的，内部类才能使用它们

成员内部类位于外部类内部，可以直接调用外部类的所有方法（静态方法和非静态方法）

由于匿名内部类只能用在方法内部，所以匿名内部类的用法与局部内部类是一致的

静态内部类可以直接访问外部类的非静态成员

分析：

6.Java类Demo中存在方法func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( ）
public class Demo{

float func1()
　　{
　　　　int i=1;
　　　　return;
　　}
　　float func2()
　　{
　　　　short i=2;
　　　　return i;
　　}
　　float func3()
　　{
　　　　long i=3;
　　　　return i;
　　}
　　float func4()
　　{
　　　　double i=4;
　　　　return i;
　　}
}
正确答案: A D 你的答案: A C D (错误)

func1

func2

func3

func4

分析：A无返回值；这里要记住short->float ,long->float 不需要强制类型转换，float虽然是4个字节，但是它的最大值要比long类型范围要大；

12月30日

1. 关于容器下面说法正确的是？ ( )

正确答案: D 你的答案: D (正确)

列表(List)和集合(Set)存放的元素都是可重复的。

列表(List)和集合(Set)存放的元素都是不可重复的。

映射(Map)中key是可以重复的。

映射(Map)中value是可以重复的。

分析：List底层是数组，所以是有顺序的，set底层是hashMap，它是无序不可重复的， map 使用的是键值对存放，可一对多，key不重复，value可重复 ，它的底层是哈希表，即数组+链表，采用头插法；jdk1.8后增加了红黑树，采用尾插法；
2. 以下关于Object类的说法正确的是（）
正确答案: A 你的答案: A (正确)

Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。

Java中的接口(interface)也继承了Object类

利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。

如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。
分析：Object是所有类，接口的父类，无论是否明确指示；interface接口它是抽象的，如果他继承Object，那他就是一个类了，并且继承了的话它就会拥有Object的一些方法，如equals（），这和接口中（除static，default）都是抽象方法是相悖的；D选项会调用Object的equals（）；
3. 以下哪个事件会导致线程销毁？（）
正确答案: D 你的答案: D (正确)

调用方法sleep()

调用方法wait()

start()方法的执行结束

run()方法的执行结束
分析：start方法是启动线程，使其进入就绪状态，当获得cpu时间片，就用执行线程；run()方法是线程的具体逻辑，所以当它执行结束，线程就会结束。
4.下列说法正确的是( )
正确答案: C 你的答案: C (正确)

volatile,synchronized
都可以修改变量，方法以及代码块

volatile，synchronized 在多线程中都会存在阻塞问题

volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性

volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性

分析：volatile 修饰变量后,其保证了可见性，禁止指令重排序；Synchronized 保证可见性，原子性，它解决的是多线程之间资源同步问题；可以修饰变量，方法；所以多线程访问时，volatile不会造成阻塞，而synchronized会造成阻塞。
5.根据下面这个程序的内容，判断哪些描述是正确的：（ ）
public class Test {
public static void main(String args[]) {
String s = “tommy”;
Object o = s;
sayHello(o); //语句1
sayHello(s); //语句2
}
public static void sayHello(String to) {
System.out.println(String.format(“Hello, %s”, to));
}
public static void sayHello(Object to) {
System.out.println(String.format(“Welcome, %s”, to));
}
}

正确答案: C D 你的答案: C D (正确)

这段程序有编译错误

语句1输出为:Hello, tommy

语句2输出为:Hello, tommy

语句1输出为:Welcome, tommy

语句2输出为:Welcome, tommy

根据选用的Java编译器不同，这段程序的输出可能不同

分析：s,m指向的是同一个字符串tommy,两个sayHello方法参数类型不同，语句1传入的是Object类型，所以打印welcome，tommy;这个题主要在于String类型，因为String的Object的子类，当出现二义性，我们匹配最符合的；
6. Hashtable 和 HashMap 的区别是：
正确答案: B C D E 你的答案: B C E (错误)

Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口

HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口

Hashtable 线程安全的，而 HashMap 是线程不安全的

Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类

HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

分析：Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。

12月31日

1.如下代码，执行test()函数后，屏幕打印结果为（）
public class Test2
{
public void add(Byte b)
{
b = b++;
}
public void test()
{
Byte a = 127;
Byte b = 127;
add(++a);
System.out.print(a + " ");
add(b);
System.out.print(b + “”);
}
}

正确答案: D 你的答案: B (错误)

127 127

128 127

129 128

以上都不对

分析：
包装类的值都是final 不可变的，对于++b 或者b++ ，只是新创建了一个对象，然后把引用传给了原对象语句，在函数中操作，只是形参的临时语句改变了指向，实参的语句还是指向原来的对象。所以即使是b = b++ 这种，b的值在add之后也是不会变的。
2.Which statement is true for the class java.util.ArrayList?
正确答案: A 你的答案: B (错误)

The elements in the collection are ordered.

The collection is guaranteed to be immutable.

The elements in the collection are guaranteed to be unique.

The elements in the collection are accessed using a unique key.

The elements in the collections are guaranteed to be synchronized.

3. 以下代码将打印出
   1
   2
   3
   4

public static void main (String[] args) {
String classFile = “com.jd.”. replaceAll(".", “/”) + “MyClass.class”;
System.out.println(classFile);
}
正确答案: C 你的答案: B (错误)

com. jd

com/jd/MyClass.class

///MyClass.class

com.jd.MyClass

分析：我们要知道replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果只是想替换的只是"."，那么就要写成"\."。
4.在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）；当N=9时呢？
正确答案: B C 你的答案: B D (错误)

11

144

55

89

分析：因为你一次只能爬1或者2阶，所以，对于11层的楼，我们设一个函数f(n),则有f(11) = f(10) + f(9);两种情况；f(10) = f(9) + f(8)…以此类推；故有f(1) = 1;f(2)=2;f(3) = 3;f(4) = 5;f(5)=8;f(6) =13;f(7) = 21;f(8) = 34;f(9)=55;f(10)=89;f(11)=144;
5.Java语言中，下面哪个语句是创建数组的正确语句？( )
正确答案: A B D E 你的答案: A D E (错误)

float f[][] = new float[6][6];

float []f[] = new float[6][6];

float f[][] = new float[][6];

float [][]f = new float[6][6];

float [][]f = new float[6][];

分析：无语。
6.jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些
正确答案: C D E 你的答案: C D E (正确)

栈空间满

年轻代空间满

老年代满

持久代满

System.gc()