小石头软件

《Effective Java 2》读书笔记：第33条：用EnumMap代替序数索引

cool8jay — Sat, 04 Apr 2009 17:39:27 +0800

读到相和相变那个例子的时候，我自然想到一个问题：为什么不用Map<Map<Phase,Phase>,Transition>这样的结构来表示相和相变之间的关系？

细心地看一下，SOLID，LIQUID，GAS三个相根据排列组合能构成六个相变。但是，它们两两组成一个Map，却只能组成三个相变，因为键只有三个，不可能有诸如<SOLID,LIQUID>和<SOLID,GAS>这样的Map同时存在。所以，这个结构是不能用的。有一个例外，如果只有两个相，比如SOLID和GAS，则它两的排列组合与能够形成的Map个数碰巧是相等的，都是两个。这个情况过于特殊，很少会碰上，还是不用为妙，况且书中使用的结构才具有一般性。

书中用到的是Map<Phase,Map<Phase,Transition>>这样的结构，外层Map还是只有三个键，但内层Map（作为外层Map的值）又有三个键，而且Map的值是可以更新的，详见这篇文章。

跟踪Transition的初始化块可以看到，静态变量m（它是一个Map）的三个值（还是Map），都是由空Map，到含一个元素的Map，再到含两个元素的Map。Map对象不变，Map的内容改变。

对书上的代码作一点补充，好让它能独立运行：

public class EnumMapTest {
    public static void main(String[] args) {
        System.out.println(Phase.Transition.from(Phase.GAS, Phase.SOLID));
    }
 
    public enum Phase {
        SOLID, LIQUID, GAS;
 
        public enum Transition {
            MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
            BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
            SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID);
            final Phase src;
            final Phase dst;
 
            Transition(Phase src, Phase dst) {
                this.src = src;
                this.dst = dst;
            }
 
            // Initialize the phase transition map
            private static final Map<Phase, Map<Phase, Transition>> m =
                    new EnumMap<Phase, Map<Phase, Transition>>(Phase.class);
 
            static {
                for (Phase p : Phase.values()) {
                    m.put(p, new EnumMap<Phase, Transition>(Phase.class));
                }
                for (Transition trans : Transition.values()) {
                    m.get(trans.src).put(trans.dst, trans);
                    System.out.println(trans.src + " --> " + trans.dst + " : " + trans.name());
                }
            }
 
            public static Transition from(Phase src, Phase dst) {
                return m.get(src).get(dst);
            }
        }
    }
}

程序运行的结果是：
SOLID –> LIQUID : MELT
LIQUID –> SOLID : FREEZE
LIQUID –> GAS : BOIL
GAS –> LIQUID : CONDENSE
SOLID –> GAS : SUBLIME
GAS –> SOLID : DEPOSIT
DEPOSIT
前六行输出来自静态块，最后一行输出来自main方法。

勘误：

Luckily, there is a much better way to achieve the same effect. The array is effectively serving as a map from the enum to a value, so you might as well use a
Map.
幸运的是，有一种更好的办法可以达到同样的效果。数组实际上充当着从枚举到值的映射，因此可能还要用到Map。

as well和as well as容易混淆。正确的翻译：幸运的是，有一种更好的办法可以达到同样的效果。数组实际上充当着从枚举到值的映射，因此你不如就用一个Map。
There is no unsafe cast; no need to label the output manually, as the map keys are enums that know how to translate themselves to printable strings;
它没有不安全的转换；不必手工标注这些索引的输出，因为映射键知道如何将自身翻译成可打印字符串的枚举。

定于从句翻译错误。正确的翻译：它没有不安全的转换；不必手工标注这些索引的输出，因为映射键是枚举，它们知道如何将自身翻译成可打印字符串。
Note that the EnumMap constructor takes the Class object of the key type: this is a bounded type token, which provides runtime generic type information (Item 29).
注意EnumMap构造器采用键类型的Class对象：这是一个有限制的类型令牌，它提供了运行时的泛型信息（见第29条）。

