来自

C:\temp\file.txt" - this is a path, an absolute path, a canonical path

.\file.txt This is a path, It's not an absolute path nor canonical path.

C:\temp\myapp\bin\..\\..\file.txt This is a path, and an absolute path, it's not a canonical path

Canonical path is always an absolute path.

import java.io.File;
public class PathTesting {
        public static void main(String [] args) {
                File f = new File("test/.././file.txt");
                System.out.println(f.getPath());
                System.out.println(f.getAbsolutePath());
                try {
                        System.out.println(f.getCanonicalPath());
                }
                catch(Exception e) {}
        }
}

test\..\.\file.txt
C:\projects\sandbox\trunk\test\..\.\file.txt
C:\projects\sandbox\trunk\file.txt

35
下面程序模拟一个简单的时钟
int minutes = 0;
for (int ms = 0; ms < 60*60*1000; ms++)
  if (ms %  60*1000 == 0)
     minutes++;
 System.out.println(minutes);
结果是60000，问题在于布尔表达式ms % 60*1000 == 0，最简单的修改方法是：if (ms % (60 * 1000) == 0)
更好的方法是用合适命名的常量代替魔力数字：

private static final int MS_PER_HOUR = 60 * 60 * 1000;
private static final int MS_PER_MINUTE = 60 * 1000;
public static void main(String[] args) {
   int minutes = 0;
   for (int ms = 0; ms < MS_PER_HOUR; ms++)
     if (ms % MS_PER_MINUTE == 0)
        minutes++;
    System.out.println(minutes);
}
绝不要用空格来分组；使用括号来决定优先级

问题出在 j = j++; 等同于下列操作：

int tmp = j; j = j + 1; j = tmp;
这次的教训和难题7一样：在一个表达式中不要给同一个变量赋值超过一次。

26

public static final int END = Integer.MAX_VALUE;
public static final int START = END - 100;
public static void main(String[] args) {
    int count = 0;
    for (int i = START; i <= END; i++)
       count++;
     System.out.println(count);
}
看起来像100，再仔细看循环是小于等于，应该是101？结果是程序没有输出任何值，陷入一个死循环。问题出在Integer.MAX_VALUE，当继续增加的时候，他悄悄变为Integer.MIN_VALUE。如果你需要循环int值边界，最好用long变量做索引：
for (long i = START; i <= END; i++)  //输出101
教训是：ints are not integers。无论何时用基本类型，注意边界值。上溢或下溢会出现什么情况？一般来说最好用大一点的类型（基本类型是byte, char, short, int, and long）。也可以不用long：

int i = START;
do {
  count++;
} while (i++ != END);
考虑到清晰和简单，总是用long索引，除了一种特殊情况：如果要遍历所有int值，这样用int索引的话会快两倍。
一个循环四十亿int值，调用方法的常规用法：

// Apply the function f to all four billion int values
int i = Integer.MIN_VALUE;
do {
f(i);
} while (i++ != Integer.MAX_VALUE);

27  位移
记住java是使用二进制补码计算，在任何有符号基本类型中(byte, short, int, or long)都是用所有位置1来表示-1。
        int i = 0;
        while (-1 << i != 0)       //左位移
            i++;
        System.out.println(i);
int型的-1用0xffffffff 表示。不断左移，右边由0补位。移位32次，变为全0，跳出循环打印32？实际上程序会死循环。问题出在-1<<32不等于0而是等于-1，因为位移符号只用右边操作数的低五位作为移动距离，如果左操作数是long的话用六位。三个位移操作符：<<,>>,>>>都是这样。移动距离总是0到31，左边操作数是long的话0到63。位移距离用32取模，左边是long则用64取模。给int值位移32位或给long值位移64位只会返回本身。所以不可能用位移完全移除一个数据。幸运的是，有一个简单的办法解决这个问题。保存上一次的位移结果，每一次迭代多移动一位。
        int distance = 0;
        for (int val = -1; val != 0; val <<= 1)
            distance++;
        System.out.println(distance);
修改后的程序说明了一个原则：位移距离如果可能的话，用常量。
另外一个问题，许多程序员认为右移一个负的移动距离，就和左移一样，反之亦然。事实上不是这样，左移是左移，右移就是右移。负数距离只留下低五位（long留六位），其余的置0就变为了正数距离。比如，左移一个int值-1的距离，实际上是左移31位。

