（一）如何使用JTree

英文文档地址： http://download.oracle.com/javase/tutorial/uiswing/components/tree.html

如何使用 Jtree

（1）创建树

（2）对节点的选择做出响应

（3）自定义树的外观表现

（4）动态改变一棵树

（5）创建树的数据模型

（6）懒加载孩子

（7）如何写expansion linstener

（8）如何写tree-will-expand listener

 

利用 JTree 类，你可以显示等级体系的数据。一个 JTree 对象并没有包含实际的数据；它只是提供了数据的一个视图。像其他非平凡的（ nontrivial ） Swing 组件一样，这种 Jtree 通过查询她的数据模型获得数据。这是一个 Jtree ：

如上面的图片所显示， Jtree 垂直显示它的数据。树中显示的每一行包含一项数据，称之为节点（ node ）。每颗树有一个根节点（ root node ），其他所有节点是它的子孙。默认情况下，树只显示根节点，但是你可以设置改变默认显示方式。一个节点可以拥有孩子也可以不拥有任何子孙。我们称那些可以拥有孩子（不管当前是否有孩子）的节点为“分支节点”（ branch nodes ），而不能拥有孩子的节点为“叶子节点”（ leaf nodes ）。

分支节点可以有任意多个孩子。通常，用户可以通过点击实现展开或者折叠分支节点，使得他们的孩子可见或者不可见。默认情况下，除了根节点以外的所有分支节点默认呈现折叠状态。程序中，通过监听 tree expansion 或者 tree-will-expand 事件可以检测分支节点的展开状态。监听事件在下面两节内容中描述 How to Write a Tree Expansion Listener and How to Write a Tree-Will-Expand Listener .

       在树中，一个节点可以通过 TreePath （一个囊括该节点和他所有祖先节点的路径对象）或者他的折叠行来识别。

       展开节点（ expanded node ）就是一个非叶子节点，当他的所有祖先都展开时，他将显示他的孩子。

       折叠节点（ collapsed node ）是隐藏了孩子们得的节点。

       隐藏节点（ hidden node ）就是折叠节点下的一个孩子

(1)创建一棵 Tree

       这里是一个应用程序的截图，上半部分展示了一个滚动面板（ scroll pane ）中的树（ Jtree ）。

      

    接下来的代码是从

http://download.oracle.com/javase/tutorial/uiswing/examples/components/TreeDemoProject/src/components/TreeDemo.java 获得，创建了一个JTree 对象，并将之放到一个scroll pane 上

//Where instance variables are declared:
	private JTree tree;
	...
	public TreeDemo() {
 	   ...
 	   DefaultMutableTreeNode top =
 	       new DefaultMutableTreeNode("The Java Series");
  	  createNodes(top);
  	  tree = new JTree(top);
   	 ...
    	JScrollPane treeView = new JScrollPane(tree);
   	 ...
	}

 

    这段代码创建了一个DefaultMutableTreeNode 实例作为根节点。接着创建树中剩下的其他节点。创建完节点后，通过指定刚才创建的根节点为JTree 构造函数的参数，创建一棵树。最后，将树放到滚动面板中，这是一个通常的策略，因为需要显示完一个树，而展开树需要另外比较大的空间。

    以下代码创建根节点以下的节点

