1.下面的程序 编译运行后，在屏幕上显示的结果是（A）

public class test {
    
	public static void main(String args[]) {
    
		int x,y;
		x=5>>2;
		y=x>>>2;
		System.out.println(y);
	}
}

A 0
B 2
C 5
D 80
解析：
右移运算符（>>），num >> 1,相当于num除以2。无符号右移（>>>），忽略符号位，空位都以0补齐。
5的二进制位0101，右移两位为0001等于1,1在无符号右移2为，结果为0。

2.以下代码结果是什么？（C）

public class foo {
    
	public static void main(String sgf[]) {
    
		StringBuffer a=new StringBuffer(“A”);
		StringBuffer b=new StringBuffer(“B”);
		operate(a,b);
		System.out.println(a+”.”+b);
	}
	static void operate(StringBuffer x,StringBuffer y) {
    
		x.append(y);
		y=x;
	}
}

A 代码可以编译运行，输出“AB.AB”。
B 代码可以编译运行，输出“A.A”。
C 代码可以编译运行，输出“AB.B”。
D代码可以编译运行，输出“A.B”。
解析：

引用a指向对象A，引用b指向对象B，引用x指向对象A，引用y指向对象B。在operate方法中，引用x指向的对象A被连接了B，对象A也就被改变为AB。然后又把引用y指向了x所指向的对象地址，也就是此时引用a,x,y指向同一个对象AB，而引用b没有发生任何变化，依旧指向对象B。

3.在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（B）
A this.A(x)
B this(x)
C super(x)
D A(x)
解析：
A选项：是调用普通方法的格式
C选项：为调用父类构造方法的格式
D选项：为调用静态方法的格式

4.下面代码的运行结果是（C）

public static void main(String[] args){
    
	String s;
	System.out.println("s="+s);
}

A 代码编程成功，并输出”s=”
B 代码编译成功，并输出”s=null”
C 由于String s没有初始化，代码不能编译通过。
D 代码编译成功，但捕获到NullPointException异常

5.装箱、拆箱操作发生在:
A 类与对象之间
B 对象与对象之间
C 引用类型与值类型之间
D 引用类型与引用类型之间
解析：
通俗的讲，就是基本数据类型和包装类之间的转换。如： int 类型和 Integer 类的转换 基本数据类型转化成包装类是装箱 (如： int --> Integer)。 包装类转化成基本数据类型就是拆箱 (如：Integer --> int)。 包装类就是引用类型，基本数据类型就是值类型。所以选C。

6.一个以”.java”为后缀的源文件（C）
A 只能包含一个类，类名必须与文件名相同
B 只能包含与文件名相同的类以及其中的内部类
C 只能有一个与文件名相同的public类，可以包含其他类
D 可以包含任意类

7.下列哪个说法是正确的（D）
A ConcurrentHashMap使用synchronized关键字保证线程安全
B HashMap实现了Collction接口
C Array.asList方法返回java.util.ArrayList对象
D SimpleDateFormat是线程不安全的
解析：
concurrentHashMap采用分段加锁的机制来确保安全。HashMap实现了Map接口。Arrays.asList()将一个数组转化为一个List对象，这个方***返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的静态内部类！用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。

8.以下说法错误的是（D）
A 虚拟机中没有泛型，只有普通类和普通方法
B 所有泛型类的类型参数在编译时都会被擦除
C 创建泛型对象时请指明类型，让编译器尽早的做参数检查
D 泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型
解析：
运用泛型编译器不建议使用raw原生类型，而是要指明具体类型List，以便编译器作参数检查。在编译阶段会采取擦除机制，将所有的泛型都编译成为原生类型List,因为虚拟机中没有泛型，只有普通类和普通方法。JVM是通过强大的反射机制获取具体类型的，也正因为有了反射才促生了泛型，所以D错。

9.下列代码执行结果为（A）

public static void main(String args[])throws InterruptedException{
    
	Thread t=new Thread(new Runnable() {
    
		public void run() {
    
			try {
    
				Thread.sleep(2000);
			} catch (InterruptedException e) {
    
				throw new RuntimeException(e);
			}
				System.out.print("2");
		}
	});
	t.start();
	t.join();
	System.out.print("1");
}

A 21
B 12
C 可能为12，也可能为21
D 以上答案都不对
解析：
join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

10.指出以下程序运行的结果是（B）

public class Example{
    
	String str=new String("good");
	char[]ch={
    'a','b','c'};
	public static void main(String args[]){
    
		Example ex=new Example();
		ex.change(ex.str,ex.ch);
		System.out.print(ex.str+" and ");
		System.out.print(ex.ch);
	}
	public void change(String str,char ch[]){
    
	//引用类型变量，传递的是地址，属于引用传递。
		str="test ok";
		ch[0]='g';
	}
}

A good and abc
B good and gbc
C test ok and abc
D test ok and gbc

11.下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：（B）

