BlogJava-Jiangshachina-随笔分类-CoreJavaTechTips

在泛型中使用通配符和继承(译)

Sha Jiang — Mon, 28 Dec 2009 05:44:00 GMT

在泛型中使用通配符和继承

    本文是Sun官方以Blog形式发布的Java核心技术窍门(JavaCoreTechTip)中的一篇，它以非常简洁的示例展示了泛型通配符的使用，初学Java泛型的朋友可以看看。(2009.12.30最后更新)
    Java2平台，标准版5.0(J2SE 5.0)为Java程序设计语言及其平台引入了泛型。在最简单的案例和典型的应用中，泛型能够识别集合容器中所存储的是否是你所期望的对象。所以，你可以特别说你有一个String或其它类型对象的List，而不是声称你的程序有一个Object的List。所以，如果你不小心向该List中加入了错误类型的对象，编译器会告之你这个错误。该错误将在编译时进行修复，而不用等到你运行该程序，且在程序运行到该处代码时，在获取对象的操作中产生一个运行时的强制类型转换异常。
这就提出了泛型的第二个好处。迭代器将变得类型安全了。Iterator接口中的next()方法将会返回集合中下一个元素的类型安全版本。
    但这并不是本文要介绍的泛型应用的窍门，那些窍门已由2005 Core Java Technologies Tip描述过了。在使用泛型时，大多数人都不能很好地理解对extends关键字的使用。一个典型的描述如何使用extends关键字的示例与绘制图形有关。与其不同的是，此处窍门所用的示例将使用Swing组件，以便你不必创建额外的新类。在一个非常有限的例子中，Swing按钮组件的类层次结构如下所示，当然，Object是实际上的根。

所有AbstractButton的子类都共同享有的一个东西就是方法getText。这就是泛型的精髓，你能定义一个方法去处理以AbstractButton为元素的List，并返回这些按钮的String类型的标签的List。下面是该方法的第一个版本：

public static List<String> getLabels(List<AbstractButton> list) {
    List<String> labelList = new ArrayList<String>(list.size());
    for (AbstractButton button: list) {
        labelList.add(button.getText());
    }
    return labelList;
}

下面就是如何使用该方法。首先，定义一个AbstractButton类型的List，然后向其中填充值，并调用该方法：

List<AbstractButton> buttonList = new ArrayList<AbstractButton>();
buttonList.add(new JButton("Hello"));
buttonList.add(new JCheckBox("World"));
buttonList.add(new JRadioButton("Hola"));
buttonList.add(new JMenuItem("Mundo"));

List labels = getLabels(buttonList);
System.out.println(labels);

根据Google，"Hola, Mundo"是"Hello, World"的西班牙译文。调用println()方法的结果如下所示：
[Hello, World, Hola, Mundo]

对于AbstractButton的List对象，一切都能正常运行，但当是其它类型，特别是AbstractButton子类型的List时，就不能正常工作了。从逻辑上，有人可能认为对于以JButton为元素的List，一切仍能正常工作。因为JButton是AbstractButton的子类。难道不能对AbstractButton子类型的List调用方法getLabels(List)？
然而，事实并非如此。因为这是一个编译时检查，同时也因为getLabels方法被定义为只接受AbstractButton的List，你不能向该方法中传入任何其它类型的List。

GetList.java:13: getLabels(java.util.List<javax.swing.AbstractButton>)
  in GetList cannot be applied to (java.util.List<javax.swing.JButton>)

    List<String> labels = getLabels(buttonList);
                          ^
1 error

这也就是extends关键字发挥作用的地方了。不将getLabes方法定义为仅仅接受AbstractButton List，而是将它定义为接受AbstractButton子类的List：

public static List<String> getLabels(
List extends AbstractButton> list)

此处的通配符?表明该方法并不关心确切的类型是什么，只要它是AbstractButton的子类型即可。下面是综合了前述所有代码片断的完整示例程序：

