java編程陷阱

1.首先什么是陷阱

　　簡潔的定義：

 　　　　 陷阱，是指那些能夠正常編譯，但是在執行時卻產生事與願違的，有時候甚至是災難性后果的程序代碼。

　　廣義的定義：

  　　　　任何可能導致程序員把大量的時間浪費在開發工具的使用上而不是最終軟件的進展上的語言特性、API或系統，都可以稱呼為陷阱。

2、陷阱的分類

　　

3、分析陷阱三重奏

　　a.症狀或者問題

  　　首先找到是哪一個代碼造成的問題，陷阱的類型是什么。

　　b.問題的根源

  　　這個是揭示陷阱最重要的一個部分，我們要深入底層，了解可能導致程序員絆腳的詳細內部工作過程、無效的假設或者API的缺陷。

　　c.解決方案

 　　 這個是分析陷阱的最后一個步驟，最終給出一個程序實現和運行結果。

例子1：找奇數

　　//找奇數
    public static boolean isOdd(int i) {
        return i % 2 == 1;
    }
    
    public static void main(String[] args) {
        System.out.println(isOdd(1));
        System.out.println(isOdd(2));
        System.out.println(isOdd(3));
        System.out.println(isOdd(-1));
        System.out.println(isOdd(-2));
    }

你會發現所有的負數在isOdd()方法里返回的都是false

更正方法：

　　public static boolean isOdd(int i) {
        return i % 2 != 0;
    }

 

例子2：浮點數相減

　　public static void main(String[] args) {
        System.out.println(2.0-1.1);
    }

你覺得得數會是多少？0.9？還是0.9000.....?

答案是：0.8999999999999999 可是我要的是0.9啊！ 那怎么怎么辦呢？

　　public static void main(String[] args) {
        System.out.println(new BigDecimal("2.0").subtract(new BigDecimal("1.1")));
    }

這樣就實現了變成0.9了

如果你覺得太麻煩了那你還能這樣：

 

System.out.printf("%.1f",2.0-1.1);

 

例子3、長整數

public static void main(String[] args) {
        final long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000;
        final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000;
        System.out.println(MICROS_PER_DAY / MILLIS_PER_DAY);
    }

你一看覺得得數是多少？ 很多人回答會是 1000 因為大家都能算的出來  但是你運行發現得數是5  你會說MICROS_PER_DAY 是long啊 應該不會溢出啊，

這是因為在java中 24 默認是int型的 那么24 * 60 * 60 * 1000 * 1000都會是int型的 當然就會溢出 最后會把溢出后的值給MICROS_PER_DAY 所以最后的值會莫名其妙

改正：

public static void main(String[] args) {
        final long MICROS_PER_DAY = 24L * 60 * 60 * 1000 * 1000;
        final long MILLIS_PER_DAY = 24L * 60 * 60 * 1000;
        System.out.println(MICROS_PER_DAY / MILLIS_PER_DAY);
    }

NO.4  互換內容

public static void main(String[] args) {
        int x = 1234;
        int y = 5678;
        x ^= y^= x^= y;
        System.out.println(" x = " + x + " , y =" + y);
    }

在c或者C++中有人見過這樣的交換兩個數的方法 。但是在java中有點不相同 結果是  x = 0 , y =1234

其實它要的原理是這樣的：

public static void main(String[] args) {
        int x = 1234;
        int y = 5678;
        y = x ^ y;
        x = x ^ y;
        y = x ^ y;
        System.out.println(" x = " + x + " , y =" + y);
    }

當由於java和c/C++存在差異所以才會出錯。

更正：

public static void main(String[] args) {
        int x = 1234;
        int y = 5678;
        y = (x ^= (y^= x)) ^ y;
        System.out.println(" x = " + x + " , y =" + y);
    }

No 5 ：隨機數的問題

