选择习题集

一、
1、下面哪段程序能够正确的实现了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”)解码得到原字符串
再使用.getbyte(“UTF-8”)得到UTF8的编码的字节数组

2、下列关于java并发的说法中正确的是：B
A：copyonwritearraylist适用于写多读少的并发场景
B：readwritelock适用于读多写少的并发场景
C：concurrenthashmap的写操作不需要加锁，读操作需要加锁
D：只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

copyonwritearraylist适用于写少读多的情况
readwritelock是读写锁，要求写与写之间互斥，读与写之间互斥，读与读之间可以并发执行。在读多写少的情况下可以提高效率。
concurrenthashmap是同步的HashMap，读写都加锁
volatile只能保证多线程操作的可见性，不能保证原子性

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

4、在Java中，HashMap中是用哪些方法来解决哈希冲突的？C
A：开放地址法
B：二次哈希法
C：链地址法
D：建立一个公共溢出区

5、阅读下列程序，选择哪一个是正确的输出结果 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

类的初始化顺序：
a.初始化父类中的静态成员方法和静态代码块
b.初始化子类中的静态成员方法和静态代码块
c.初始化父类中的普通成员方法和代码块，再执行父类中的构造方法
d.初始化子类中的普通成员方法和代码块，再执行字类中的构造方法

6、以下是java concurrent包下的4个类，选出差别最大的一个 C
A：Semaphore
B：ReentrantLock
C：Future
D：CountDownLatch

Semaphore：类，控制某个资源可悲同时访问的个数
ReentrantLock：类，具有与使用synchronized方法和语句锁访问的隐式监视器相同的一些基本行为和语义，但功能更强大
Future：接口，表示异步计算的结果
CountDownLatch：类，可以用来再一个线程中等待多线程完成任务的类

7、关于sleep和wait,以下描述错误的是 D
A：sleep是线程类的方法，wait是object的方法
B：sleep不释放对象锁，wait放弃对象锁
C：sleep暂停线程，但监控状态依然保持，结束后会自动恢复
D：wait进入等待锁定池，只有针对此对象发出notify方法获得对象锁进入运行状态

sleep()是Thread类中的方法，wait是object类中的方法
sleep()方法会导致线程暂停，但是他的监控状态依然保持着，当指定的时间到了之后就会自动回复运行状态，并且在调用sleep()方法的时候线程是不会去释放锁的。
wait()方法导致线程放弃对象锁，进入等待次对象的等待锁定池，只有针对此对象调用了notify()方法后该线程才会进入到对象锁定池准备获取对象锁进入到运行状态。

二、
1、 Math.round(11.5) 等于：C
A：11
B：11.5
C：12
D：12.5

floor：意为地板，指向下取整，返回不大于他的最大整数
ceil：意为天花板，指向上取整，返回不小于他的最小整数
round：意为大约，表示“四舍五入”，Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整。

2、以下 D_ 不是 Object 类的方法
A：clone（）
B：finalize()
C：toString()
D：hasNext()

Object类中没有hasNext（）方法，这是迭代器的方法。
Object类中没有copy方法，但是有clone()方法。

三、
1、java中关于内存回收的正确说法是：B
A：程序员必须创建一个线程来释放内存
B：内存回收程序负责释放无用内存
C：内存回收程序允许程序员直接释放内存
D：内存回收程序可以在指定的时间释放内存对象

A、有GC线程，不用程序员自己创建
C、java中内存回收由GC线程来完成，程序员不能直接释放，只能通过System.gc()提醒GC进行垃圾回收
D、只能用System.gc提醒，不能指定时间

2、A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：

A a0=new A();
A a1=new B();
A a2=new C();

以下哪个说法是正确的？A
A：第1行，第2行和第3行的声明都是正确的
B：第1,2,3行都能通过编译，但第2,3行运行时出错
C：第1,2行能通过编译，但第3行编译出错
D：只有第1行能通过编译

java中，继承具有传递性，也可以成为间接继承。