import java.util.*;
import javax.swing.*;

public class GetList {
    public static void main(String args[]) {
        List<JButton> buttonList =
                new ArrayList<JButton>();
        buttonList.add(new JButton("Hello"));
        buttonList.add(new JButton("World"));
        buttonList.add(new JButton("Hola"));
        buttonList.add(new JButton("Mundo"));

        List labels = getLabels(buttonList);
        System.out.println(labels);
    }

    public static List<String> getLabels(
            List extends AbstractButton> list) {
        List<String> labelList = new ArrayList<String>(list.size());
        for (AbstractButton button: list) {
            labelList.add(button.getText());
        }
        return labelList;
    }
}

现在，当你要用泛型来定义你自己的类和方法时，就要考虑接受作为泛型参数的抽象类，或它的任一超类，记得使用通配符以便相同的方法对于子类也能很好地工作。
更多关于泛型的信息，请见两篇较早前由Gilad Bracha撰写的教程：一篇是2004年的教程(PDF)，另一篇是在线的Java Tutorial中的泛型章节。

Sha Jiang 2009-12-28 13:44 发表评论

使用Callable返回结果(译)

Sha Jiang — Sat, 31 May 2008 14:24:00 GMT

使用Callable返回结果

    本文是Sun官方以Blog形式发布的Java核心技术窍门(JavaCoreTechTip)中的一个。本文主要介绍了Callable及其相关接口和类的使用，篇幅不长且易于理解，故翻译在了此处，相信对于准备或刚接触java.util.concurrent的朋友会有所帮助。(2008.05.31最后更新)

    自从Java平台的最开始，Runnable接口就已存在了。它允许你定义一个可由线程完成的任务。如大多数人所已知的那样，它只提供了一个run方法，该方法既不接受任何参数，也不返回任何值。如果你需要从一个未完成的任务中返回一个值，你就必须在该接口之外使用一个方法去等待该任务完成时通报的某种消息。例如，下面的示例就是你在这种情景下可能做的事情：
    Runnable runnable = ...;
    Thread t = new Thread(runnable);
    t.start();
    t.join();
    String value = someMethodtoGetSavedValue()
严格来说，上述代码并无错误，但现在可用不同的方法去做，这要感谢J2SE 5.0引入的Callable接口。不同于Runnable接口拥有run方法，Callable接口提供的是call方法，该方法可以返回一个Object对象，或可返回任何一个在泛型化格式中定义了的特定类型的对象。
    public interface Callable {
       V call() throws Exception;
    }
因为你不可能把Callable对象传到Thread对象去执行，你可换用ExecutorService对象去执行Callable对象。该服务接受Callable对象，并经由submit方法去执行它。
    Future submit(Callable task)
如该方法的定义所示，提交一个Callable对象给ExecutorService会返回一个Future对象。然后，Future的get方法将会阻塞，直到任务完成。
    为了证明这一点，下面的例子为命令行中的每个词都创建一个单独的Callable实例，然后把这些词的长度加起来。各个Callable对象将只是计算它自己的词的长度之和。Futures对象的Set集合将被保存以便从中获得计算用的值。如果需要保持返回值的顺序，则可换用一个List对象。

import java.util.*;
import java.util.concurrent.*;

public class CallableExample {

    public static class WordLengthCallable
            implements Callable {
        private String word;
        public WordLengthCallable(String word) {
            this.word = word;
        }
        public Integer call() {
            return Integer.valueOf(word.length());
        }
    }

    public static void main(String args[]) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        Set<Future<Integer>> set = new HashSet<Future&lg;Integer>>();
        for (String word: args) {
            Callable<Integer> callable = new WordLengthCallable(word);
            Future<Integer> future = pool.submit(callable);
            set.add(future);
        }
        int sum = 0;
        for (Future<Integer> future : set) {
            sum += future.get();
        }
        System.out.printf("The sum of lengths is %s%n", sum);
        System.exit(sum);
    }
}