take经常用在说某个方法/函数的参数那里，意思是该方法/函数带有/使用/接受什么样的参数。正确的翻译：注意EnumMap构造器采用键类型的Class对象作为参数：这是一个有限制的类型令牌，它提供了运行时的泛型信息（见第29条）。
以及phase和phase transition，正确的翻译是物理中的“相”和“相变”。

疑点：

And the size of the table is quadratic in the number of phases, even if the number of non-null entries is smaller.
This is a special case of the general principle that application programmers should rarely, if ever, use Enum.ordinal (Item 31).

《Effective Java 2》读书笔记：第32条：用EnumSet代替位域

cool8jay — Fri, 03 Apr 2009 18:34:07 +0800

勘误：

If the elements of an enumerated type are used primarily in sets, it is traditional to use the int enum pattern (Item 30), assigning a different power of 2 to each constant:
如果一个枚举类型的元素主要用在集合中，一般就使用int枚举模式（见第30条），将2的不同倍数赋予每个常量：

正确的翻译：如果一个枚举类型的元素主要用在集合中，一般就使用int枚举模式（见第30条），将2的不同次幂赋值给每个常量：

《Effective Java 2》读书笔记：第31条：用实例域代替序数

cool8jay — Thu, 02 Apr 2009 17:34:59 +0800

利用枚举常量的序数来做一些事情，比如排序，看似是个很不错的办法，因为枚举常量天生带有一个序数值。可细想就会发现这个天生的优势，弄不好就成了劣势。比如，你想对一个已有枚举增添新的常量，而新常量偏偏不是放到已有常量的末尾。问题就出来了，客户端代码很可能与原来的序数紧密相关，很难修改！

勘误

You may be tempted to derive an associated int value from the ordinal: 你可以试着从序数中得到关联的int值：

正确的翻译：你可能会从序数中得到关联的int值（你被误导了）：
Also, you can’t add a constant for an int value without adding constants for all intervening int values. 要是没有给所有这些int值添加常量，也无法给某个int值添加常量。

正确的翻译：而且，常量必须一一对应于连续的int值。（根据上下文意译）
At best, this is ugly. If many int values are unused, it’s impractical. 这么做顶多就是不好看。如果有许多int值都是从未用过的，可就不切实际了。

unused是闲置的，无用的，废弃的意思。正确的翻译：这么做顶多就是不好看。如果有许多int值都是无用的，可就不切实际了。

《Effective Java 2》读书笔记：第30条：用enum代替int常量

cool8jay — Wed, 01 Apr 2009 16:33:10 +0800

勘误：

Before enum types were added to the language, a common pattern for representing enumerated types was to declare a group of named int constants, one for each member of the type:
在编程语言还没有引入枚举类型之前，表示枚举类型的常用模式是声明一组具名的int常量，每个类型成员一个常量：

Java是在其1.5版本中引入枚举类型的（enum types）。正确的翻译：在Java还没有引入枚举类型之前，表示枚举类型的常用模式是声明一组具名的int常量，每个类型成员一个常量：
The compiler won’t complain if you pass an apple to a method that expects an orange, compare apples to oranges with the == operator, or worse:
如果你将apple传到想要orange的方法中，编译器也不会出现警告，还会用==操作符将apple与orange进行对比，甚至更糟糕：

正确的翻译：编译器对以下情况不会报错：1，你将apple传到需要orange的方法中；2，用==操作符将apple与orange进行比较；3，甚至是更糟糕的：
You may encounter a variant of this pattern in which String constants are used in place of int constants. This variant, known as the String enum pattern, is even less
desirable.
你还可能碰到这种模式的变体，在这种模式中使用的是String常量，而不是int常量。这样的变体被称作String枚举模式，同样也是我们最不期望的。

正确的翻译：你还可能碰到这种模式的变体，在这种模式中使用的是String常量，而不是int常量。这样的变体被称作String枚举模式，这更糟糕。
Java’s enum types are full-fledged classes, far more powerful than their counterparts in these other languages, where enums are essentially int values.
Java的枚举类型是功能十分齐全的类，功能必其他语言中的对等五要更强大得多，Java的枚举本质上是int值。