byte[] src,dst;

A dst=String.frombytes(src,”GBK”).getbytes(“UTF-8”)
B dst=new String (src,”GBK”).getbytes(“UTF-8”)
C dst=new String (”GBK”, src,) getbytes()
D dst=String.encode(String.decode(src,”GBK”)), “UTF-8”)
解析：
操作步骤是先解码再编码：用new String(src，“GBK”)解码得到字符串，再用getBytes(“UTF-8”)得到UTF8编码字节数组。

12.下列关于java并发的说法中正确的是：（B）
A copyonwritearraylist适用于写多读少的并发场景
B readwritelock适用于读多写少的并发场景
C concurrenthashmap的写操作不需要加锁，读操作需要加锁
D 只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了
解析：
A选项：CopyOnWriteArrayList适用于写少读多的并发场景
B选项：ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，读与读之间可以并发执行。在读多写少的情况下可以提高效率
C选项：ConcurrentHashMap是同步的HashMap，读写都加锁
D选项：volatile只保证多线程操作的可见性，不保证原子性

13.Java中的集合类包括ArrayList、LinkedList、HashMap等，下列关于集合类描述错误的是？（C）
A ArrayList和LinkedList均实现了List接口
B ArrayList的访问速度比LinkedList快
C 随机添加和删除元素时，ArrayList的表现更佳
D HashMap实现Map接口，它允许任何类型的键和值对象

14.下列哪个对访问修饰符作用范围由大到小排列是正确的？（D）
A private>default>protected>public
B public>default>protected>private
C private>protected>default>public
D public>protected>default>private
解析：

15.在Java中，HashMap中是用哪些方法来解决哈希冲突的？（C） 我觉得答案应该为（AC）
A 开放地址法
B 二次哈希法
C 链地址法
D 建立一个公共溢出区
解析：
（1）开放地址法:寻找下一个为空的数组下标,而后将冲突元素存储
（2）再散列法(二次哈希法):再次使用一个不同的哈希算法再计算一次 (第一次%16换另一个数进行%运算)
（3）链地址法(拉链法):将所有冲突元素按照链表存储,冲突后时间复杂度变为O(1+n)n为冲突元素个数)[hashMap就是用这种方法]

16.阅读下列程序，选择哪一个是正确的输出结果（C）

class HelloA{
    
	public HelloA()
	{
    
		System.out.println("I’m A class ");
	}
	static
	{
    
		System.out.println("static A");
	}
}
public class HelloB extends HelloA{
    
	public HelloB()
	{
    
		System.out.println("I’m B class");
	}
	static{
    
		System.out.println("static B");
	}
	public static void main (String[] args){
    
		new HelloB();
	}
}

A static A I’m A class static B I’m B class
B I’m A class I’m B class static A static B
C static A static B I’m A class I’m B class
D I’m A class static A I’m B class static B
解析：
打印顺序：父类的静态方法，子类的静态方法，父类的构造方法，父类的实例方法，
子类的构造方法，子类的实例方法

17.执行下列代码的输出结果是（C）

public class Demo{
    
　public static void main(String args[]){
    
　　　int num = 10;
　　　System.out.println(test(num));
}
public static int test(int b){
    
　　　try
　　　{
    
　　　　b += 10;
　　　　return b;
　　　}
　　　catch(RuntimeException e)
　　　{
    
　　　}
　　　catch(Exception e2)
　　　{
    
　　　}
　　　finally
　　　{
    
　　　　b += 10;
　　　　return b;
　　　}
　　}
}

A 10
B 20
C 30
D 40
解析：
finally块中的return会抑制try中的return。该题先执行try中的b+=10，在执行finally中的b+=10，最后执行finally中的return，故打印值为30.

18.以下是java concurrent包下的4个类，选出差别最大的一个（C）
A Semaphore
B ReentrantLock
C Future
D CountDownLatch
解析：
A选项：Semaphore：类，控制某个资源可被同时访问的个数;
B选项：ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C选项：Future：接口，表示异步计算的结果；
D选项： CountDownLatch： 类，可以用来在一个线程中等待多个线程完成任务的类。

19.关于sleep和wait,以下描述错误的是（D）
A sleep是线程类的方法，wait是object的方法
B sleep不释放对象锁，wait放弃对象锁
C sleep暂停线程，但监控状态依然保持，结束后会自动恢复
D wait进入等待锁定池，只有针对此对象发出notify方法获得对象锁进入运行状态
解析：
首先，sleep()是Thread类中的方法，而wait()则是Object类中的方法。
（1）sleep()方法导致了程序暂停，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。
（2）wait()方法导致线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。注意是准备获取对象锁进入运行状态，而不是立即获得

20.下列代码的输出结果是（B）

boolean b=true?false:true==true?false:true;
System.out.println(b);

A true
B false
C null
D 空字符串
解析：
（1）==优先级大于?:
（2）?:计算方向：从右到左