WordLengthCallable保存了每个词并使用该词的长度作为call方法的返回值。这个值可能会花点儿时间去生成，不过在这个例子中，可以立即知道它。 call方法的唯一要求是这个值要在call方法的结尾处返回。当Future的get方法稍后被调用时，如果任务运行得很快的话，Future将会自动得到这个值(如同本例的情况)，否则将一直等到该值生成完毕为止。多次调用get方法不会导致任务从该线程返回。因为该程序的目的是计划所有字的长度之和，它不会强令Callable任务结束。如果最后一个任务在前三个任务之前完成，也是没错的。对Future的get方法的第一次调用将只会等待Set中第一个任务结束，而不会阻塞其它的任务分别执行完毕。它只会等待当次线程或任务结束。这个特定的例子使用固定数线程池来产生ExecutorService对象，但其它有效的方法也是可行的。
关于执行器和线程池用法的更多信息，请见Java Tutorial中Executors一节。SwingWorker类是另一个使用Future的Runnable对象的例子，尽管有些微不同之处。更多信息请见Java Tutorial中Worker Threads and SwingWorker一节。

Sha Jiang 2008-05-31 22:24 发表评论

字符串排序(译)

Sha Jiang — Mon, 07 Apr 2008 01:10:00 GMT

字符串排序

本文是Sun官方以Blog形式发布的Java核心技术窍门(JavaCoreTechTip)中的一个。我之前尚未关注过java.text.Collator类，看过Sorting Strings这个tip之后觉得有些意义，故翻译在了此处，也希望对其它朋友有所助益。(2008.04.07最后更新)

使用Java平台进行字符串排序被认为是一件简单的工作，但为国际市场开发程序时，则需要有更多的考虑。如果你陷入只关注英语的心态中，并认为你的程序会工作的很好，因为它所显示的字符串从今往后都是一样的，你可能认为一切都很正常。但一旦你有一位西班牙用户，他希望能够正常地对mañana进行排序，但如果你都是使用String类中缺省的compare方法去做排序，字符ñ将会跟在字符z之后，而在正常的西班牙语排序中，ñ应该在字符n和o之间。这就是java.text包的类Collator发挥作用的地方了。
想像这样的一组词

first
mañana
man
many
maxi
next

使用String类的默认排序机制，即它的compare()方法，排序的结果将会是：

first
man
many
maxi
mañana
next

    此处，mañana出现在maxi与next之间。而在西班牙语世界中，mañana应该出现在many和maxi之间，因为在字母表中，字符ñ(读作eñe)跟在n之后。当来了一个德语用户，想用他们自己的变音符时，你就可以写一个自己的定制排序规则来处理ñ，否则一组使用façade的设计模式将会怎样呢？你是否想让façade出现在factory之前或之后呢？(关键是如同对c或其它字符那样去处理ç的小写变音符。)
    这就是类Collator能派上用场的地方了。类Collator用于对语言敏感的排序问题，并不会只基于它们的ASCII/Unicode字符去尝试排序。使用Collator要求你在完全应用它的特性之前要理解一个额外的属性，即称之为强度(Strength)的属性。Collator的强度设置决定了在排序时如何使用强(或弱)匹配。该属性有4个可能的值：PRIMARY，SECONDARY，TERTIARY和IDENTICAL。具体是哪个强度在产生作用取决于语言环境。典型地，会有如下的情况。按从后往前的顺序，IDENTICAL强度表示能够被进行相同的处理的字符必须是一致的。TERTIARY通常用于忽略大小写差异。SECONDARY用于忽略变音符，如n和ñ。 PRIMARY与IDENTICAL相似也是基于字母之间差异，但是当处理控制字符和发音时还是有所不同。查看Collator的javadoc，以获取更多关于这些强度之间的差异及分解(Decomposition)模式规则的信息。
    为了使用Collator，你需要先得到它的一个实例。你既可以调用getInstance方法以得到一个针对默认语言环境的Collator对象，也可以传递一个指定的Locale对象给getInstance方法以得到一个针对特定语言环境的Collator对象。例如，为了获得针对一个西班牙语的 Collator对象，你应使用new Locale("es")去创建一个西班牙语的Locale对象，然后将它传入getInstance方法中：

