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);            
        }
    }
}