下面一道题，是关于 Java 的引用传递的问题。

view sourceprint?01 package org.leeing.mem;  

02    

03 class StringBean{  

04     String  str = "hello";  

05 }  

06    

07 class IntBean{  

08     int intVal = 100;  

09 }  

10 public class RefDemo02 {  

11     public static void main(String[]args){  

12    

13         StringBean strbean = new StringBean();  

14         strbean.str = "world";  

15    

16         IntBean intbean = new IntBean();  

17    

18         intbean.intVal = 33;  

19         String strname = "strname not Changed";  

20    

21         change(strbean);  

22         change(intbean);  

23         change(strname);  

24    

25         System.out.println(strbean.str); 
// 输出 "strbean changed"  

26         System.out.println(intbean.intVal);
// 输出 999  

27         System.out.println(strname); 
// 输出 "strname not Changed"  

28    

29     }  

30    

31     public static void change(StringBean temp){  

32         temp.str = "strbean changed";  

33     }  

34    

35     public static void change(String str){  

36         str = "leeing";  

37     }  

38    

39     public static void change(IntBean temp){  

40         temp.intVal = 999;  

41    

42     }  

43 } 

输出是：

view sourceprint?1 strbean changed  

2 999 

3 strname not Changed 

可以看到 String 是不可变对象，而IntBean和StringBean则通过引用改变了内部变量的值，此处对int和String的改变原理是相同的。

这是一道有关构造方法的程序：

view sourceprint?01 package org.leeing.mem;  

02    

03 abstract class BaseClass{  

04     public BaseClass(){  

05         this.print() ;  

06     }  

07     public abstract void print() ;  

08 }  

09    

10 class SubClass extends BaseClass{  

11     private int x = 100 ;  

12     public SubClass(int x){  

13         this.x = x ;  

14     }  

15     public void print(){  

16         System.out.println("x = " + x) ;  

17     }  

18 }  

19    

20 public class TestJava{  

21     public static void main(String args[]){  

22         BaseClass a = new SubClass(10) ;  

23     }  

24 } 

它的输出结果是：x = 0

这是因为子类对象的实例化过程是这样的：首先调用父类的构造方法BaseClass()，而在BaseClass()调用完毕之前，子类的构造方法SubClass()是不能得到调用的，同时SubClass 的所有属性也不能初始化，在这里中 int 类型的 x 默认值为 0。

同时，在开发中应当尽可能遵循的原则是：一个类不要继承一个已经实现好的类，而是最好继承抽象类或者实现接口。

经常看到一道笔试题，是关于打印矩阵的，今天抽空写了一个实现。题目如下：

打印如下形式的矩阵： 

当 n=5 时：

view sourceprint?1 1   2   9  10  25 

2 4   3   8  11  24 

3 5   6   7  12  23 

4 16  15  14 13  22 

5 17  18  19 20  21 

当 n=6 时: 

view sourceprint?1 1   2   9  10  25  26 

2 4   3   8  11  24  27 

3 5   6   7  12  23  28 

4 16  15  14 13  22  29 

5 17  18  19 20  21  30 

6 36  35  34 33  32  31 

 

经过仔细的观察，可以看到平方数的位置与对角线的值的关系： 

view sourceprint?1 a[0][0] = (0+1)(0+1)-0 = 1;  

2 a[1][1] = (1+1)(1+1)-1 = 3;  

3 a[2][2] = (2+1)(2+1)-2 = 7; 

 

一旦定了对角线元素，接下来就好办了，根据下标的奇偶性填充其它的元素，注意加减的符号即可。 不多说了，放代码吧。 


view sourceprint?01 package org.leeing.matrix;  

02    

