Interview2---3g

1.字节流与字符流的区别?

第一:字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。

第二:字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点.

第三:字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串；

第四:字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。

2.HashMap和HashTable的区别?

第一个不同主要是历史原因。Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

第二:HashTable是线程安全的,而HashMap不是;

第三:HashMap允许有一个key为null和多个value为null, 而HashTable是不可以的.

3.Vector与ArrayList的区别？

第一、同步性：Vector是线程安全的，ArrayList不是。

第二、数据增长：当需要增长时，Vector默认为原来的一倍，而ArrayList是原来的一半。

4.Java中如何引发异常, 处理异常有两种途径?

Java提供了两类主要的异常:runtime exception和checked exception。所有的checked exception是从java.lang.Exception类衍生出来的，而runtime exception则是从java.lang.RuntimeException或java.lang.Error类衍生出来的。

* Runtime exceptions: 
在定义方法时不需要声明会抛出runtime exception; 
在调用这个方法时不需要捕获这个runtime exception; 
runtime exception是从java.lang.RuntimeException或java.lang.Error类衍生出来的。 
* Checked exceptions: 
定义方法时必须声明所有可能会抛出的checked exception; 
在调用这个方法时，必须捕获它的checked exception，不然就得把它的exception传递下去; 
checked exception是从java.lang.Exception类衍生出来的。

两种途径: 1.调用者来处理; 2.通过try/catch来处理;

5.百马百担货, 大马三担, 中马二担, 小马两马一担, 求大中小马各有多少?

public class HorseTest {
    public static void main(String[] args) {
        int i,j;//
        for (i = 1; i < 34; i++) {//大马
            for (j = 1; j < (100-3*i)/2+1; j++) {//中马
                if ((100-i-j)%2==0  && 3*i+2*j+(100-i-j)/2==100) {
                    System.out.println("大马,中马,小马:"+i+","+j+","+(100-i-j));
                }
            }
        }
    }
}

6.从前有个农民，一生养了不少牛。去世前留下遗嘱：牛的总数的一半加半头给儿子，剩下牛的一半加半头给妻子，再剩下的一半加半头给女儿，再剩下的一半加半头宰杀犒劳帮忙的老乡。农民去世后，他们按遗嘱分完后恰好一头也不剩。他们各分了多少头牛？

解:

1-->儿子 1/2x+1/2

2-->妻子  1/4x+1/4

3—>女儿  1/8x+1/8

4-->乡亲  1/16x+1/16

可得：1/2x+1/2+1/4x+1/4+1/8x+1/8+1/16x+1/16=x， 解之得：x=15.

public class CattleTest {
    public static void main(String[] args) {
        System.out.println("总共的牛的头数是:"+cal(4));
    }
    private static int cal(int count) {
        if (count>0) {
            return 2*(cal(--count))+1;
        }
        return 0;
    }
}

7.用JAVA写一个多线程程序。一个变量，四个线程，二个加1，二个减1，输出。

package com.yenange.actual;

public class ThreadTest1 {
    private int j;

    public static void main(String args[]) {
        ThreadTest1 tt = new ThreadTest1();
        Inc inc = tt.new Inc();
        Dec dec = tt.new Dec();
        for (int i = 0; i < 2; i++) {
            Thread t = new Thread(inc);
            t.start();
            t = new Thread(dec);
            t.start();
        }
    }

    private synchronized void inc() {
        j++;
        System.out.println(Thread.currentThread().getName() + "-inc:" + j);
    }

    private synchronized void dec() {
        j--;
        System.out.println(Thread.currentThread().getName() + "-dec:" + j);
    }

    class Inc implements Runnable {
        public void run() {
            for (int i = 0; i < 5; i++) {
                inc();
            }
        }
    }

    class Dec implements Runnable {
        public void run() {
            for (int i = 0; i < 5; i++) {
                dec();
            }
        }
    }
}

8.十二个鸡蛋，其中有一个是坏的，用天平称三次，找出坏蛋。

解：

假设A,B相称.
                (一):A和B平.说明话鸡蛋在C中.
                          A1C1和C2C3称(第二次):
                                  1.平:A1和C4称(第三次):
                                          1).C4高:C4是重的坏鸡蛋
                                          2).C4低:C4是轻的坏鸡蛋
                                  2.A1C1高:(说明C1是轻的坏鸡蛋,或者C2C3有个重的坏鸡蛋)
                                          A1C2和A2C3称(第三次):
                                                1).A1C2高:C2是重的坏鸡蛋
                                                2).A2C3高:C3是重的坏鸡蛋
                                                3).平:C1是轻的坏鸡蛋
                                  3.A1C1低:推断和2类似
                其他按照类似思路
不平(一例):
        A高B低:(说明A中一个是轻的或B有一个是重的)
                A1B1B2和A2B3C1称:(第二次):
                          平:(A3A4一为轻或B4为重)
                                  A3和A4称:(第三次)
                                            平:B4为重的
                                            高:A3为轻的
                                            低:A4为轻的
                          A1B1B2高:(A1为轻或B3为重的)
                                  A1和C1称(第三次):
                                          平:B3为重
                                          高:A1为轻
                                          低:(这种情况不会出现)
                          A1B1B2低:(B1B2一为重或A2轻)
                                  B1和B2称:(第三次)
                                          平:A2轻
                                          高:B2重
                                          低:B1重
另一情况类似

9.一颗二叉树有7个度数为2的节点， 有10个度数为1的节点， 求总节点数：25

10. 有如下几个类，打印结果如何？

package com.yenange.actual;

public class Z {
    private Y y=new Y();
    public Z(){
        System.out.print("Z");
    }
    public static void main(String[] args) {
        Z z=new Z();
    }

}

class Y extends X{
    private X x=new X();
    public Y(){
        System.out.print("Y");
    }
}

class X {
    public X(){
        System.out.print("X");
    }
}

结果：XXYZ

解答：

从Z开始，Z有属性y，所以要先Y， 但Y又有属性x， 所以打X， 而在构造Y时，必须先父类，所以再打X， 再打Y, 最后打Z

11.注意：String虽然是引用类型，但作方法参数无法回传。