这个错远了。正确的翻译：Java的枚举类型是功能十分齐全的类，功能比其他语言中的枚举类型要更强大得多，它们本质上是int值。
Enums provide compile-time type safety. If you declare a parameter to be of type Apple, you are guaranteed that any non-null object reference passed to the parameter is one of the three valid Apple values. Attempts to pass values of the wrong type will result in compile-time errors, as will attempts to assign an expression of one enum type to a variable of another, or to use the == operator to compare values of different enum types.
枚举提供了编译时的类型安全。如果声明一个参数的类型为Apple，就可以保证，被传到该参数上的任何非null对象引用一定属于三个有效的Apple值之一。试图传递类型错误的值时，会导致编译时错误，就像试图将某种枚举类型的表达式赋给另一种枚举类型的变量，或者试图利用==操作符比较不同枚举类型的值一样。

正确的翻译：枚举提供了编译时的类型安全。如果声明一个参数的类型为Apple，就可以保证，被传到该参数上的任何非null对象引用一定属于三个有效的Apple值之一。试图传递类型错误的值，或者将某种枚举类型的表达式赋给另一种枚举类型的变量，或者使用==操作符比较不同枚举类型的值，都会导致编译时错误。

Java的枚举类型可以有效防止前面提到的三种常见的错误，而且是在编译时就能发现它们，这种类型安全检查对程序的正确性有很大提高。
You can add or reorder constants in an enum type without recompiling its clients because the fields that export the constants provide a layer of insulation between an enum type and its clients: the constant values are not compiled into the clients as they are in the int enum pattern. Finally, you can translate enums into printable strings by calling their toString method.
你可以增加或者重新排列枚举类型中的常量，而无需重新编译它的客户端代码，因为导出的常量的域在枚举类型和它的客户端之间提供了一个隔离层：常量值并没有被编译到客户端代码中，而是在int枚举模式之中。

正确的翻译：你可以增加或者重新排列枚举类型中的常量，而无需重新编译它的客户端代码，因为导出的常量的域在枚举类型和它的客户端之间提供了一个隔离层：常量值不像int枚举模式之中那样，被编译到客户端代码中。

在客户端使用了枚举类型之后，仍然可以对枚举类型进行一些修改，比如增加新的常量，重新排列常量的顺序（这个操作是有前提的：客户端的代码的行为不能依赖于枚举类型中常量的序数。当确实需要某种数字本质的属性时，应采用别的方法，见第31条和第33条），而不能删除已有的常量，这个很好理解，因为客户端已经在使用这个枚举类型了。
For a nice example of a rich enum type, consider the eight planets of our solar system.
举个有关枚举类型的好例子，比如太阳系中的8颗行星。

正确的翻译：举个富枚举类型的好例子。

Java的枚举类型本质是Java类，像其他类一样，可以有域和方法。最简单的枚举类型是只含有常量的形式，如果需要复杂一些的功能话，则在最简单形式的基础上，添加域和方法，即富枚举类型。
One way to achieve this is to switch on the value of the enum:
有一种方法是通过启用枚举的值来实现：

switch是Java中的一个关键字（key word）。正确的翻译：有一种方法是通过对枚举的值进行switch来实现：
This code works, but is isn’t very pretty. It won’t compile without the throw statement because the end of the method is technically reachable, even though it will never be reached [JLS, 14.2.1].
这段代码可行，但是不太好看。如果没有throw语句，它就不能进行编译，虽然从技术角度来看代码的结束部分是可以执行到的，但是实际上是不可能执行到这行代码的[JLS，14.2.1]。

正确的翻译：这段代码可行，但是不太好看。从技术角度看，如果没有throw语句，程序是可以执行到方法结尾处的，但这会导致编译时出错，因为apply方法必须返回一个double值。而实际上我们不会让程序执行到方法结尾处，因为swtich中的表达式必然会满足四个case之一[JLS，14.2.1]。

本质问题是方法含有一个没有default的switch，却用throw来结束方法，怪怪的。
Enums are, generally speaking, comparable in performance to int constants.
一般来说，枚举会有限使用comparable而非int常量。