private void createNodes(DefaultMutableTreeNode top) {
    DefaultMutableTreeNode category = null;
    DefaultMutableTreeNode book = null;
    
    category = new DefaultMutableTreeNode("Books for Java Programmers");
    top.add(category);
    
    //original Tutorial
    book = new DefaultMutableTreeNode(new BookInfo
        ("The Java Tutorial: A Short Course on the Basics",
        "tutorial.html"));
    category.add(book);
    
    //Tutorial Continued
    book = new DefaultMutableTreeNode(new BookInfo
        ("The Java Tutorial Continued: The Rest of the JDK",
        "tutorialcont.html"));
    category.add(book);
    
    //JFC Swing Tutorial
    book = new DefaultMutableTreeNode(new BookInfo
        ("The JFC Swing Tutorial: A Guide to Constructing GUIs",
        "swingtutorial.html"));
    category.add(book);

    //...add more books for programmers...

    category = new DefaultMutableTreeNode("Books for Java Implementers");
    top.add(category);

    //VM
    book = new DefaultMutableTreeNode(new BookInfo
        ("The Java Virtual Machine Specification",
         "vm.html"));
    category.add(book);

    //Language Spec
    book = new DefaultMutableTreeNode(new BookInfo
        ("The Java Language Specification",
         "jls.html"));
    category.add(book);
}

 

       DefaultMutableTreeNode 构造函数的参数是一个用户自定义的类对象，它包含或指向了关联树节点的数据。这个用户对象可以是一个字符串，或者是一个自定义的类。如果它实现了一个自定义对象，你应该要重新实现覆盖他的 toString 方法，这样他才能返回对应字符串作为节点显示的字符串。 Jtree 默认情况下，每个节点都是用 toString 的返回值作为显示。所以，让 toString 返回一些有意义的值是很重要的。有时候，覆盖 toString 方法是不可行的；在某些场景你可以通过重写 Jtree 的 convertValueToText 方法，映射模型对象到一个可显示的字符串。

       例如，前面 demo 中的 BookInfo 类是一个自定义类，它包含了两个字段：书名和描述该书本的 HTML 文件的 URL 路径。 toString 方法也重新实现，返回书名。从而，每个节点关联了一个 BookInfo 对象，并且显示书名。

       总之，你可以调用 Jtree 的构造函数创建一棵树，指定一个实现了 TreeNode 的类作为参数。你应该尽量把这棵树放到一个滚动面板中（ scroll pane ），这样树就不会占用太大的空间。对于树节点相应用户点击而展开和折叠的功能，你不需要做任何事情。但是，你一定要添加一些代码使得树在用户点击选择一个节点时能够作出反应，例如：

(2)对节点的选择作出响应

对于树节点的选择做出响应是简单的。你可以实现一个树节点选择监听器，并且注册在这棵树上。接下来的代码显示了 TreeDemo.java 中有关选择的代码：

//Where the tree is initialized:
  	 tree.getSelectionModel().setSelectionMode
            (TreeSelectionModel.SINGLE_TREE_SELECTION);
	
	//Listen for when the selection changes.
    tree.addTreeSelectionListener(this);
	...
	public void valueChanged(TreeSelectionEvent e) {
	//Returns the last path element of the selection.
	//This method is useful only when the selection model allows a single selection.
	    DefaultMutableTreeNode node = (DefaultMutableTreeNode)
	                       tree.getLastSelectedPathComponent();

 	   if (node == null)
 	   //Nothing is selected.	
 	   return;
	
    Object nodeInfo = node.getUserObject();
    if (node.isLeaf()) {
        BookInfo book = (BookInfo)nodeInfo;
        displayURL(book.bookURL);
    } else {
        displayURL(helpURL); 
    }
}

 

 

上面的代码执行了一下任务：

       1 ．获得树的默认 TreeSelectionModel （节点选择模式），然后设置它，使得在某一时刻只有一个节点被选中。

       2 ．注册了一个事件处理器。事件处理器是一个实现了 TreeSelectionListener 接口的对象。

       3. 在事件处理器中，通过调用 Tree 的 getLastSelectedPathComponent 方法获得选中的节点。

       4 ．使用 getUserObject 方法获得节点关联的数据。（节点 node 是一个非平凡组件，要通过它关联的数据模型获得真正的数据）

 

这里给出一些树节点的图片，分别通过 Java 、 Windows 和 MacOS 样式绘得。

（依次为 java look 、 windows look 和 MacOS look ）

像之前图片显示一样，一棵树按照惯例，对于每个基点显示了一个图标和一些文字。像我们简短的展示一样，你可以指定这些样式。

       一棵树通常表现一些外观和样式特效，通过不同的绘制图形指示节点间的关系。你可以在限制范围内自定义这些图形。首先，你可以使用 tree.setRootVisible(true) 设置显示根节点或者 tree.setRootVisible(false) 隐藏根节点。其次，你可以使用 tree.setShowsRootHandles(true) 请求设置树的顶层节点具有句柄（ +- 图标，点击句柄使其展开折叠）。如果顶层节点是根节点的话，需要保证它是可视的，如果是顶层节点则每个孩子都显示句柄。

       如果你使用 Java 样式，你可以自定是否在节点间显示行线来表现他们的关系。默认情况下， Java 样式使用“角线”（类似“ L ”）。通过设置 Jtree.lineStyle 的客户端属性，你可以指定一种不同的标准。例如，通过以下代码，这只 JAVA 样式仅使用水平线隔开一组节点：

      

