你是及格的java程序员吗（1）

写了很多年的java程序就一定是一个及格的java程序员吗？我不敢说自己就是一个合格的java程序员，勉强算及格吧。
我们从项目中最常用的String说起吧
1.关于replace和replaceAll
很多哥们对这两个兄弟的认识就是：replace只进行一次替换，replaceAll是全部替换。
replace是普通字符串替换，replaceAll是正则替换，这个要怪就怪Sun的工程师们给这两个方法取名取得不好，replaceAll如果改名叫做replaceRegex就好多了。
此外：replaceAll的第一个是正则表达式，第二个是替换字符串，这个函数的正确使用方式是：
对第一个参数使用：Pattern.quote()
对第二个参数使用：Matcher.quoteReplacement()
参考：《java puzzlers》Puzzle 20: What's My Class? Puzzle 21: What's My Class, Take 2
2.关于split
实际项目中，大家经常会用到把几个参数用一个特殊的字符拼到一块，然后用split拆分的情况，比如说：
String params = "aa|bb|cc|dd";
String paramArray[] = params.split("|");
看上去没错，实际上人家split也是用正则表达式来进行拆分的，而|在正则里面是有特殊意义的，所以这就出问题了。
既然replace可以有个双胞胎兄弟replaceAll，那么，split为什么就不可以有双胞胎姐妹splitAll或者说splitRegex呢?
此外，split还可以有第二个参数，split(regex, limit)，这第二个参数是什么意义呢？
我们api文档怎么说:
The limit parameter controls the number of times the pattern is applied and therefore affects the length of the resulting array. If the limit n is greater than zero then the pattern will be applied at most n - 1 times, the array's length will be no greater than n, and the array's last entry will contain all input beyond the last matched delimiter. If n is non-positive then the pattern will be applied as many times as possible and the array can have any length. If n is zero then the pattern will be applied as many times as possible, the array can have any length, and trailing empty strings will be discarded.
如果limit<0,将会尽最大可能进行拆分
如果limit=0,将会尽最大可能进行拆分，但是会丢掉末尾的空字符串
如果limit>0,最多会进行limit-1次拆分，拆分出来的字符串数组的长度最大是limit。
"aa,bb,,,,,".split(",").length=2
"aa,bb,,,,,".split(",",0).length=2
"aa,bb,,,,,".split(",",-1).length=7
3.曾经遇见过synchronized(String)这种东西
这个不大好描述，还是直接看代码吧：
class Worker implements Runnable{
    private int count = 0;
    @Override
    public void run() {
        String lock = "mylock";
        synchronized(lock){
            try{Thread.sleep(100);}catch(Exception e){e.printStackTrace();}
            count++;
            System.out.println(Thread.currentThread().getName()+" count:"+count);
            count--;
            System.out.println(Thread.currentThread().getName()+" count:"+count);
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        Worker worker = new Worker();
        for(int i=0;i<10;i++){
            Thread t = new Thread(worker);
            t.start();
        }
    }
}
乍一看，锁对象是方法的内部变量，因此，根本起不到同步的作用，但是，实际上呢？运行一下代码就看出来了，人家确实是同步的！
因为，String的字面常量在一个虚拟机的常量池内部只会保留一份，因此，就算是内部变量，实际上也只有一份，因此是可以用来当锁使用的，
当然，可以这么做不等于一定就得这么做，反正我是没看出来非得这么使用的理由。如果想让上面的锁失效，也很简单：String lock = new String("mylock");这样的话，
每次都是new出来的新对象，肯定不是同一把锁，肯定就不会同步了！
下面是字节码：
(1)String lock = "mylock";的时候
stack=3, locals=5, args_size=1
         0: ldc           #3                  // String mylock
         2: astore_1      
         3: aload_1       
         4: dup           
         5: astore_2      
         6: monitorenter  
(2)String lock = new String("mylock");的时候
stack=3, locals=5, args_size=1
         0: new           #3                  // class java/lang/String
         3: dup           
         4: ldc           #4                  // String mylock
         6: invokespecial #5                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
         9: astore_1      
        10: aload_1       
        11: dup           
        12: astore_2      
        13: monitorenter  
可以参考：java language specification，3.10.5 String Literals这里面有最权威的例子。
不推荐使用String对象作为锁，如果非要使用，可以使用synchronized(str.intern())。
4.下面我们来看一个关于集合初始化的问题：
java里面所有的集合类基本上都有一个指定集合大小的构造函数，比如ArrayList，如果我们确切的知道List的元素数量是n个，我们在定义List的时候，可以这样：
List<String> list = new ArrayList<String>(n);这并不是说，用这个构造函数构造出来的List只能装n个元素，它只是说初始化的时候，可以装n个元素，当装不下的时候还是会进行扩容的。
指定初始化容量的好处是显而易见的，因为默认ArrayList是有10个元素，如果我们的List的元素比较少，只有5个元素，我们可以省掉一半的空间，如果元素比较多是1000个，
如果不指定初始化大小，那中间要经过12次扩容才可以放得下这1000个元素int newCapacity = oldCapacity + (oldCapacity >> 1);hashmap稍微有点特殊，因为它还有一个负载因子的概念，也就是说，HashMap不会等到把所有的桶都装满以后才进行扩容，而是达到一定的比例，就开始扩容，默认是0.75，因为HashMap扩容需要对里面所有的元素重新计算hashcode，因此，如果元素数目比较多，相对来说还是一件挺耗时的事情，如果可以的话，我们尽量减少扩容的次数。
下面是我写的一个用来计算HashMap初始化容量的一个类：
public class HashMapUtil {
    /**
     * 计算存储realCount个元素所需的hashmap的capacity，可以避免扩容
     *
     * @param realCount 实际要存储的元素的数目
     * */
    public static int capacity(int realCount){
        return capacity(realCount,0.75);
    }
    /**
     * 计算存储realCount个元素所需的hashmap的capacity，可以避免扩容
     *
     * @param realCount   实际要存储的元素的数目
     * @param loadbalance 负载因子
     * */
    public static int capacity(int realCount,double loadbalance){
        if(realCount <= 1){
            return 1;
        }
        int capacity = 1;
        while(capacity * loadbalance < realCount){
            capacity = capacity << 1;
        }
        return capacity;
    }
}
类似的还有StringBuffer和StringBuilder，如果在构造的时候就指定其大小，可以减少扩容的次数，提高效率。