Java面试

1、

    public static void main(String[] args) {
        String s1 = "uml";
        String s2 = "uml";
        String s3 = new String("uml");
        String s4 = new String("uml");

        System.out.println(s1 == s2);//true
        System.out.println(s3 == s4);//false
        System.out.println(s1.equals(s3));//true
    }

2、String、StringBuilder、StringBuffer

1）String是final修饰的，不可变；

2）运行速度StringBuilder>StringBuffer>String；

3）StringBuffer是线程安全的，StringBuilder和String是线程不安全的。

 

3、hashCode()和equals()比较对象

1）equals()相等的两个对象他们的hashCode()肯定相等，也就是用equals()对比是绝对可靠的。

2）hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。

所有对于需要大量并且快速的对比的话如果都用equals()去做显然效率太低，所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equals()，如果equals()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！

 

4、关于Float

1）它是一个类，在包java.lang中；

2）

        Float a = 1.0f;//必须加上f

        Float b = new Float(2.0);

5、总结

1）线程安全性

线程安全的集合对象：

Vector

HashTable

StringBuffer

线程不安全的集合对象：

Arraylist、LinkedList（有序，可重复）

HashSet、TreeSet（无序，唯一）

HashMap、TreeMap

StringBulider

6、

package test17;

class Two {
    Byte x;
}

class PassO {
    public static void main(String[] args) {
        PassO p = new PassO();
        p.start();
    }

    void start() {
        Two t = new Two();
        System.out.print(t.x + " ");//null
        Two t2 = fix(t);
        System.out.print(t.x + " " + t2.x);//42 42
    }

    Two fix(Two tt) {
        tt.x = 42;
        return tt;
    }
}

执行结果：null 42 42

如果改为

package test17;

class Two {
    byte x;
}

class PassO {
    public static void main(String[] args) {
        PassO p = new PassO();
        p.start();
    }

    void start() {
        Two t = new Two();
        System.out.print(t.x + " ");//null
        Two t2 = fix(t);
        System.out.print(t.x + " " + t2.x);//42 42
    }

    Two fix(Two tt) {
        tt.x = 42;
        return tt;
    }
}

执行结果：0 42 42

 

7、

引用毕向东教程的一段话：

1.成员变量：编译和运行都参考左边。

2.成员函数（非静态）：编译看左边，运行看右边

3.静态函数：编译和运行都看左边。

1）Father.java

package test17;

public class Father {

    public void say() {
        System.out.println("father");
    }

    public static void action() {
        System.out.println("爸爸打儿子！");
    }
}

2）Son.java

package test17;

public class Son extends Father {

    public void say() {
        System.out.println("son");
    }

    public static void action() {
        System.out.println("打打！");
    }

    public static void main(String[] args) {
        Father f = new Son();
        f.say();//成员函数（非静态）：编译看左边，运行看右边    所以执行结果为Son类的say()方法
        f.action();//静态函数：编译和运行都看左边   所以执行结果为Father类的action()方法
    }

}

运行结果：

son
爸爸打儿子！

 

再举一个例子----------->

package test18;

public class A {

    public int func1(int a, int b) {
        return a - b;
    }

}

package test18;

public class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}

        A a = new B();
        B b = new B();
        System.out.println("Result=" + a.func1(100, 50));
        System.out.println("Result=" + b.func1(100, 50));

运行结果：

Result=150 Result=150