3、Test.main() 函数执行后的输出是D

public class Test {  
	public static void main(String [] args){  
		System.out.println(new B().getValue());  
	}  
	static class A{  
		protected int value;  
		public A(int v) {  
			setValue(v);  
		}  
		public void setValue(int value){  
			this.value = value;  
		}  
		public int getValue(){  
			try{  
				value++;  
				return value;  
			} catch(Exception e){  
				System.out.println(e.toString());  
			} finally {  
				this.setValue(value);  
				System.out.println(value);  
			}  
			return value;  
		}  
	}  
	static class B extends A{  
		public B() {  
			super(5);  
			setValue(getValue() - 3);  
		}  
		public void setValue(int value){  
			super.setValue(2 * value);  
		}  
	} 
}

A：11 17 34
B：22 74 74
C：6 7 7
D：22 34 17

这个题考虑的是java中多态的理解，在执行对象实例化的过程中遵循多态的特性，调用的方法都是将要实例化的子类中的重写方法，只有明确调用super关键字或者子类中没有的方法时，才会去调用父类相同的同名方法。

第一步：new B（）

B的构造函数中super(5)直接调用父类A带参数的构造方法，该构造方法调用setValue(v),虽然这个构造函数时A的构造函数，但是需要注意这里实例化的是B，B中是有setValue方法的，因此调用B中的setValue方法。而B中的setValue()方法又调用了父类的setValue()方法，此时B实例的value值是2*5=10。

下面调用B的构造方法中的第二行。先执行getValue()方法，B中没有这个方法，就调用父类的getValue()方法，这个方法需要分成几步：
（1）调用getValue方法，现在B的成员变量的value值是10.
（2）value++之后，value值变为了11，此时开始执行return语句，将11这个值作为getValue方法的返回值返回出去。
（3）因为又finally语句，所以上一步的11先暂时存起来，等finally全部执行完之后再返回。
（4）finally中的this.setValue(value); 调用的是该对象的setValue方法，也就是B的setValue方法，而B的setValue方法，又显示调用了A的setValue方法，将B的value值设为了 2*11=22.
（5）执行finally中的第二行打印，第一个打印就是22
（6）finally执行完毕之后，会把刚刚暂时存起来的11返回出去，也就是getValue的返回值是11.

B的构造方法的第二行setValue(getValue() - 3);最终结果是setValue（11-3）=》setValue(8)
B的setValue方法会将value值变为2*8=16

第二步：new B().getValue()

B中没有getValue方法，因此调用getValue方法。
（1）调用getValue方法之前，value值为16.
（2）value++之后，value为17，17暂时先做返回值返回出去。
（3）finally中的语句调用该对象的setValue方法，也就是B的setValue方法，而B的setValue方法，又显示调用了A的setValue方法，将B的value值设为了 2*17=34.
（4）第二个打印34
（5）finally执行完毕，将刚才的17返回出去。

第三步：System.out.println(new B().getValue());

刚才最终是将17返回出去，因此第三个打印的是17

四、
1、下面程序的输出是:(D)

String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);

A：FmNwxy
B：fmnwxy
C：wxyfmn
D：Fmnwxy

toUpperCase():把字符串中所有的字母都改为大写
toLowerCase()：把字符串中所有的字母改为小写
第一行：fmn是在常量池中的不可变对象
第二行：在堆中new一个FMN对象，但是没有引用指向它
第三行：在堆中new一个Fmn对象，y指向它
第四行：在堆中重新new一个Fmnwxy对象，y指向它

2、 JAVA语言的下面几种数组复制方法中，哪个效率最高？B

A：for循环逐一复制
B：System.arraycopy
C：Arrays.copyOf
D：使用clone方法

System.arraycopy>clone>Arrays.copyOf>for循环
System类源码中有arraycopy方法，是native方法，本地方法，所以是效率最高的。
Arrays.copyOf源码中调用了System.arraycopy

3、有关下述Java代码描述正确的选项是F