正确的翻译：一般来说，枚举在性能上与int常量差不多。
The enum feature was specifically designed to allow for binary compatible evolution of enum types.
专门设计枚举特性是考虑到枚举类型的二进制兼容演变。

正确的翻译：Java的枚举特性被专门设计为允许枚举类型的二进制可兼容演变。

[JSL,13,4,26]就是讲的这一条：枚举的演变/进化（Evolution of Enums）

13.4.26
Adding or reordering constants from an enum type will not break compatibility with pre-existing binaries.
添加或者重新排序枚举类型的常量不会破坏已经存在的二进制代码的兼容性。

If a precompiled binary attempts to access an enum constant that no longer exists, the client will fail at runtime with a NoSuchFieldError. Therefore such a change is not recommended for widely distributed enums.
如果一个以前编译好的二进制代码试图访问一个不存在的枚举常量，客户端将在运行时报NoSuchFieldError错误。因此，不推荐对已经大量被使用的枚举进行这样的修改（指删除常量）。

In all other respects, the binary compatibility rules for enums are identical to those for classes.
从其他所有方面来看，针对枚举的二进制兼容性规定与针对其它类的规定完全相同。
Many enums require no explicit constructors or members, but many others benefit from associating data with each constant and providing methods whose behavior is affected by this data.
许多枚举都不需要显式的构造器或者成员，但许多其他枚举则受益于“每个常量与属性的关联”以及“提供行为受这个属性影响的方法”。

正确的翻译：许多枚举都不需要显式的构造器或者成员，但许多其他枚举则受益于“每个常量与数据的关联”以及“提供行为受这个数据影响的方法”。

疑点:

[JLS]没有14.2.1这个章节呢？

参考文章：

《深入Java 1.5枚举类型的内部》，这篇文章与本条目讨论的话题基本一致。
《So you want to change the Java Programming Language…》，这篇文章讲了Java的开发者们是如何修改Java语言的，它以枚举为例，概括性地说明了Java的枚举是怎么来滴。

《Effective Java 2》

cool8jay — Sun, 22 Mar 2009 12:39:07 +0800

同事极力推荐的一本书，理由是Java之父James Gosling做过这样的评价：

“I sure wish I had this book ten years ago. Some might think that I don’t need any Java books, but I need this one.”

“我很希望10年以前就拥有这本书。可能有人认为我不需要任何Java方面的书籍，但是我需要这本书。”

既然他都想拥有这本书，我等就更有必要了。

这不是一本教科书，而是一本学习笔记。作者通过自己多年的开发经验，对如何正确使用Java提出了有益有效的建议。他不仅仅是告诉你How，更要告诉你Why。所以说，这本书绝对不适合初学者，而是针对有过一定开发经验的程序员，引发他们进行深入的思考。

书中少量条目比较简单，易懂，看过就会用，属于操作级别的建议。还有很多条目，涉及到更深的方面，如建模，算法，架构等等，难度较大，需要反复研读，应用，揣摩。

中文版整体翻译质量还可以，错误率不高，平均两三页才有一个明显的翻译错误（隐藏的错误还会更多）。原因还是太仓促，太急着出书。另外，书的排版有一些问题：与英文版的相比，书的每一页没有标出具体条目的编号和标题；原书中重点的部分用的是粗体字，而中文版仅换了种中文字体，很不明显；少量地方，原书指明参考页码，也被去掉了。纸张很一般，毕竟价格与原版相比，便宜不少。

总的来说，打70分。置于案头常备，仍然是先看中文版，再看英文版，自己总结心得。

神兽之歌

cool8jay — Sat, 07 Mar 2009 14:36:35 +0800

伟大神兽之歌。

不能看YouTube的，请点这里下载。

Java：正则表达式

cool8jay — Tue, 03 Mar 2009 14:38:56 +0800

正则表达式适用范围非常广泛，只要涉及到文本编辑，几乎都有用武之地。

在Java中，这样一个小例子：

