每日10题

1final方法等同于private方法。（ ）
A.正确
B.错误
2.下面输出结果为

public class EqualsMethod
{
    public static void main(String[] args)
    {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.print(n1 == n2);
        System.out.print(",");
        System.out.println(n1 != n2);
    }
}

3.下面有关java hashmap的说法错误的是？
A.HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。
B.HashMap 的实现不是同步的，意味着它不是线程安全的
C.HashMap通过开放地址法解决哈希冲突
D.HashMap中的key-value都是存储在Entry数组中的
4.Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法是Collection接口所定义的（ ）
A.int size()
B.boolean containsAll(Collection c)
C.compareTo(Object obj)
D.boolean remove(Object obj)
5.下列流当中，属于处理流的是：（）
A.FilelnputStream
B.lnputStream
C.DatalnputStream
D.BufferedlnputStream
6.When is the text “Hi there” displayed?

public class StaticTest
{
    static
    {
        System.out.println("Hi there");
    }

    public void print()
    {
        System.out.println("Hello");
    }

    public static void main(String args[])
    {
        StaticTest st1 = new StaticTest();
        st1.print();
        StaticTest st2 = new StaticTest();
        st2.print();
    }
}

A.Never.
B.Each time a new object of type StaticTest is created.
C.Once when the class is loaded into the Java virtual machine.
D.Only when the main() method is executed.
7.定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)，则s1.length()和s1.capacity()分别是多少?
A.4 10
B.4 4
C.10 10
D.10 4
8.关于 访问权限说法正确 的是 ？ ( )
A.外部类定义前面可以修饰public,protected和private
B.局部内部类前面可以修饰public,protected和private
C.匿名内部类前面可以修饰public,protected和private
D.以上说法都不正确
9.单例模式中，两个基本要点是
A.构造函数私有
B.静态工厂方法
C.以上都不对
D.唯一实例
10.针对以下代码，哪些选项执行后是true的：（）

class CompareReference{
   public static void main(String [] args){
   float f=42.0f;
   float f1[]=new float[2];
   float f2[]=new float[2];
   float[] f3=f1;
   long x=42;
   f1[0]=42.0f;
  }
}

A.f1f2
B.xf1[0]
C.f1f3
D.f2f1[1]

(1)虽然类中的private方法都隐式地指定为final，但是二者并不是等同的。private是访问权限修饰符，用于控制外界对类内部成员的访问，private方法只能在类的内部访问，而final方法可以在类外部访问
final修饰类，表示类不可被继承
final修饰变量，表示变量不可更改
final修饰方法，表示方法不可被覆盖
(2)使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至127直接时，作为基本类型。
使用Integer a = new Integer(1); 时，无论值是多少，都作为对象。
(3)C记住 hashmap采用拉链法解决冲突
(4)A B D
Collection 接口常用的方法
size():返回集合中元素的个数
add(Object obj):向集合中添加一个元素
addAll(Colletion coll):将形参coll包含的所有元素添加到当前集合中
isEmpty():判断这个集合是否为空
clear():清空集合元素
contains(Object obj):判断集合中是否包含指定的obj元素
① 判断的依据：根据元素所在类的equals()方法进行判断
②明确：如果存入集合中的元素是自定义的类对象，要去：自定义类要重写equals()方法
constainsAll(Collection coll):判断当前集合中是否包含coll的所有元素
rentainAll(Collection coll):求当前集合与coll的共有集合，返回给当前集合
remove(Object obj):删除集合中obj元素，若删除成功，返回ture否则
removeAll(Collection coll):从当前集合中删除包含coll的元素
equals(Object obj):判断集合中的所有元素 是否相同
hashCode():返回集合的哈希值
toArray(T[] a):将集合转化为数组
①如有参数，返回数组的运行时类型与指定数组的运行时类型相同。
iterator():返回一个Iterator接口实现类的对象,进而实现集合的遍历。
数组转换为集合：Arrays.asList(数组)
(5)CD
此题考察对于java流的理解
节点流是实际工作的流，
处理流（我们叫包装流可能容易理解一点）设计的目的是让对流中数据的操作，转化成我们能更简单明了的看懂的数据（而不是二进制的字节等）的操作，但实际上增加了很多类，是io流变的更复杂
字节流必是一个接点流，字符流就是一个操作流
使用时，必须是有一个结点流，然后才能用操作流来包装结点流，即把结点流当参数传个操作流
(6)被static修饰的语句或者变量有如下特点：
1.随着类的加载而加载
2.优先于对象存在
3.被所有对象所共享
4.可以直接被类名所调用
使用注意：
1.静态方法只能访问静态成员
2.静态方法中不可以写this,super关键字
3.主函数是静态的
(7)StringBuffer s = new StringBuffer(x); x为初始化容量长度
s.append(“Y”); "Y"表示长度为y的字符串
length始终返回当前长度即y；
对于s.capacity()：
1.当y<x时，值为x
以下情况，容器容量需要扩展
2.当x<y<2x+2时，值为 2x+2
3.当y>2*x+2时，值为y
(8)D
1、外部类前可以修饰：public、default、abstract、final
2、内部类前可以修饰：public、protected、default、private、abstract、final、static
3、局部内部类前可以修饰：abstract、final
其中：访问修饰符（public、protected、default、private），其他都是非访问修饰符
(9)AD

通常单例模式在Java语言中，有两种构造方式：
1.懒汉方式。指全局的单例实例在第一次被使用时构建。

//懒汉式
public class Singleton2 {
private static Singleton2 INSTANCE=null;

private Singleton2(){}

public static Singleton2 getInstance(){
if(INSTANCE!=null){
INSTANCE = new Singleton2();
}
return INSTANCE;
}
}
2.饿汉方式。指全局的单例实例在类装载时构建。

//饿汉式
public class Singleton {
private final static Singleton INSTANCE = new Singleton();

private Singleton(){}

public static Singleton getInstance(){
return INSTANCE;
}
}

(10)BC正确，选项B解释，java核心卷I中43页有如下表述：两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型。