28 无穷的表示
for (int i = start; i <= start + 1; i++) {
}
看起来循环两次就会结束，如果这样定义呢：
int start = Integer.MAX_VALUE - 1;//死循环
while (i == i + 1) {
}
这个不可能死循环？如果i是无穷呢？Java采用IEEE 754浮点数算术，用double或float来表示无穷。所以可以用任何浮点数计算表达式得出无穷来初始化i。比如：double i = 1.0 / 0.0;
更好的是可以利用标准库提供的常量:double i = Double.POSITIVE_INFINITY;
事实上，根本用不着用无穷初始化i来引起死循环。只要足够大的浮点数就够了：double i = 1.0e40;
这是因为浮点数越大，他的值和下一个数的值距离也就越大。distribution of floating-point values is a consequence of their representation with a fixed number of significant bits. 给足够大的浮点数加一不会改变值，因为他不能填充这个数和下一个数之间的距离。浮点数操作返回最接近准确数学结果的浮点值。一旦两个相邻浮点值之间的距离大于2，加1就不会有效果。float类型来说，超过2²⁵（或33,554,432）再加1就无效；对double来说超过2⁵⁴（接近1.8 x 10¹⁶）再加1就无效。
     相邻浮点数之间的距离称为ulp（unit in the last place的缩写）。在Java 5里 Math.ulp方法被引入来计算float或double值的ulp。

总结：不可能用float或double来表示无穷。另外，在一个大的浮点数上加一个小的浮点数，值不会改变。有点不合常理，实数并不是这样。记住二进制浮点数计算只是近似于实数计算。

29 NaN

while (i != i) { }
IEEE 754 浮点数计算保留了一个特殊值来来表示不是数字的数量。NaN是浮点计算不能很好定义的数，比如0.0 / 0.0。规范定义NaN不等于任何数包括自己。因此double i = 0.0 / 0.0; 可让开始的等式不成立。也有标准库定义的常量：double i = Double.NaN; 如果一个或多个操作数为NaN，那么浮点数计算就会等于NaN。

总结：float和doule存在特殊的值NaN，小心处理。

30
while (i != i + 0) { } 这一次不能使用float或者double。
+操作符除了数字，就只能处理String。+操作符会被重载：对于String类型，他做的是连接操作。如果操作数有非String类型，会先做转换变为String之后再做连接。i一般用作数字，要是对String型变量这么命名容易引起误解。

总结：操作符重载非常容易误导人。好的变量名，方法名，类名和好的注释对于程序的可读性一样重要。

yuxh 2010-11-15 16:39 发表评论

]]>

和其他已存在的对象交流：
public class Student {
    // Details omitted.
    // Constructor.
    public Student(String major) {
        // Alert the student's designated major department that a new student has
        // joined the university.
        // Pseudocode.
        majorDept.notify(about this student ...);
    // etc.
    }
    // etc.
}

好习惯：如果需要有参数的构造函数，最好同时显示声明一个无参构造函数。
容易出现的bug：如果给构造函数加上void编译会通过！不过会被当作方法而不是构造函数！
当有多个构造函数，而且都有共同的初始化内容时，就会出现很多重复的代码，比如构造一个新学生，我们会做：
1 通知登记办公室学生的存在
2 给学生创建学生成绩报告单
重复引起以后修改必须修改多处，如果使用this 会得到改善

public class Student {
 // Attribute details omitted.
 // Constructor #1.
 public Student() {
// Assign default values to selected attributes ... details omitted.
// Do the things common to all three constructors in this first
// constructor ...
// Pseudocode.
alert the registrar's office of this student's existence
// Create a transcript for this student.
transcript = new Transcript();
}

 // Constructor #2.
 public Student(String s) {
  // ... then, REUSE the code of the first constructor within the second!
  this();
  // Then, do whatever else extra is necessary for constructor #2.
  this.setSsn(s);
 }

 // Constructor #3.
 public Student(String s, String n, int i) {
  // ... and REUSE the code of the first constructor within the third!
  this();
  // Then, do whatever else extra is necessary for constructor #3.
  this.setSsn(s);
  this.setName(n);
  this.setAge(i);
 }
 // etc.
}