tree.putClientProperty(“Jtree.lineStyle”,  “Horizontal”);

 

 

指定 JAVA 样式在节点间不显示任何行线，则使用以下代码：

 

tree.putClientProperty(“Jtree.lineStyle”,  “None”); 

(3)自定义树的外观表现

       接下来的一些截图显示了设置不同的 Jtree.lineStyle 属性（使用 JAVA 样式）

      

不管你使用那种样式（ java 、 windows 、 mac ） , 默认情况下，节点显示的图标决定于节点是否为叶子节点和是否可展开。例如，在 windwos 样式中，每个叶子节点的默认图标是一个点；在 JAVA 样式中，叶子节点默认图标是一个类似白纸的符号。在所有样式中，分支节点被一个文件夹符号所标识。不同样式对于可展开分支和对应的可折叠分支，可能有不同的图标。

       你可以很容易的改变叶子节点、可展开分支节点和可折叠分支节点的默认图标。如果要这样做的话，首先，你要创建一个 DefaultTreeCellRenderer 实例。你总是可以创建自己的 TreeCellRender ，让你喜欢的任何组件重复利用。接着，通过调用以下一个或多个方法去指定图标： setLeafIcon （对于叶子节点）， setOpenIcon （对于可展开分支节点）， setClosedIcon （对于可折叠节点）。如果你想要这棵树中各种节点都不显示图标，你就要指定图标为 null 。

一定你创建了这些图标，使用树的 setCellRender 方法去指定这个 DefaultTreeCellRender 来绘制它的节点。这里有一个来自 TreeIconDemo 的例子

 

ImageIcon leafIcon = createImageIcon("images/middle.gif");
if (leafIcon != null) {
    DefaultTreeCellRenderer renderer = 
	new DefaultTreeCellRenderer();
    renderer.setLeafIcon(leafIcon);
    tree.setCellRenderer(renderer);
}

 

这是一个截图：

    如果你想更精巧的控制节点图标，或者你想提供一些工具，你可以创建 DefaultTreeCellRender 的子类，然后覆盖他的getTreeCellRendererComponent 方法。因为DefaultTreeCellRenderer 是Jlabel 的一个子类，你可以使用任何Jlabel 的方法，例如setIcon 。

       下面代码来自 TreeIconDemo2.java ，创建了一个单元绘制器（ cell renderer ），它根据节点的文本数据是否包含单词“ Tutorial ”来改变了叶子节点的图标。这个 renderer 同样可以指定提示文本（ tool-tip ） --- 鼠标移到上面，出现提示。

 

//...where the tree is initialized:
    //Enable tool tips.
    ToolTipManager.sharedInstance().registerComponent(tree);
    
    ImageIcon tutorialIcon = createImageIcon("images/middle.gif");
    if (tutorialIcon != null) {
        tree.setCellRenderer(new MyRenderer(tutorialIcon));
    }
...
class MyRenderer extends DefaultTreeCellRenderer {
    Icon tutorialIcon;

    public MyRenderer(Icon icon) {
        tutorialIcon = icon;
    }

    public Component getTreeCellRendererComponent(
                        JTree tree,
                        Object value,
                        boolean sel,
                        boolean expanded,
                        boolean leaf,
                        int row,
                        boolean hasFocus) {

        super.getTreeCellRendererComponent(
                        tree, value, sel,
                        expanded, leaf, row,
                        hasFocus);
        if (leaf && isTutorialBook(value)) {
            setIcon(tutorialIcon);
            setToolTipText("This book is in the Tutorial series.");
        } else {
            setToolTipText(null); //no tool tip
        } 

        return this;
    }

    protected boolean isTutorialBook(Object value) {
        DefaultMutableTreeNode node =
                (DefaultMutableTreeNode)value;
        BookInfo nodeInfo =
                (BookInfo)(node.getUserObject());
        String title = nodeInfo.bookName;
        if (title.indexOf("Tutorial") >= 0) {
            return true;
        }

        return false;
    }
}

 

 

下面是结果的截图：