Collator esCollator =
Collator.getInstance(new Locale("es"));

假设针对该语言环境的默认Collator强度，针对西班牙语的默认强度是SECONDARY已经足够了。然后你将这个Collator对象如任一Comparator对象那样传入Collections类的sort方法的比较规则参数中，以得到排序后的List对象。

Collections.sort(list, esCollator);

操作之前的单词列表，你现在就会得到一个基于西班牙语字母表的恰当排序结果：

first
man
many
mañana
maxi
next

如果你在上述Collator中换用US的Locale对象，由于ñ并不是US中本有的字母，所以mañana将会出现在man和many之间。
这儿有一个简洁的例子以显示这些差异。 import java.awt.*;

import java.text.*;
import java.util.*;
import java.util.List; // Explicit import required
import javax.swing.*;
public class Sort {
    public static void main(String args[]) {
        Runnable runner = new Runnable() {
            public void run() {
                String words[] = {"first", "mañana", "man",
                    "many", "maxi", "next"};
                List list = Arrays.asList(words);
                JFrame frame = new JFrame("Sorting");
                frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
                Box box = Box.createVerticalBox();
                frame.setContentPane(box);
                JLabel label = new JLabel("Word List:");
                box.add(label);
                JTextArea textArea = new JTextArea( list.toString());
                box.add(textArea);
                Collections.sort(list);
                label = new JLabel("Sorted Word List:");
                box.add(label);
                textArea = new JTextArea(list.toString ());
                box.add(textArea);
                Collator esCollator = Collator.getInstance(new Locale("es"));
                Collections.sort(list, esCollator);
                label = new JLabel("Collated Word List:");
                box.add(label);
                textArea = new JTextArea(list.toString());
                box.add(textArea);
                frame.setSize(400, 200);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater (runner);
    }
}

最后还有一点儿关于语言排序规则的信息。通过调用getInstance方法而得到的Collator对象通常是支持特定语言的RuleBasedCollator实例。你可使用RuleBasedCollator去定义你自己的排序顺序。该类的Javadoc更完整地描述了这种规则的语法，但还是让我们先假设你有一个4字符字母表，并希望字母的顺序是CAFE，而不是ACEF，你的规则看起来就像这样：

String rule =
"< c, C < a, A < f, F < e, E";
RuleBasedCollator collator = new RuleBasedCollator(rule);

上述规则通过展示不同字母的大小写定义了特定的字母顺序为cafe。现在对单词列表ace，cafe，ef和face使用新的规则进行排序，排序结果的顺序为cafe，ace，face和ef：

import java.text.*;
import java.util.*;

public class Rule {
    public static void main(String args[]) throws ParseException {
        String words[] = {"ace", "cafe", "ef", "face"};
        String rule ="< c, C < a, A < f, F < e, E";
        RuleBasedCollator collator = new RuleBasedCollator(rule);
        List list = Arrays.asList(words);
        Collections.sort(list, collator);
        System.out.println(list);
    }
}

在对上述代码编译并运行之后，你将看到使用新规则排序后的单词：

> javac Rule.java
> java Rule
[cafe, ace, face, ef]

请以后阅读Javadoc中更多的关于规则语法的信息，再尝试扩展字母表并处理不同的变音符。
现在，当你为全世界开发程序时，你的程序就能做出更好的准备以去适应本地用户了。也要确保字符串在资源包中，如之前的一个窍门所展示的那样：Earlier tip。(译注：原文并没有提供这个Earlier tip的正确链接地址。)

Sha Jiang 2008-04-07 09:10 发表评论