库之谜总结

1.不可变类型的问题

问题：

BigInteger i = 1;

BigInteger j = 1;

i.add(j);后i是多少？1

分析：

(1)不可变类型种类：String、BigDecimal、BigInteger和各种包装器类型都是不可变类型。

(2)对于String不可变的特性在我另一篇博文中说到。

(3)比如BigInteger的add方法，并不会改变两个操作数即现有实例，而是返回新的实例。

结论：

在调用不可变对象的方法时，如果对于看起来是对对象进行改变的方法，则现有实例并不会改变，而是返回一个新的实例。

import java.math.*; public class PuzzleDemo56{ public static void main(String args[]){ BigInteger five = new BigInteger("5"); BigInteger six = new BigInteger("6"); BigInteger total = BigInteger.ZERO; total = five.add(six); System.out.println("5 + 6 = "+total); } }

2.HashSet中覆写hashCode的重要性

在HashSet中寻找某个对象需要两个步骤：

(1)通过计算hashCode方法计算散列码，并对应到某个数组索引。

(2)通过数组索引对应的链表遍历，调用equals方法查找是否已经存在这个对象。

结论：
因此在HashSet中hashCode和equals方法缺一不可，当然在一般的类中，如果覆写了equals方法，就必须覆写hashCode方法。

import java.util.*; public class PuzzleDemo57{ private final String first,last; public PuzzleDemo57(String first,String last){ this.first = first; this.last = last; } @Override public boolean equals(Object o){ if(!(o instanceof PuzzleDemo57)) return false; PuzzleDemo57 n = (PuzzleDemo57)o; return n.first.equals(first) && n.last.equals(last); } @Override public int hashCode(){ return 13 * first.hashCode() + 27 * last.hashCode(); } public static void main(String args[]){ Set<PuzzleDemo57>s = new HashSet<PuzzleDemo57>(); s.add(new PuzzleDemo57("xia","zdong")); System.out.println(s.contains(new PuzzleDemo57("xia","zdong"))); } }

3.八进制表示问题

问题：int i[] = {012,123,234};中 i[1]-i[0]结果是什么？113

分析：

(1)八进制表示：以0开头的整形字面常量。

结论：

千万不要在一个整型字面常量前加一个0.

import java.util.*; public class PuzzleDemo59{ public static void main(String args[]){ int vals[] = {789,678,567,456,345,234,123,12}; Set<Integer>diffs = new HashSet<Integer>(); for(int i=0;i<vals.length;i++){ for(int j=i;j<vals.length;j++){ int tmp = vals[i] - vals[j]; diffs.add(tmp); System.out.println(tmp); } } } }

4.打印数组的巧妙方法

问题：如果编写一个方法打印数组，接收一个数组，但却不知道数组的维度，该怎么办？库方法

分析：

在Arrays类中有一个deepToString()方法，如果传递的是数组，则将打印数组中的内容。

结论：

要了解类库中的方法。

import java.util.*; public class PuzzleDemo60{ public static void main(String args[]){ String[]strs = {"spam","sausage","spam","bacon","spam"}; List<String> list = Arrays.asList(strs); List<String> list2 = deleteMore(list); System.out.println(list2); int[][]s = new int[3][2]; s[0][0] = 1; s[0][1] = 1; s[1][0] = 1; s[1][1] = 1; s[2][0] = 1; s[2][1] = 1; System.out.println(Arrays.deepToString (s)); } public static List<String> deleteMore (List<String> list){ return new ArrayList<String>(new LinkedHashSet<String>(list)); } }

5.如果要在List中去除重复元素，则可以把他放到Set中，则会自动去除。

见上例。

6.Integer.bitCount(int i)返回i变成二进制后被置位的位数。

7.Date和Calendar的一些规定

(1)在这两个类中，月份都是从0开始计数，即一月是0。

(2)Date的方法基本都已经过时，所以不要使用。

(3)Calendar cal = Calendar.getInstance();创建一个实例。

(4)cal.set(int year,int mon,int day);设置时间。

import java.util.*; public class PuzzleDemo61{ public static void main(String args[]){ Calendar cal = Calendar.getInstance(); cal.set(1999,Calendar.DECEMBER,31); System.out.print(cal.get(Calendar.YEAR)+" "); System.out.println(cal.get(Calendar.DAY_OF_MONTH)); } }

8.Math.abs(i)一定返回非负数？

问题：Math.abs(Integer.MIN_VALUE)返回什么？Integer.MIN_VALUE.

分析：

(1)一般情况下，返回的是非负数。

(2)当参数为Integer.MIN_VALUE时，则返回是其本身。

import java.util.*; public class PuzzleDemo64{ public static void main(String args[]){ int min = Math.abs(Integer.MIN_VALUE); System.out.println(min); //打印的仍是Integer.MIN_VALUE. final int MODULUS = 3; int[] histogram = new int[MODULUS]; int i = Integer.MIN_VALUE; do{ histogram[mod(i,MODULUS)]++; }while(i++!=Integer.MAX_VALUE); for(int j=0;j<MODULUS;j++){ System.out.println(histogram[j]+" "); } } public static int mod(int i,int modulus){ int result = i%modulus; return result<0?result+modulus: result; } }

9.惯用法比较器真的正确？

问题：

Comparator comp = new Comparator<Integer>(){ public int compare(Integer i,Integer j){ return i-j; } }

这种传统的比较器真的正确吗？不！

分析：

(1)这种惯用法是不合理的，因为i-j可能会溢出。

结论：

Comparator<Integer> comp = new Comparator<Integer>(){ public int compare(Integer i,Integer j){ return i<j?-1:((i==j)?0:1); } };

这种比较器是没有问题的。

因此千万不要使用基于减法的比较器。

import java.util.*; public class PuzzleDemo65{ public static void main(String args[]){ Integer[]arr = {Integer.MIN_VALUE,2}; Comparator<Integer> oldComp = new Comparator<Integer>(){ public int compare(Integer i,Integer j){ return i-j; } }; Comparator<Integer> comp = new Comparator<Integer>(){ public int compare(Integer i,Integer j){ return i<j?-1:((i==j)?0:1); } }; Arrays.sort(arr,oldComp); System.out.println(arr[0]+" "+arr[1]); Arrays.sort(arr,comp); System.out.println(arr[0]+" "+arr[1]); } }