public static void main(String[] args) {
        Random random = new Random();
        StringBuffer sb = null;
        switch (random.nextInt(3)) {
        case 1:
            sb = new StringBuffer('P');
            break;
        case 2:
            sb = new StringBuffer('M');
            break;
        default:
            sb = new StringBuffer('G');
            break;
        }
        
        sb.append('a');
        sb.append('i');
        sb.append('n');
        System.out.println(sb.toString());
    }

你覺得會打印出什么？ 很多人會說是 "Pain" 或者 "Main" 或者 "Gain" 。

其實都錯了  答案只有一個："ain"

其實主要的原因來自StringBuffer的構成方法 當你使用 new StringBuffer('G')是'G'會解釋成int 型  所以調用的構造方法是：

StringBuffer(int capacity) 構造一個不帶字符，但具有指定初始容量的字符串緩沖區。

而不是

StringBuffer(String str) 構造一個字符串緩沖區，並將其內容初始化為指定的字符串內容

所以改正的方法不言而喻了。

NO.6  無情的增量操作

public static void main(String[] args) {
        int j = 0 ;
        for (int i = 0; i < 100 ; i++) {
            j = j++;
        }
        System.out.println(j);
        
    }

這個題目你一個不注意就會喊出 輸出100 ；

其實答案是 0  這里的 j = j++; 從第一次賦值開始 j 就是被賦給了0 因為j++是后綴++ 賦值的時候還沒有增值。

NO.7  整數邊界的問題

public static final int MAX = Integer.MAX_VALUE;
    public static final int START = MAX - 100;
    public static void main(String[] args) {
        int j = 0 ;
        for (int i = START; i <= MAX ; i++) {
            j++;
        }
        System.out.println(j);
        
    }

 

你可能會很快的回答100 然后細心地看了下 說 101 

其實答案都不是  程序在無限循環着 

這是因為Integer.MAX_VALUE + 1 = Integer.MIN_VALUE 所以在for循環中 i=MAX 后 i++ 這時的 i 變成Integer.MIN_VALUE 了

 依然滿足條件

要循環結束 在for中的 i <= MAX 變成 i < MAX 即可。

 

 NO.8  計數器的問題

public static void main(String[] args) {
        int minutes = 0 ;
        for (int ms = 0; ms < 60 * 60 * 1000; ms++) {
            if(ms % 60*1000 == 0) {
                minutes ++ ;
            }
        }
        System.out.println(minutes);
    }

 你有可能一下子就說出了是 輸出 60 因為能整除 60 * 1000 的只能是 1 * 60 * 1000 ，2 * 60 * 1000 ....一直到 60 * 60 * 1000 一共60 個 

但是 答案讓你失望了  是60000

其實 這個的陷阱是在 ms % 60*1000 == 0 的操作符的優先級上  % 和 * 是同一級的 所以其實他是(ms % 60) *1000 == 0 這樣的 滿足ms % 60 這個就多了

 

NO.9  優柔寡斷的返回值

    public static void main(String[] args) {
        System.out.println(decisor());
    }
    
    public static boolean decisor(){
        try {
            return true;
        } finally {
            return false;
        }
    }

你覺得會返回的是什么？

答案是 false；

那你再看一個：

NO.10  你好，再見

    public static void main(String[] args) {
        try {
            System.out.println("Hello world");
            System.exit(0);
        } finally{
            System.out.println("GoodBye world");
        }
    }

你又會覺得會返回的是什么？

答案是 僅僅只有 Hello world

NO.11  打開Javac進程

 