你可能会疑惑单元绘制器（ cell renderer ）是如何工作的。当一个 tree 在话每个节点的时候，不管是 Jtree 或是他的样式表现都包含了绘制节点的代码。 Tree 可以使用 cell renderer 的绘图代码代替前者去绘制节点。例如，画一个包含字符串“ The Java Programming Language ”的叶子节点， tree 会要求 cell renderer 返回一个组件，该组件能够绘制一个包含该字符串的叶子节点。如果这个 cell renderer 是一个 DefaultTreeCellRender ，它就返回一个 label （ DefaultTreeCellRender 继承于 Jlabel ），它绘制默认的叶子节点图标，紧随一段字符串。

         一个 cell renderer 仅绘制而不处理事件。如果你想要对一颗 tree 增加事件处理器，你需要在树上注册监听器，如果事件紧发生在某个节点被选择时，可以选择注册在 tree 的 cell editor 上。有关 cell editors 的资料可以参考 Concepts: Editors and Renderers . 这节将讨论 table cell editors 和 renderers ，他们类似于 tree cell editors 和 renderers 。

(4)动态地改变一棵 Tree

接下来的图片展示了一个叫 DynamicTreeDemo 的应用程序，它允许你从一颗可视 tree 中增加或者移除节点。你也可以编辑每个节点的文本。

这里给出了树初始化的代码：

      

rootNode = new DefaultMutableTreeNode("Root Node");
treeModel = new DefaultTreeModel(rootNode);
treeModel.addTreeModelListener(new MyTreeModelListener());

tree = new JTree(treeModel);
tree.setEditable(true);
tree.getSelectionModel().setSelectionMode
     (TreeSelectionModel.SINGLE_TREE_SELECTION);
tree.setShowsRootHandles(true); 

 

 

       通过明确的创建 tree 的模型（ model ），这段代码保证 tree 的 model 是 DefaultTreeModel 的实例。这样，我们知道所有 tree model 支持的方法。例如，我们可以调用 model 的 insertNodeInto 方法，几时这个方法不是 TreeModel 接口要求的。

       为使得树中节点的文本值可编辑，我们调用对 tree 调用 setEditable(true) 。当用户完成一个节点的编辑时，这个 model 产生一个 tree model 事件，它会告诉所有监听者（包括 Jtree ）：树节点被改变了。注意：尽管 DefaultMutableTreeNode 拥有改变一个节点内容的方法，但是改变还是需要通过 DefaultTreeModel 上面的方法。否则， tree model 事件就不能产生，事件的监听者（例如 tree ）就不能知道这些更新。

       为了通知“节点改变”，我们可以实现一个 TreeModelListener 。这里有一个关于 tree model 监听器的例子，当用户为一个树节点输入一个新名字时，事件会被检测到。

      

class MyTreeModelListener implements TreeModelListener {
    public void treeNodesChanged(TreeModelEvent e) {
        DefaultMutableTreeNode node;
        node = (DefaultMutableTreeNode)
                  (e.getTreePath().getLastPathComponent());

         /*

         * If the event lists children, then the changed
         * node is the child of the node we have already
         * gotten.  Otherwise, the changed node and the
         * specified node are the same.
         */
        try {
            int index = e.getChildIndices()[0];
            node = (DefaultMutableTreeNode)
                   (node.getChildAt(index));
        } catch (NullPointerException exc) {}

         System.out.println("The user has finished editing the node.");
        System.out.println("New value: " + node.getUserObject());
    }
    public void treeNodesInserted(TreeModelEvent e) {
    }
    public void treeNodesRemoved(TreeModelEvent e) {
    }
    public void treeStructureChanged(TreeModelEvent e) {
    }
} 

 

这里是一些增加按钮事件处理器（用于增加节点）的代码：

 

