编写java代码的一些技巧

（1）BigDecimal中要使用String作为参数来构造（BigDecimal.valueOf()会把各种值转化成字符串，再调用 BigDecimal(String)的），否则照样会出问题；

		System.out.println(10000*1.005);
		System.out.println(new BigDecimal(10000).multiply(new BigDecimal(1.005)));
		System.out.println(BigDecimal.valueOf(10000).multiply(BigDecimal.valueOf(1.005)));
		System.out.println(new BigDecimal("10000").multiply(new BigDecimal("1.005")));

输出：
10049.999999999998
10049.99999999999893418589635984972119331359863281250000
10050.000
10050.000



（2）长整型要使用大写字母L而不是小写字母l来标识，因为小写字母l看起来有点像数字1；
例如：

    long i = 200l;//看起来是不是像2001呢；
    long i = 200L;//这样，就算有近视，也能辨认清楚了。

（3）如果一个类中有多处使用长数字，则可以定义并使用数字常量，到处写长的数字，容易出现多一个0或少一0等写错位数的问题，同时导致问题难以排查。
例如：

if(i > 10000000 && i<100000000) {...}
if(j >= 10000000 && j<=100000000) {...}

可改成：

final int BEGIN = 10000000;
//或 final int BEGIN = 10*1000*1000;
final int END = 100000000;
//或 final int END = 100*1000*1000
if (i > BEGIN && i< END){...}
if (j >= BEGIN && j<= END){...}

再如TimeUnit中的代码：

    // Handy constants for conversion methods
    static final long C0 = 1L;
    static final long C1 = C0 * 1000L;
    static final long C2 = C1 * 1000L;
    static final long C3 = C2 * 1000L;
    static final long C4 = C3 * 60L;
    static final long C5 = C4 * 60L;
    static final long C6 = C5 * 24L;

（4）在使用Map时，要注意Integer与Long的自动装箱，要与String类型的key区分开来：
例如：

		Map<String,String> hm = new HashMap<String,String>();
		hm.put("1", "1Value");
		hm.put("2", "1Value");
		hm.put("3", "1Value");
		hm.put("4", "1Value");
		
		int i = 1;
		System.out.println(hm.get(i+1));//错误的做法，值为null
		System.out.println(hm.get(String.valueOf(i+1)));//正确的做法

输出：
null
1Value
因为i+1计算后自动装箱成Integer(2)，而hm.get(new Integer(2)) 与hm.get(new String(2))是完全不一样的。


（5）有同学写代码，把数字转型为字串时喜欢用类似 i+"" 这种方式，个人认为这样的代码比较难看，可以写成 String.valueOf(i)，它是不是好看一些。


（6）对于复杂的判断条件，最好不要经常使用“非”等排除条件式子，这样不便于理解组合条件的含义：
例如：
   如果 成功方案赢利≥1000元 或 成功方案赢利≥500元且回报率≥10倍 则返回战绩，否则 返回0；

不便于直接思维的、排除式的写法：

 if (profit.compareTo(minProfit) < 0 && (profit.compareTo(minRateProfit) < 0 || rate.compareTo(minRate) < 0)) {
            return 0; 
} else {
return 战绩值；}

这个是正确的写法，但是因为整合条件都要反过来写，类似：A&&B 变成 !A||!B，很难理解，也极容易把（!A || !B）写成 （!A && !B）。


便于理解的、直观式的写法：

 if (profit.compareTo(minProfit) >= 0 && (profit.compareTo(minRateProfit) >= 0 && rate.compareTo(minRate) >= 0)) {
       return 战绩值；
}else {
   return 0; 
}

（7）经常看见list!=null && list.size()>0 这样的代码，大概担心用到的list为null而导致空指针异常，其实list!=null一般是没有必要，这样的代码比较难看一点。

《Effective Java》建议：对返回值为Collection或Map的子类的，尽量返回一个元素为空的Collection或Map，而不是返回null。

事实上，很多开源的框架中就是这么做的，看下面应用Hibernate的一段代码：

 
       Query q = *Dao.createQuery(hql);
       List<?> list = q.list();
       if (list != null && list.size() > 0) {
          return (DcRace) list.get(0);
       }

可以改为：

 
       Query q = *Dao.createQuery(hql);
       List<?> list = q.list();
       if (list.size() > 0) {//删除 list != null && 
          return (DcRace) list.get(0);
       }

事实上，q.list()永远不会返回null，所以没有必要判断list是否为null，这样代码更加简洁、好看。

（8）BigDecimal是一个只读类，它的对象一旦构建好了，就无法修改该该对象的属性。如：
public BigDecimal setScale(int newScale, int roundingMode)
public BigDecimal add(BigDecimal augend)
等方法都是返回一个新的BigDecimal对象，而对原来的BigDecimal不会起热任何修改作用的。JDK中类似的只读类还有：所有的基本数据类型，所有的数据封装类，BigInteger，String等。

（9）java中，等式返回值是等式右边表达式的值，如

    public LinkedList() {
        header.next = header.previous = header;
    }

能看懂吗？第一步执行header.previous = header，第二部（header.previous = header）返回值为header,把header赋给header.next.

又如：

		String t;
		String x;
		System.out.println(x = t = "1222");
		System.out.println("x:" + x);
		System.out.println("t:" + t);
                //输出:1222 x1222 t1222

（10）Java1.5以上，String.format(String,object1...)提供了在字串中插入格式化的部分。
例如：

	
		System.out.println(String.format("test %s %s","ooo","pppp"));
		System.out.println(String.format("test %1$s %2$s","ooo","pppp"));
		System.out.println(String.format("test %2$s %1$s","ooo","pppp"));

输出为：
test ooo pppp
test ooo pppp
test pppp ooo



(11) 模运算的另类表达：
一般： M%N, 但这种效率不高，效率更高为： M & (N-1)。
HashMap中算key在Node[]的下标，就用&这种方式。

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);