public static void main(String[] args) {
        try {
            Runtime runtime = Runtime.getRuntime();
            Process proc = runtime.exec("C:\\Program Files\\Internet Explorer\\iexplore.exe");
            int exitVal = proc.exitValue();
            System.out.println("process exitVal :" + exitVal);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 

運行時你會發現IE啟動了  但是拋異常了

Exception in thread "main" java.lang.IllegalThreadStateException: process has not exited
    at java.lang.ProcessImpl.exitValue(Native Method)
    at Test.main(Test.java:9)

這個異常的原因是在我們打開IE的時候就執行了proc.exitValue()即返回退出時的值。可是我們還沒有退出IE啊 所以才會報異常

解決方法：給成

int exitVal = proc.waitFor();

這樣看起來沒什么啊，是啊 很好理解 那你再看一個

public static void main(String[] args) {
        try{            
            Runtime rt = Runtime.getRuntime();
            Process proc = rt.exec("javac");
            int exitVal = proc.waitFor();
            System.out.println("Process exitValue: " + exitVal);
        } catch (Throwable t){
            t.printStackTrace();
        }
    }

你運行的時候會發現程序會死在那里： 這是因為javac會一直等待它要執行的東西 所以一直在等待：

改正：

public static void main(String[] args) {
        try{            
            Runtime rt = Runtime.getRuntime();
            Process proc = rt.exec("javac");
            InputStream stderr = proc.getErrorStream();
            InputStreamReader isr = new InputStreamReader(stderr);
            BufferedReader br = new BufferedReader(isr);
            String line = null;
            System.out.println("<ERROR>");
            while ( (line = br.readLine()) != null)
                System.out.println(line);
            System.out.println("</ERROR>");
            int exitVal = proc.waitFor();
            System.out.println("Process exitValue: " + exitVal);
        } catch (Throwable t){
            t.printStackTrace();
        }
    }

運行結果：

<ERROR>
用法：javac <選項> <源文件>
其中，可能的選項包括：
  -g                         生成所有調試信息
  -g:none                    不生成任何調試信息
  -g:{lines,vars,source}     只生成某些調試信息
  -nowarn                    不生成任何警告
  -verbose                   輸出有關編譯器正在執行的操作的消息
  -deprecation               輸出使用已過時的 API 的源位置
  -classpath <路徑>            指定查找用戶類文件和注釋處理程序的位置
  -cp <路徑>                   指定查找用戶類文件和注釋處理程序的位置
  -sourcepath <路徑>           指定查找輸入源文件的位置
  -bootclasspath <路徑>        覆蓋引導類文件的位置
  -extdirs <目錄>              覆蓋安裝的擴展目錄的位置
  -endorseddirs <目錄>         覆蓋簽名的標准路徑的位置
  -proc:{none,only}          控制是否執行注釋處理和/或編譯。
  -processor <class1>[,<class2>,<class3>...]要運行的注釋處理程序的名稱；繞過默認的搜索進程
  -processorpath <路徑>        指定查找注釋處理程序的位置
  -d <目錄>                    指定存放生成的類文件的位置
  -s <目錄>                    指定存放生成的源文件的位置
  -implicit:{none,class}     指定是否為隱式引用文件生成類文件 
  -encoding <編碼>             指定源文件使用的字符編碼
  -source <版本>               提供與指定版本的源兼容性
  -target <版本>               生成特定 VM 版本的類文件
  -version                   版本信息
  -help                      輸出標准選項的提要
  -Akey[=value]              傳遞給注釋處理程序的選項
  -X                         輸出非標准選項的提要
  -J<標志>                     直接將 <標志> 傳遞給運行時系統

</ERROR>
Process exitValue: 2

NO.12  日志粒度的控制

public class BadLogger {
    private Logger m_log = null; 

    public BadLogger(Level l){
        ConsoleHandler ch = new ConsoleHandler();
        m_log = Logger.getLogger("no2.BadLogger.logger");
        ch.setLevel(l);
    }

    public void test(){                          
        System.out.println("The level for the log is: "+ m_log.getLevel());  
        m_log.finest("This is a test for finest");
        m_log.finer("This is a test for finer");
        m_log.fine("This is a test for fine");
        m_log.info("This is a test for info");
        m_log.warning("This is a warning test");
        m_log.severe("This is a severe test");
    }

    public static void main(String[] args){
        Level loglevel = Level.INFO;
        if ( args.length !=0 ){
            if ( args[0].equals("ALL") ){
                loglevel = Level.ALL;
            }
            else if ( args[0].equals("FINE") ){
                loglevel = Level.FINE;
            }
            else if ( args[0].equals("FINEST") ){
                loglevel = Level.FINEST;
            }
            else if ( args[0].equals("WARNING") ){
                loglevel = Level.WARNING;
            }
            else if ( args[0].equals("SEVERE") ) {
                loglevel = Level.SEVERE;
            }
        }
        BadLogger logex = new BadLogger(loglevel);
        logex.test(); 
    }
}

這是錯誤的寫法  你會發現不管你傳什么參數結果都是：

The level for the log is: null
2012-10-24 19:21:26 no2.BadLogger test
信息: This is a test for info
2012-10-24 19:21:26 no2.BadLogger test
警告: This is a warning test
2012-10-24 19:21:26 no2.BadLogger test
嚴重: This is a severe test

改正：

public class BadLogger {
    private Logger m_log = null; 

    public BadLogger(Level l){
        ConsoleHandler ch = new ConsoleHandler();
        m_log = Logger.getLogger("no2.BadLogger.logger");
        m_log.addHandler(ch);
        m_log.setLevel(l); 
        m_log.setUseParentHandlers(false);
        ch.setLevel(l);
    }

    public void test(){                          
        System.out.println("The level for the log is: "+ m_log.getLevel());  
        m_log.finest("This is a test for finest");
        m_log.finer("This is a test for finer");
        m_log.fine("This is a test for fine");
        m_log.info("This is a test for info");
        m_log.warning("This is a warning test");
        m_log.severe("This is a severe test");
    }

    public static void main(String[] args){
        Level loglevel = Level.INFO;
        if ( args.length !=0 ){
            if ( args[0].equals("ALL") ){
                loglevel = Level.ALL;
            }
            else if ( args[0].equals("FINE") ){
                loglevel = Level.FINE;
            }
            else if ( args[0].equals("FINEST") ){
                loglevel = Level.FINEST;
            }
            else if ( args[0].equals("WARNING") ){
                loglevel = Level.WARNING;
            }
            else if ( args[0].equals("SEVERE") ) {
                loglevel = Level.SEVERE;
            }
        }
        BadLogger logex = new BadLogger(loglevel);
        logex.test(); 
    }
}

這個時候輸入ALL這個參數結果就為：

The level for the log is: ALL
2012-10-24 19:23:31 no2.BadLogger test
最好: This is a test for finest
2012-10-24 19:23:31 no2.BadLogger test
較好: This is a test for finer
2012-10-24 19:23:31 no2.BadLogger test
良好: This is a test for fine
2012-10-24 19:23:31 no2.BadLogger test
信息: This is a test for info
2012-10-24 19:23:31 no2.BadLogger test
警告: This is a warning test
2012-10-24 19:23:31 no2.BadLogger test
嚴重: This is a severe test

 NO.13  遍歷容器的一些陷阱

three哪去了？

public class BadVisitor {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("one");
        v.add("two");
        v.add("three"); 
        v.add("four");
        Enumeration enume = v.elements();
        while (enume.hasMoreElements()){
            String s = (String) enume.nextElement();
            if (s.equals("two"))
                v.remove("two");
            else{
                System.out.println(s);
            }
        }
        System.out.println("What's really there...");
        enume = v.elements();
        while (enume.hasMoreElements()){
            String s = (String) enume.nextElement();
            System.out.println(s);            
        }
    }
}

運行結果：

one
four
What's really there...
one
three
four

改正：

public class GoodVisitor {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("one"); v.add("two"); v.add("three"); v.add("four");
        Iterator iter = v.iterator();
        while (iter.hasNext()){
            String s = (String) iter.next();
            if (s.equals("two"))
                iter.remove();
            else{
                System.out.println(s);
            }
        }
        System.out.println("What's really there...");
        iter = v.iterator();
        while (iter.hasNext()){
            String s = (String) iter.next();
            System.out.println(s);            
        }
    }
}