String str = "\\sss\\";
String str1 = str.replace("\\", "_");
String str2 = str.replaceAll("\\\\", "_");
System.out.println(str1);
System.out.println(str2);

上面两个替换的结果都是“_sss_”，但原理上略有区别。

relace()方法使用的是普通的字符替换，replaceAll()方法使用的是正则表达式替换。这可以从两者的第一个参数的差异看出来：

replace()的第一个参数是charset，这是一个接口，我们实际传入的是一个String（当然，String实现了这个接口）。
replaceAll()的第一个参数是String regex，它表示的是一个正则表达式。

分析一下“\\\\”，第一个反斜杠是转义符，第二个反斜杠是反斜杠本身，第三个反斜杠是转义符，第四个反斜杠是反斜杠本身。

有两点要清楚：

Java中，字符串表示反斜杠需要转义，用两个反斜杠，即“\\”；
正则表达式中，表示反斜杠需要转义，同样是用两个斜杠，即“\\”。

这样就比较好解释：
先要表示正则表达式里面的反斜杠“\\”，然后再用字符串表示出来。而这两个反斜杠分别需要一个转义符，这样就成了：用四个反斜杠作为replaceAll()的第一个参数里表示正则表达式的一个反斜杠。

Java：非标准ICC Profile图片处理

cool8jay — Sat, 28 Feb 2009 15:00:02 +0800

项目中有一个缩略图批处理功能，用到Java自带的ImageIO和JPEG Codec，处理结束后，发现某些图片变的很暗淡。

原因是这些图片源文件的ICC Profile是Nikon sRGB 4.0.0.3001，而Java的ImageIO不支持这种非常规Profile，在网上搜了一下，找到这个解决方法。

/**
 * Jpeg files saved with the ICC profile "Nikon sRGB 4.0.0.3001" do not load properly using Java ImageIO.read().
 * The image in this case is far too dark, but the colors are not swapped.
 */
public class ImageReaderUtils {
    public static BufferedImage read(File file) throws IOException {
        BufferedImage image = null;
        ImageInputStream iis = ImageIO.createImageInputStream(file);
        if (iis == null) {
            throw new IOException("File not found");
        }
        Iterator<ImageReader> iir = ImageIO.getImageReaders(iis);
        boolean looking = true;
        ImageReader reader = null;
        ImageReadParam param = null;
        while (looking && iir.hasNext()) {
            reader = iir.next();
            reader.setInput(iis);
            param = reader.getDefaultReadParam();
            Iterator it = reader.getImageTypes(0);
 
            while (looking && it.hasNext()) {
                ImageTypeSpecifier type = (ImageTypeSpecifier) it.next();
                ColorSpace cs = type.getColorModel().getColorSpace();
                if (cs.isCS_sRGB()) {
                    param.setDestinationType(type);
                    looking = false;
                }
                if (cs.getType() != ColorSpace.TYPE_RGB) {
                    looking = false;
                }
            }
        }
        if (reader != null) {
            image = reader.read(0, param);
        }
        return image;
    }
 
    /**
     * ONLY USED FOR TEST
     * <p/>
     * STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
     * <p/>
     * Use Nikon Picture Project to save a JPEG, this will add the ICC profile "Nikon sRGB 4.0.0.3001" to the Jpeg.
     * Use ImageIO.read to create a BufferedImage from the Jpeg file.
     * <p/>
     * EXPECTED VERSUS ACTUAL BEHAVIOR :
     * <p/>
     * EXPECTED - An image that displays as it does when loaded with  customer  PhotoShop.
     * <p/>
     * ACTUAL - The image was far too dark, close to totally black.
     */
    ImageReaderUtils() {
        JFrame frame = new JFrame();
        JLabel bugLabel = new JLabel("bug not loaded");
        JLabel fixLabel = new JLabel("fix not loaded");
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        File file = new File("/Users/admin/Desktop/model.jpg");
        try {
            BufferedImage bug = ImageIO.read(file);
            bugLabel = new JLabel("buggy", new ImageIcon(bug), SwingConstants.LEFT);
            BufferedImage fix = read(file);
            fixLabel = new JLabel("fixed", new ImageIcon(fix), SwingConstants.LEFT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        frame.getContentPane().add(bugLabel, BorderLayout.NORTH);
        frame.getContentPane().add(fixLabel, BorderLayout.SOUTH);
        frame.pack();
        frame.setVisible(true);
    }
 
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new ImageReaderUtils();
            }
        });
    }
}

