Java选择01

1.Math.round(11.5) 等于多少()Math.round(-11.5) 等于多少 ( C ).
A 11 ,-11
B 11 ,-12
C 12 ,-11
D 12 ,-12

解析：Math.round(int value)方法是value + 0.5 然后向下取整。比如：value = 11.5; 11.5 + 0.5 = 12所以结果就是12

2.阅读如下代码。 请问，对语句行 test.hello().描述正确的有（A）

package NowCoder;
class Test {
public static void hello() {
System.out.println("hello");
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}

A 能编译通过，并正确运行
B 因为使用了未初始化的变量，所以不能编译通过
C 以错误的方式访问了静态方法
D 能编译通过，但因变量为null，不能正常运行

解析：这里Test test = null;指的是该对象在堆上没有进行实例化，只是创建了一个Test类型的引用。但是因为hello()为static类型的，所以可以直接调用，不需要进行实例化。

3.如下代码的输出结果是什么？D

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);
}
}

A 0
B 1
C 2
D 编译失败

解析：java中静态变量只能在类主体中定义，不能在方法中定义；那能在静态方法中定义吗？答案是不能，因为静态是属于类的，而普通是属于对象的，在一个方法中的变量只是临时变量，而声明一个静态变量就会变成一个属于类的，所以不能声明为static

4.以下代码运行输出的是C

public class Person{
private String name = "Person";
int age=0;
}
public class Child extends Person{
public String grade;
public static void main(String[] args){
Person p = new Child();
System.out.println(p.name);
}
}

A 输出：Person
B 没有输出
C 编译出错
D 运行出错

解析：一个java文件中只能有一个public类，并且子类继承父类，只能在内部使用父类的私有成员，不能访问，

5.以下程序的输出结果为D

class Base{
public Base(String s){
System.out.print("B");
}
}
public class Derived extends Base{
public Derived (String s) {
System.out.print("D");
}
public static void main(String[] args){
new Derived("C");
}
}

A BD
B DB
C C
D 编译错误

解析：子类调用构造前，先调用父类构造。一般默认调用父类无参构造，当父类重写了构造方法后，如果重写的构造中存在无参构造则还是可以直接默认调用，如果重写的构造中只有有参构造，那么就需要在子类构造方法中使用super()去指定调用父类的构造。

6.下面的程序 编译运行后，在屏幕上显示的结果是（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

解析：5的二进制为0101, >>为二进制按位右移，5 >> 2 结果为0001，>>>为无符号右移，左边空缺补0，x >>> 2结果为0；

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

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

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

解析：类中成员变量可以不初始化，会有默认初始值。而方法中的局部变量必须初始化，否则编译不通过。

8.java语言的下面几种数组复制方法中，哪个效率最高？B
A for 循环逐一复制
B System.arraycopy
C Array.copyOf
D 使用clone方法

解析：效率：System.arraycopy > clone > Array.copyOf > for循环
A.for循环，效率最低
B.System.arraycopy：原型是调用底层native方法public static native void arraycopy(Object src, int srcPos , Object dest, int destPos, int length);
C.Arrays.copyOf底层调用了上面的System.copeOf所以效率比上面两个低
以上都是从牛客大佬的解析中理解的，但是他们大多数说的都是自己编写代码测出来的效率。

9.在java7中,下列哪个说法是正确的:D
A ConcurrentHashMap使用synchronized关键字保证线程安全
B HashMap实现了Collction接口
C Array.asList方法返回java.util.ArrayList对象
D SimpleDateFormat是线程不安全的

解析：
A：1.7中ConcurrentHashMap使用Segment来分段和管理锁，Segment继承自ReentrankLock,因此ConcurrentHashMap使用ReentrankLock来保护线程安全。在1.8以后ConcurrentHashMap取消了segment分段锁，采用CAS+synchronized来保证并发安全，数据结构和hashmap1.8类似，是数组+链表或红黑树实现的。
B:HashMap继承了AbstractMap，AbstractMap实现了Map接口。和Collection接口没什么关系
C:Array.asList方法返回的是当前List的实现类java.util.Arrays.ArrayList这个类（而不是java.util.ArrayLisy)
D:
public abstract class Format extends Object implements Serializable, Cloneable
public abstract class DateFormat extends Format
public class SimpleDateFormat extends DateFormat
可以看出SimpleDateFormate方法都不是Synchronized的，也没有采用其他的同步措施。

10.下面哪段程序能够正确的实现了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(sre,“GBK”)解码得到字符串

用getBytes(“UTF-8”)得到UTF-8编码字节数组

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

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

解析：以上方法都是可以用来解决哈希冲突的策略，但是在java.util.HashMap中，使用的是链地址法。
HashMap底层是数组+链表/红黑树实现的，在put方法中根据key的hash值找到对应的位置。

1.当前hash指向的数组为空，则直接将键值对以链表的形式插入；
2.当hash指向的数组已经存在数，则判断当前数组中对应的是链表还是红黑树，然后根据指定方法插入。如果是链表插入到最后一个，判断链表长度是否大于8，大于8将链表转成红黑树

使用链地址法会导致get的效率从O(1)降至O(n)，所以底层使用红黑树来提高效率。

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

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

A true
B false
C null
D 空字符串

解析：boolean b=true?false:true== true?false:true; //true直接成立，后面的false:true==true?false:true不执行。

可以测试一下

	    int i = 1;
        int j = 1;
        boolean a = true ? false : ++i == 2 ? false :true;
        boolean b = false ? true : ++j == 2 ? false : true;
        System.out.println("a:" + a + ",i:" + i);
        System.out.println("b:" + b + ",j:" + j);

运行结果：
a:false,i:1
b:false,j:2