treePanel.addObject("New Node " + newNodeSuffix++);
...
public DefaultMutableTreeNode addObject(Object child) {
    DefaultMutableTreeNode parentNode = null;
    TreePath parentPath = tree.getSelectionPath();

    if (parentPath == null) {
        //There is no selection. Default to the root node.
        parentNode = rootNode;
    } else {
        parentNode = (DefaultMutableTreeNode)
                     (parentPath.getLastPathComponent());
    }

    return addObject(parentNode, child, true);
}
...
public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,
                                        Object child,
                                        boolean shouldBeVisible) {
    DefaultMutableTreeNode childNode =
            new DefaultMutableTreeNode(child);
    ...
    treeModel.insertNodeInto(childNode, parent,
                             parent.getChildCount());

    //Make sure the user can see the lovely new node.
    if (shouldBeVisible) {
        tree.scrollPathToVisible(new TreePath(childNode.getPath()));
    }
    return childNode;
}

 

   用 tree model 做为 JTree 的构造函数的参数，节点的文本改变监听器是注册在 model 上，而节点增删是通过 ActionListener 监听按钮事件

       这段代码创建一个节点，插入 tree model 中。如果可以的话，讲请求该节点的上层节点展开， tree 滚动，这样新节点就可视了。这段代码使用 DefaultTreeModel 类提供的 insertNodeInto 方法向 tree model 插入新节点。

(5)创建一个数据模型

       如果 DefaultTreeModel 不能符合你的需求，则需要你自定义一个 data model 。你的 data model 必须实现 TreeModel 接口。 TreeModel 指定 获取树中特定节点、获取特定节的孩子数量、确定一个节点是否为叶子、通知 model 树的改变 和 增加删除 tree model 监听器的方法。

       有趣的是， TreeModel 接口接受各种对象作为树节点。这就不需要通过 TreeNode 对象来表现节点，节点甚至不需要实现 TreeNode 接口。因此，如果 TreeNode 接口不适合你的 tree model, 大可自由的设计自己的节点表现形式。例如，如果一个事前存在的 阶级数据结构（ hierarchical data structure ），你就不需要复制或者强制把他放进 TreeNode 模子中。你只需实现你的 tree model ，这样你就可以使用已经存在的数据结构。

         下面图片展示了一个叫 GenealogyExample( 家谱例子 ) ，他展示了某一个人的子孙和祖先。

在 GenealogyModel.java 中，你可以找到这个自定义的 tree model 的实现。因为这个 model 通过一个 DefaultTreeModel 的子类实现，他必须实现 TreeModel 接口。这就需要实现获得节点信息的一系列方法，例如，哪个是根节点、某个节点的子孙是哪些节点。在 GenealogyModel 的例子中，每个节点表现为一个 Person 类型的对象，这是一个未实现 TreeNode 接口的自定义类。

         一个 tree model 一定要实现一些方法，用于增删 tree model listeners （监听器），当树的数据结构或者数据被改变时，必须把 TreeModelEvents （ tree model 事件）响应到这些监听器。例如，当用户指示 GenealogyExample 从“显示子孙”改变为“显示祖先”时， tree model 实现这些改变，然后产生一个事件并通知它的监听器。

（这里涉及的四个 java 文件都挺值得读，里面的编程思想跟技巧很值得学习）

(6)“懒加载”孩子                                 

       懒加载（ lazy loading ）是一种应用程序特征：当一个类实例的实际加载和实例化延迟到这个实例使用前才进行。

       通过懒加载我们得到任何东西了吗？当然，这将肯定增加了应用程序的性能。通过懒加载，你能够在使用一个类前，利用内存资源加载和实例化它。这样避免了应用程序的初始化时占用更多的类加载跟实例化时间，加快了应用程序的初始化加载时间。

       有一种办法可以懒加载一棵树的孩子：利用 TreeWillExpandListener 接口。例如，你可以声明和加载根节点，祖父双亲和双亲的显示包含在以下代码中：（树的上层为祖先）

       我们声明了根节点 root ，祖父双亲和双亲如下所示：

     

