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)?:计算方向:从右到左