03 public class Snake {  

04     public static void main(String[] args) {  

05         snake(5);  

06     }  

07    

08     private static void snake(int num) {  

09         int snakes[][] = new int[num][num];  

10         for (int i = 0; i < num; i++) {  

11             snakes[i][i] = (1 + i) * (1 + i) - i;  

12         } 
// 初始化对角线  

13    

14         for (int j = 1; j < num; j++) {  

15             if (j % 2 != 0) { 
// 如果 j 是奇数  

16    

17                 for (int i = j - 1; i >= 0; i--) {  

18                     snakes[i][j] = snakes[i + 1][j] - 1;  

19                 }
// 向上减  

20    

21                 for (int k = j - 1; k >= 0; k--) {  

22                     snakes[j][k] = snakes[j][k + 1] + 1;  

23                 }
// 向左加  

24             } else {  

25                 for (int i = j - 1; i >= 0; i--) {  

26                     snakes[i][j] = snakes[i + 1][j] + 1;  

27                 }
// 向上加  

28    

29                 for (int k = j - 1; k >= 0; k--) {  

30                     snakes[j][k] = snakes[j][k + 1] - 1;  

31                 }
// 向左减  

32             }  

33    

34         }  

35         for (int i = 0; i < num; i++) {  

36             for (int j = 0; j < num; j++) {  

37                 System.out.print(snakes[i][j] + "\t");  

38             }  

39             System.out.println();  

40         }  

41    

42     }  

43    

有道的面试题。

写一个函数，打印一个如下的 n x n 的矩阵：

 

view sourceprint?01 n = 5 

02    

03 1 1 1 1 1 

04 1 2 3 2 1 

05 1 3 6 3 1 

06 1 2 3 2 1 

07 1 1 1 1 1 

08    

09 n = 6 

10    

11 1 1 1 1 1 1 

12 1 2 3 3 2 1 

13 1 3 6 6 3 1 

14 1 3 6 6 3 1 

15 1 2 3 3 2 1 

16 1 1 1 1 1 1 

提示: 除了边上的元素,每个元素都是由边上的某两个元素相加得到的。

观察一下即知这个矩阵具有一定的对称性，那么只要求取左上角的子矩阵，再通过对称即可得到整个矩阵。

view sourceprint?01 package org.leeing.matrix;  

02    

03 public class Matrix {  

04     public static void main(String[] args) {  

05         printMatrix(5);  

06     }  

07    

08     private static void printMatrix(int num) {  

09         int matrix[][] = new int[num][num];  

10         int len = (int)Math.ceil(num/2.0);  

11         for(int j = 0;j<len;j++){ 
// 边赋值为1  

12             matrix[0][j] = 1;  

13             matrix[j][0] = 1;  

14         }  

15    

16         for(int i = 1;i<len ;i++){ 
// 求和  

17             for(int j =1;j<len;j++)  

18                 matrix[i][j] = matrix[i-1][j] + matrix[i][j-1];  

19         }  

20    

21         for(int i = 0;i<len;i++){ 
// 左右对称  

22             for(int j = len;j<num;j++){  

23                 matrix[i][j] = matrix[i][num-j-1];  

24             }  

25         }  

26    

27         for(int i = len;i<num;i++){ 
//上下对称  

28             for(int j = 0;j<num;j++){  

29                 matrix[i][j] = matrix[num-i-1][j];  

30             }  

31         }  

32    

33         for(int i = 0;i<num;i++){  

34             for(int j = 0;j<num;j++){  

35                 System.out.print(matrix[i][j]+"\t");  

36             }  

37             System.out.println();  

38         }  

39         System.out.println();  

40     }  

41 } 

据说是微软的一道题。

题目：在排序数组中，找出给定数字的出现次数，比如 [1, 2, 2, 2, 3] 中2的出现次数是3次。

算法的思想，使用修改后的二分查找法，找到最左边 2 的下标为 1 ，最后边 2 的下标为 3，然后返回3 – 1 + 1 = 3 即可，算法复杂度为 logN。

编码的时候，用一个变量 last 来存储本次查找到的位置，然后根据情况变换查找方向，就可以分别确定 left 和 right 下标的值。

代码实现：

view sourceprint?01 package org.leeing.interview;  

02    

03 /**  

04  * 题目：在排序数组中，找出给定数字的出现次数，比如 [1, 2, 2, 2, 3]  

05  * 2 的出现次数是3次。  

06  *  

07  * @author leeing  

08  *  

09  */ 

10 public class NumberCounter {  

11     public static void main(String[] args) {  

12         int a[] = { 1, 2, 2, 2, 2, 3, 4 };  

13         int counter = numbercounter(a, 4);  

14         System.out.println(counter);  

15     }  

16    

17     static int numbercounter(int[] a, int num) {  

18         int left = binarysearch(a, num, true);  

19         int right = binarysearch(a, num, false);  

20         System.out.println("left is :" + left);  

21         System.out.println("right is :" + right);  

22    

23         if (left != -1 && right != -1) {  

24             return right - left + 1;  

25         } else {  

26             return 0;  

27         }  

28     }  

29    

30     static int binarysearch(int[] a, int target, boolean isLeft) {  

31         int left = 0, right = a.length - 1;  

32         int last = 0;  

33         while (left <= right) {  

34             int mid = (left + right) / 2;  

35             if (a[mid] < target) {  

36                 left = mid + 1;  

37             } else if (a[mid] > target) {  

38                 right = mid - 1;  

39             } else {  

40                 last = mid;  

41    

42                 if (isLeft) {  

43                     right = mid - 1;  

44                 } else {  

45                     left = mid + 1;  

46                 }  

47             }  

48         }  

49         return last > 0 ? last : -1;  

50     }  

51 }