class DemoArea extends JScrollPane

                   implements TreeWillExpandListener {
         .......
         .......

         private TreeNode createNodes() {
            DefaultMutableTreeNode root;
            DefaultMutableTreeNode grandparent;
            DefaultMutableTreeNode parent;

            root = new DefaultMutableTreeNode("San Francisco");
            grandparent = new DefaultMutableTreeNode("Potrero Hill");
            root.add(grandparent);

            parent = new DefaultMutableTreeNode("Restaurants");
            grandparent.add(parent);
          
            dummyParent = parent;
             return root;

        } 

 

 

       你还可以像下面代码一样，把之前声明的节点加载到树 tree 上（这里只是显示而已）

      

TreeNode rootNode = createNodes();
tree = new JTree(rootNode);
 tree.addTreeExpansionListener(this);
tree.addTreeWillExpandListener(this);
	.......
  	.......
 setViewportView(tree);

 

 

       现在，你可以你可以懒加载孩子了，无论双亲节点 Restaurant 是否可视。如上所述，我们在一个方法中声明两个孩子：

private void LoadLazyChildren(){
	    DefaultMutableTreeNode child;
            child = new DefaultMutableTreeNode("Thai Barbeque");
            dummyParent.add(child);
            child = new DefaultMutableTreeNode("Goat Hill Pizza");
	    dummyParent.add(child);
	    textArea.append(" Thai Barbeque and Goat Hill Pizza are loaded lazily");
	}

	.......
	.......

public void treeWillExpand(TreeExpansionEvent e) 
                    throws ExpandVetoException {
            saySomething("You are about to expand node ", e);
            int n = JOptionPane.showOptionDialog(
                this, willExpandText, willExpandTitle,
                JOptionPane.YES_NO_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                null,
                willExpandOptions,
                willExpandOptions[1]);
           
	LoadLazyChildren();
	}

 

(7)如何写 Tree Expansion Listener （监听器）

       有时候，我们使用一棵 tree ，当分支变成展开或者折叠状态的时候，或许需要作出某些反映。例如，你或许需要加载或者保存数据。

       有两种监听器可以负责响应展开或折叠事件： tree expansion listeners （我理解为：已展开事件监听器）和 tree-will-expand listeners. （将来可以展开事件监听器）这节讨论 tree expansion listeners 。

       一个 tree expansion 监听器侦测在展开或者折叠已经发生。一般来说，你应该实现一个 tree expansion 监听器，除非你需要阻止展开或折叠。

       这个例子演示了一个简单的 tree expansion 监听器。窗口底部的文字区域展示关于每次 tree expansion 事件发生的消息。这是一个简单易懂的演示。

       下面的代码展示了程序如何处理 expansion 事件

来自 TreeExpandEventDemo.java .

 

private void LoadLazyChildren(){
	    DefaultMutableTreeNode child;
            child = new DefaultMutableTreeNode("Thai Barbeque");
            dummyParent.add(child);
            child = new DefaultMutableTreeNode("Goat Hill Pizza");
	    dummyParent.add(child);
	    textArea.append(" Thai Barbeque and Goat Hill Pizza are loaded lazily");
	}

	.......
	.......

public void treeWillExpand(TreeExpansionEvent e) 
                    throws ExpandVetoException {
            saySomething("You are about to expand node ", e);
            int n = JOptionPane.showOptionDialog(
                this, willExpandText, willExpandTitle,
                JOptionPane.YES_NO_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                null,
                willExpandOptions,
                willExpandOptions[1]);
           
	LoadLazyChildren();
	}

 

(8)如何写 Tree-Will-Expand Listener

       Tree-will-expand listener 挡住了节点的展开或折叠（就是监听器侦听在展开折叠正在发生之前）。如果仅仅要在展开和折叠发生后通知监听器，那你就应该使用 expansion listener 代替它。

       这个 demo 增加了 tree-will-expand 监听器。在你每次要展开一个节点前，监听器会提示你给出确认信息，确认是否展开。

       TreeExpandEventDemo2.java

      

 

评论

8 楼 feipigzi 2013-11-08  

rickqin 写道

恭喜楼主失业~这意味着你又有机会寻找更好的工作机会了！我明年跳槽

我跟你想法一样~祝您明年找到满意的工作 o(∩_∩)o 哈哈

7 楼 rickqin 2013-11-01  

恭喜楼主失业~这意味着你又有机会寻找更好的工作机会了！我明年跳槽

6 楼 feipigzi 2013-10-25  

ligang7895123 写道

nice  good   楼主 不错呀  现在在哪里任职?

这个翻译是毕业前弄的，挫得我都看不下去了。

今天离职了，失业中。。。o(∩_∩)o

5 楼 ligang7895123 2013-07-19  

nice  good   楼主 不错呀  现在在哪里任职?

4 楼 Jia_er 2013-05-11  

赞赞赞~~

3 楼 mllaner 2013-02-08  

详细易懂，非常好

2 楼 odelia1990 2012-06-17  

  
哈哈，非常受用！谢了！

1 楼 rickqin 2012-02-27  

相当ok的文章！