代码中使用的源图是：

测试结果是：

jQuery－图片拖拽排序

cool8jay — Sat, 07 Feb 2009 16:55:33 +0800

第一次用jQuery，想实现一个简单的图片拖拽排序功能，在网上啊找啊，终于找到一个将就可以用的。

网上的资料太多，太乱，转来转去，完全没有质量保证。

自己研究了一下，精简到最基本的必要内容，保证能用。

点击下载源代码。

后补：实际上这个程序由jQuery核心+INTERFACE界面构成。

点滴思考

cool8jay — Sun, 01 Feb 2009 18:58:57 +0800

过年没有回家，原因很多。一是没有买到火车票，又不想忍受其他的方式辗转；二是想着回家也不过是懒散地窝在家里混日子。于是就决定留下来，一个人，在灰色的水泥钢筋森林里面体验一下青灯自守的滋味。

给家里打电话报告自己的决定，父母也痛快地答应了，还嘱咐我：“储备好年货，过年商店是不开门的”。我说：“过年期间是超市生意最旺的时候，不会关门的。”“做饭遇到问题就打电话回家问你爸”。我笑到：“做饭炒菜的时候，哪来多余的手打电话？”

在公司的最后一天，大家都心不在焉。有几个人急着赶火车，赶飞机，便早早地告假走掉。这更让剩下的人心急火燎，如坐针毡。好不容易熬到了下班，所有人，除了老板和我，以最快的速度，奔。

老板得知我过年会留在这里，不回家，问我需要什么，他一定会帮忙。我当然不会浪费这个机会，就请他让我把我工作用的电脑带回家，理由是可以看看书。他爽快地同意了，我也向他保证，年后开工前一天，我会把电脑还回公司。

我要看的书是一本不可多得的书，网上有很多推荐。我平时不爱读书，因为自己想像力不够发达，对多数书中的描绘毫无心灵上的通感。这本书没有这种个体化的特例描述，很适合我的口味。更重要的是，它是一本内容绝对唯物，很有启发意义的书。在茫茫书海中，可称“奇书”，呵呵，倒也讽刺，书，本来不就该这样么？

书的主要内容是中国当代经济活动的现象分析和规律总结。篇幅有200多页，我花了3个晚上看完。每次看完一部分，我就觉得头脑发热，眼前浮现出很多社会画面，佩服作者的眼光和勇气，还有入木，不，是入铁三分的笔锋。

由于我的教育背景，一个标标准准的理科学生，主要关注自然科学方面的东西。研究它们的规律，并加以利用。社会科学给我的感觉一度是不清晰的，一方面是因为它的现象非常复杂，另一方面也是我兴趣不在这里。但我隐约中仍然相信一点：万物是按规律运行的。

很早就学过马克思的《资本论》，它揭示了人类社会发展最核心的规律：生产力与生产关系的规律。我对它的认识直到看完这本书才算跨越了最有意义的一步。这条规律不仅得到历史无可辩驳的证实，更重要的是，现在，它还在扩大它的“证人”和“证据”的集合。毫无疑问，在人类消亡以前的未来中，它还会继续应验。

很多人惊讶历史车轮的巨大力量，感叹凡夫俗子无力抵抗，一个傻瓜问题便是：你既然清楚这一点，为什么不顺应它，去做人，做事呢？

我以前一直秉持“不予置评”的态度去观察很多事情。但是，正所谓“话不说不清，理不辩不明”，即使你掌握“金科玉律”，不晓以世人，那就是浪费，是糟贱，是犯罪。所以，以后遇到什么事情，有感的时候，我也应该发一发。没有有偏见的评论，就没有无偏见的评论。

末了，这本书的名字我不能说，自己开动脑筋，上下求索吧。