每日一题Day9

1.下面程序的输出是:()

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

答案：Fmnwxy

解析：x.toUpperCase();该方法是将小写字母转换为大写，在这里并没有改变x的内容，后边就是字符串的替换和拼接。

2. 以下多线程对int型变量x的操作,哪个不需要进行同步(D)

A ++x
B x=y
C x++
D x=1

解析：

A.由于y的值不确定，所以要加锁；

B,C 两个在多线程情况下是必须要加锁的，因为他们是先被读入寄存器，然后再进行+1操作，如果没有加锁，那么可能会出现数据异常；

D 原子操作，所以不需要加锁

    原子性：指该操作不能再继续划分为更小的操作。

    Java中的原子操作包括：     

        1、除long和double之外的基本类型的赋值操作

        2、所有引用reference的赋值操作

        3、java.concurrent.Atomic.* 包中所有类的一切操作

3. 关于 JAVA 堆,下面说法错误的是(D)

A 所有类的实例和数组都是在堆上分配内存的
B 对象所占的堆内存是由自动内存管理系统回收
C 堆内存由存活和死亡的对象,空闲碎片区组成
D 数组是分配在栈中的

解析：

一句话解决：数组是对象，所有对象存储在堆内存中，而基本数据类型存储在栈内存中。

Java 把内存划分成两种：一种是栈内存，另一种是堆内存。

栈式存储：
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。
优点：存取速度比堆要快，仅次于寄存器，栈数据可以共享。
缺点：存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量(,int, short, long, byte, float, double, boolean, char)和对象句柄。

堆式存储：
堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。
优点：堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。
缺点是：由于要在运行时动态分配内存，存取速度较慢。

4. 一个以“.java”为后缀的源文件（C）

A 只能包含一个public类，类名必须与文件名相同
B 只能包含与文件名相同的public类以及其中的内部类

C 只能有一个与文件名相同的public类，可以包含其他非public类（不考虑内部类）
D 可以包含任意public类

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

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

解析：

for循环逐一复制：这个应该是比较慢的。

System.arraycopy( )：查看源码，可知 public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);

Arrays.copyof( )：本质上调用的是arraycopy( )方法，所以效率上肯定比System.arraycopy( )要低。

Clone( )方法：查看源码可知，protected native Object clone() throws CloneNotSupportedException；可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。但是返回的是Object类型，需要强制转换。 一般用clone效率是最差的。

6. 下面那些情况可以终止当前线程的运行？（B）

A 当一个优先级高的线程进入就绪状态时
B 抛出一个异常时
C 当该线程调用sleep()方法时
D 当创建一个新线程时

7.对文件名为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);
}
}

A 输出：0000
B 输出：123
C 编译报错
D 输出：No name

解析：不管你用什么语言，构造函数带传参，就是说该类被创建时需要参数进行初始化，如果不给就无法编译。

那么如果一个子类继承了一个父类，父类具有参数构造函数，子类有责任将参数传递给父类，以便父类初始化。

因为你new的时候new的不是父类，无法直接给予参数，你new的是子类，所以子类必须也同时具有带参数的构造函数，以便将参数传递给父类。

8.有关下述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只是迷惑大家的跟它没有什么关系。

    这里 ((TestClass)null).testMethod();也可以写成TestClass t = null; t.testMethod();同样可以正确输出。null可以被强制转换成任意类型对象，虽然这个时候t被赋为了空，但这个“空对象”也是属于TestClass的，那么这个“空对象”也就可以去堆上的静态方法区调用testMethod()方法了。

    如果这里testMethod把static去掉，该testMethod方法就变成了实例对象的方法了。这时，可以编译通过，但是会报空指针。

9.下列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

解析：字符串是一种不可变对象. 它的内容不可改变.String 类的内部实现也是基于 char[] 来实现的, 但是 String 类并没有提供 set 方法之类的来修改内部的字符数组

10.在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 程序无法执行

解析：

1、==需要看情况，得看比较的是基本数据类型还是引用数据类型 1、若是比较的是基本数据类型，直接看值，若是值在【-128，127】且相等，则比较相等；若值不在【-128，127】或者两个数的值不相等，则比较为不等。
2、若是比较的是引用数据类型（比如new与new）（或者new 与 基本数据类型），即使值相等，也会比较为不相等。

3、equals比较是值，只要值相等即可