public class TestClass { 
	private static void testMethod(){ 
		System.out.println("testMethod"); 
	} 
	public static void main(String[] args) { 
		((TestClass)null).testMethod(); 
	}
}

A：编译不通过
B：编译通过，运行异常，报NullPointerException
C：编译通过，运行异常，报IllegalArgumentException
D：编译通过，运行异常，报NoSuchMethodException
E：编译通过，运行异常，报Exception
F：运行正常，输出testMethod

这个题是类对方法的调用，直接使用类名来调用，不依赖于对象是否被创建，null可以被强制类型转换成任意类型

这个题还没搞懂
4、下列java程序的输出结果为B

public class Example{ 
	String str=new String("hello"); 
	char[]ch={'a','b'}; 
	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]='c'; 
	}
}

A：hello and ab
B：hello and cb
C：hello and a
D：test ok and ab
E：test ok and cb
F：test ok and c

5、在jdk1.5之后，下列 java 程序输出结果为

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

A：true,false
B：true,true
C：false,true
D：false,false
E：对于不同的环境结果不同F程序无法执行

这是一个自动拆装箱的问题（需要在jdk1.5之后）
基本类型和封装类型进行“==”运算，封装类型会自动拆箱变成基本类型再进行比较
两个基本类型进行equals比较，首先会比较类型，类型相同再比较值
封装类型调用equals，参数是基本类型，会先自动装箱，再比较

五、
1、 下面代码运行结果是：C

public class Test{  
	public int add(int a,int b){  
		try {  
			return a+b;  
		}catch (Exception e) {  
			System.out.println("catch语句块");  
		}finally{  
			System.out.println("finally语句块");  
		}  
		return 0;  
	}  
	public static void main(String argv[]){  
		Test test =new Test();  
		System.out.println("和是："+test.add(9, 34));  
	}
}

A：catch语句块 和是：43
B：编译异常
C：finally语句块 和是：43
D：和是：43 finally语句块

finally块不论在任何情况下，都会被执行的。
但是finally是在returna+b的代码块之后执行的，此时这里计算的a+b的值并没有返回，而是先把要返回的值保存起来，所以不论finally中的代码块是什么都不会影响这个返回值了，执行完finally中的代码之后就可以将保存的值返回。而finally中有了return方法，程序就会提前退出

2、下列Java代码中的变量a、b、c分别在内存的__C__存储区存放。

class A { 
	private String a = “aa”; 
	public boolean methodB() { 
		String b = “bb”; 
		final String c = “cc”; 
	}
}

A：堆区、堆区、堆区
B：堆区、栈区、堆区
C：堆区、栈区、栈区
D：堆区、堆区、栈区
E：静态区、栈区、堆区
F：静态区、栈区、栈区

堆：new创建的对象、成员变量
方法区：加载好的类、静态方法
栈：局部变量

3、以下声明合法的是
A：default String s
B：public final static native int w( )
C：abstract double d
D：abstract final double hyperbolicCosine( )

default不可以修饰属性
abstract不可以修饰属性
abstract修饰方法时，不可以使用final
所修饰，抽象类主要用来被继承，final修饰之后就不可以重写该方法了

4、代码片段：

byte b1=1,b2=2,b3,b6; 
final byte b4=4,b5=6; 
b6=b4+b5; 
b3=(b1+b2); 
System.out.println(b3+b6);

关于上面代码片段叙述正确的是C
A：输出结果：13
B：语句：b6=b4+b5编译出错
C：语句：b3=b1+b2编译出错
D：运行期抛出异常

被final修饰的变量是常量，计算是会被jvm进行优化
b6=b4+b5在编译时就已经变成了b6=10了
b1、b2是byte类型，java中在进行计算的时候会自动进行类型提升，变成int类型，再计算b1+b2在计算后就变成了int类型，赋值给b3，而b3是byte类型，会发生类型不匹配，编译不通过，需要进行强制类型转换
java中byte、short、char进行计算时都会提升为int