zhangchen124
zhangchen124

高级Swing 组件


 

课程目标

n       JList高级应用

n       JTree高级应用

n       JTable高级应用


知识要点

列表（List）

如果你想要向用户显示一组选项，而单选按钮或复选框的设置需要占用太多的空间，那么就可以使用组合框或者列表。组合框在Swing组件里已经介绍过了，因为它比较简单。JList组件拥有很多的特性，并且它的设计与树和表格组件的设计非常相似。由于这个原因，因此我们首先要讲一讲各个复杂的Swing组件。

当然，你可以建立各种字符串列表，但是你也可以建立包含任意对象的列表，并且完全能够控制它们的显示方式。列表组件的内部结构使它具备了很强的通用性，而且这种内部结构是相当巧妙的。你会发现通常情况下列表控件使用起来不太灵便，因为你必须对某些构建进行操作，才能实现它的通用性。我们先向你介绍简单的和最常用的例子，即一个字符串列表框，然后介绍一个比较复杂的例子，以便显示列表组件的灵活性。

JList组件

JList组件类似一组复选框或者单选按钮，不过JList组件的各个项目是放在单个框中，并且是通过单击项目本身而不是单击按钮来选定的。如果你允许对列表框中的项目进行多次选择，那么用户就可以选定框中项目的任何组合。

下面是个简单的例子：ListTest.java

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

 

/**

 * This program demonstrates a simple fixed list of strings.

 */

public class ListTest {

   public static void main(String[] args) {

      JFrame frame = new ListFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame contains a word list and a label that shows a sentence made up

 * from the chosen words. Note that you can select multiple words with

 * Ctrl+click and Shift+click.

 */

class ListFrame extends JFrame {

   public ListFrame() {

      setTitle("ListTest");

      setSize(WIDTH, HEIGHT);

 

      String[] words = { "quick", "brown", "hungry", "wild", "silent",

            "huge", "private", "abstract", "static", "final" };

 

      wordList = new JList(words);

      JScrollPane scrollPane = new JScrollPane(wordList);

      JPanel p = new JPanel();

      p.add(scrollPane);

     wordList.addListSelectionListener(newListSelectionListener() {

         public void valueChanged(ListSelectionEvent event) {

            Object[] values = wordList.getSelectedValues();

 

            StringBuffer text = new StringBuffer(prefix);

            for (int i = 0; i < values.length; i++) {

                String word = (String) values[i];

                text.append(word);

                text.append("");

            }

            text.append(suffix);

 

            label.setText(text.toString());

         }

      });

 

      Container contentPane = getContentPane();

      contentPane.add(p, BorderLayout.SOUTH);

      label = new JLabel(prefix + suffix);

      contentPane.add(label, BorderLayout.CENTER);

   }

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 300;

 

   private JList wordList;

 

   private JLabel label;

 

   private String prefix = "The ";

 

   private String suffix = "fox jumpsover the lazy dog.";

}

输出结果，如下图13.1


列表模型

上面介绍了使用列表组件的最常见的方法，这些方法是：

n       指定一组在列表中显示的固定的字符串

n       添加一个滚动条

n       跟踪列表选择事件

在介绍列表的后半部分中，我们还要讲述一些需要更高操作技巧的更加复杂的列表形式，它们是：

n       很长的列表

n       内容经常变化的列表

n       不包含字符串的列表

在第一个示例代码中，我们构建了一个包含固定字符串集合的JList组件。但是，列表框中选择的集合始终都是固定的。那么我们应该如何在列表框中添加或者删除项目呢？让人有些奇怪的是，JList类中没有任何方法可以用来实现这些操作。相反，你必须进一步了解列表组件的内部设计情况。与文本组件一样，列表组件使用模式查看控制器设计方式，将视觉外观（以某种方式来显示的一列项目）与它的基本数据（对象的集合）区分开来。

JList类负责控制数据的视觉外观。它对数据的存储方式实际上知道得很少，它只知道它能够通过某个实现下面这个ListModel接口的对象来检索数据：public interface ListModel {

   public int getSize();

 

   public Object getElementAt(int i);

 

   public void addListDataListener(ListDataListener l);

 

   public void removeListDataListener(ListDataListener l);

}

通过该接口,JList就可以获得各个元素的数量，并且可以检索每个元素。另外，JList对象可以使自己成为一个列表数据监听器。然后，如果元素的集合发生了变化，它就可以得到通知，从而是它能够刷新列表。

这种通用性为什么非常有用呢？为什么JList对象只存储对象的一个向量呢？

请注意，该接口并没有设定如何进行对象的存储。尤其是，它根本没有要求对它们进行存储！getElementAt方法可以在每个值被调用时随意对这些值进行从新计算。如果你想要显示非常大的一个集合而又不必存储这些值，那么这种方法可能是很有用的。

请看下面这个例子：LongListTest.java

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

 

public class LongListTest {

   public static void main(String[] args) {

      JFrame frame = new LongListFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame contains a long word list and a label that shows a sentence made

 * up from the chosen word.

 */

class LongListFrame extends JFrame {

   public LongListFrame() {

      setTitle("LongListTest");

      setSize(WIDTH, HEIGHT);

      wordList = new JList(new WordListModel(3));

      wordList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

 

      wordList.setFixedCellWidth(50);

      wordList.setFixedCellHeight(15);

 

      JScrollPane scrollPane = new JScrollPane(wordList);

      JPanel p = new JPanel();

      p.add(scrollPane);

      wordList.addListSelectionListener(new ListSelectionListener() {

         public void valueChanged(ListSelectionEvent evt) {

            StringBuffer word = (StringBuffer) wordList.getSelectedValue();

            setSubject(word.toString());

         }

      });

 

      Container contentPane = getContentPane();

      contentPane.add(p, BorderLayout.SOUTH);

      label = new JLabel(prefix + suffix);

      contentPane.add(label, BorderLayout.CENTER);

      setSubject("fox");

   }

 

   /**

    * Sets the subject in the label.

    *

    * @param word

    *           the new subject that jumps over the lazy dog

    */

   public void setSubject(String word) {

      StringBuffer text = new StringBuffer(prefix);

      text.append(word);

      text.append(suffix);

      label.setText(text.toString());

   }

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 300;

 

   private JList wordList;

 

   private JLabel label;

 

   private String prefix = "The quickbrown ";

 

   private String suffix = " jumps overthe lazy dog.";

}

 

/**

 * A model that dynamically generates n-letter words.

 */

class WordListModel extends AbstractListModel {

   /**

    * Constructs the model.

    *

    * @param n

    *           the word length

    */

   public WordListModel(int n) {

      length = n;

   }

 

   public int getSize() {

      return (int) Math.pow(LAST - FIRST + 1, length);

   }

 

   public Object getElementAt(int n) {

      StringBuffer r = new StringBuffer();

      ;

      for (int i = 0; i < length; i++) {

         char c = (char) (FIRST + n % (LAST - FIRST + 1));

         r.insert(0, c);

         n = n / (LAST - FIRST + 1);

      }

      return r;

   }

 

   private int length;

 

   public static final char FIRST = 'a';

 

   public static final char LAST = 'z';

}

运行结果见图13.2


插入和删除值

你不能直接编辑列表值的集合。相反，你必须访问一个列表模型，然后再添加或删除元素。这种操作也是说起来容易做起来难。假设你想到将更多的值添加给一个列表，你可以获取一个对列表模型的引用：

ListModelmodel=list.getModel();

但是这个列表模型并不能给你带来什么好处，正如你在上一节中看到的那样，ListModel接口没有任何方法可以用来插入或者删除元素，因为拥有列表模型的整个目的是它不需要存储各个元素。

让我们用另一种方法来进行这项工作。JList的一个构造器取走对象的一个向量：

Vectorvalues=new Vector();

values.addElement("daf");

values.addElement("daf");

…

JListlist=new JList(values);

当然，现在你可以编辑该向量，并且添加或者删除元素，但是该列表并不知道正在进行的这些操作，因此它无法对这些变化作出反应。尤其是你添加值的时候，该列表更无法更新它的视图。

相反，你必须建立一个特定的模型，即DefaultListModel，将初始值填入该列表模型，然后将它与列表关联起来。

DefaultListModelmodel=new DefaultListModel();

model.addElement("dafds");

model.addElement("dafds");

…

JListlist =new JList(model);

现在你就可以将值添加给model对象，或者从model对象中删除值。然后，model对象将把修改的情况通知该列表，同时该列表对自己进行刷新。

model.removeElement("dsaf");

model.addElement("dafds");

正如你看到的样子，DefaultListModel类使用的方法名与集合类使用的名字是不同的。默认列表模型在内部使用向量来存放列表的值。它继承了AbstractListModel类的列表通知机制，就像上一节中的示例模型类一样。

警告

有一个JList构造器，可以用对象或字符串的数组或向量来建立列表。你可能认为这些构造器会使用DefaultListModel来存放这些值。实际情况并非如此，该构造器将建立一个简单的普通模型，它能够访问各个值，但是如果列表的内容发生变更，它并不发出任何通知。例如，下面是用Vector建立一个JList的构造器：

public JList(final Vector listData)

{

   this(new AbstractListModel()

   {

      public int getSize(){return listData.size();}

      public Object getElementAt(int i){

           return        listData.elementAt(i);

       }

   });

}

这意味着，如果你在列表建立后修改了向量的内容，该列表在它被完全刷新之前，将会显示一个新值与旧值混合在一起的视图（上面的整个构造器中的final一词无法阻止你修改其他位置上的向量，它只意味着构造器本身将不修改listData引用的值；关键字final是必须要有的，因为listData对象是在内部类中使用的）。

值的表示

到现在为址，你在本章中看到的所有列表都只包含字符串。但是，如果要显示一个图标的列表，实际上同样容易做到，你只需要传递一个填入了Icon对象的数组或向量即可。更加有意思的是，你可以非常容易地用你绘制的任何东西来代表你的列表值。

虽然JList类能够自动显示字符串和图标，但是你必须为所有定制的图形将一个列表单元格绘制器安装到JList对象中。列表单元格绘制器是用于实现下面这个接口的任意类：

interface ListCellRenderer {

   Component getListCellRendererComponent(JList list, Object value, int index,

         Boolean isSelected, Boolean cellHasFocus);

   /*

    * 用于返回一个组件，它的paint方法将能够绘制单元格的内容。如果列表的单元格的大小不固定，那么该组件也不必须实现gePreferredSize方

    * 法。参数：list 要绘制其单元格的列表 item 要绘制的项目 index 项目存放在列表模型中时使用的索引 isSelected

    * 如果设定的单元格被选定，则返回true hasFocus 如果设定的单元格拥有该焦点，则返回true

    */

}

请看下面代码：ListRenderingTest.java

import java.util.*;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

 

public class ListRenderingTest {

    public static void main(String[] args) {

       JFrame frame = new ListRenderingFrame();

       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

       frame.show();

    }

}

 

class ListRenderingFrame extends JFrame {

    public ListRenderingFrame() {

       setTitle("ListRenderingTest");

       setSize(WIDTH, HEIGHT);

 

       ArrayList fonts = new ArrayList();

       final int SIZE = 24;

       fonts.add(new Font("Serif", Font.PLAIN, SIZE));

       fonts.add(new Font("SansSerif", Font.PLAIN, SIZE));

       fonts.add(new Font("Monospaced", Font.PLAIN, SIZE));

       fonts.add(new Font("Dialog", Font.PLAIN, SIZE));

       fonts.add(new Font("DialogInput", Font.PLAIN, SIZE));

       fontList = new JList(fonts.toArray());

       fontList.setVisibleRowCount(4);

       fontList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

       fontList.setCellRenderer(new FontCellRenderer());

       JScrollPane scrollPane = new JScrollPane(fontList);

 

       JPanel p = new JPanel();

       p.add(scrollPane);

       fontList.addListSelectionListener(new ListSelectionListener() {

           public void valueChanged(ListSelectionEvent evt) {

              Font font = (Font) fontList.getSelectedValue();

              text.setFont(font);

           }

 

       });

       Container contentPane = getContentPane();

       contentPane.add(p, BorderLayout.SOUTH);

       text = new JTextArea("The quick brown foxjumps over the lazy dog");

       text.setFont((Font) fonts.get(0));

       text.setLineWrap(true);

       text.setWrapStyleWord(true);

       contentPane.add(text, BorderLayout.CENTER);

    }

 

    private JTextArea text;

 

    private JList fontList;

 

    private static final int WIDTH = 400;

 

    private static final int HEIGHT = 300;

}

 

class FontCellRenderer implements ListCellRenderer {

    public Component getListCellRendererComponent(final JList list,

           final Object value, final int index, final boolean isSelected,

           final boolean cellHasFocus) {

       return new JPanel() {

           public void paintComponent(Graphics g) {

              Font font = (Font) value;

              String text = font.getFamily();

              FontMetrics fm = g.getFontMetrics(font);

              g.setColor(isSelected ? list.getSelectionBackground() :list

                     .getBackground());

              g.fillRect(0, 0, getWidth(), getHeight());

              g.setColor(isSelected ? list.getSelectionForeground() :list

                     .getForeground());

              g.setFont(font);

              g.drawString(text, 0, fm.getAscent());

           }

 

           public Dimension getPreferredSize() {

              Font font = (Font) value;

              String text = font.getFamily();

              Graphics g = getGraphics();

              FontMetrics fm = g.getFontMetrics(font);

              return new Dimension(fm.stringWidth(text), fm.getHeight());

           }

       };

    }

}

运行结果见图13.3


树状结构（Tree）

使用分层结构的文件系统的每个计算机用户都见过树状结构。当然，目录和文件只是构成多种树状结构例子中的一种。程序员都很熟悉显示类的继承关系的树状结构。作为编程人员，我们常常需要显示这些树状结构。幸好，Swing类库有个JTree 类，它可以用于这个目的。在我们进一步深入介绍树状结构之前，让我们首先讲述几个这方面的术语。树状结构是由许多节点组成的。每个节点既可以是个树叶，也可以是个子节点。每个节点（根节点除外）只有一个父节点。一个树状结构只有一个根节点，有时你可能拥有一个树的集合，每个树都有她自己的根节点。这种集合称为树林。

关于树的实现跟JList的实现方式基本一样，这里就不多介绍了。下面看个树的一个例子：SimpleTree.java

 

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.tree.*;

 

/**

 * This program shows a simple tree.

 */

public class SimpleTree {

   public static void main(String[] args) {

      JFrame frame = new SimpleTreeFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame contains a simple tree that displays a manually constructed tree

 * model.

 */

class SimpleTreeFrame extends JFrame {

   public SimpleTreeFrame() {

      setTitle("SimpleTree");

      setSize(WIDTH, HEIGHT);

 

      // set up tree model data

 

      DefaultMutableTreeNode root = new DefaultMutableTreeNode("World");

      DefaultMutableTreeNode country = new DefaultMutableTreeNode("USA");

      root.add(country);

      DefaultMutableTreeNode state = new DefaultMutableTreeNode("California");

      country.add(state);

      DefaultMutableTreeNode city = new DefaultMutableTreeNode("San Jose");

      state.add(city);

      city = new DefaultMutableTreeNode("Cupertino");

      state.add(city);

      state = new DefaultMutableTreeNode("Michigan");

      country.add(state);

      city = new DefaultMutableTreeNode("Ann Arbor");

      state.add(city);

      country = new DefaultMutableTreeNode("Germany");

      root.add(country);

      state = new DefaultMutableTreeNode("Schleswig-Holstein");

      country.add(state);

      city = new DefaultMutableTreeNode("Kiel");

      state.add(city);

 

      // construct tree and put itin a scroll pane

 

      JTree tree = new JTree(root);

      Container contentPane = getContentPane();

      contentPane.add(new JScrollPane(tree));

   }

 

   private static final int WIDTH = 300;

 

   private static final int HEIGHT = 200;

}

运行结果见图13.4

在SDK1.4中，你可以使用下面这个具有魔力的代码来撤消连接父节点与子节点之间的线条：

tree.putClientProperty("JTree.lineStyle","None");

如果你要显示拐角线，请使用下面的代码

tree.putClientProperty("JTree.lineStyle","Angled");

如果你愿意的话，可以调用下面这个方法，增加一个门把手图标：

tree.setShowsRootHandles(true);

反过来你可以使用下面的代码隐藏这个根

tree.setRootVisible(false);

对于那些不应该拥有的子节点的节点，请调用下面这个方法：

node.setAllowsChildren(false);

一旦你拥有选定了的节点，你就可以对它进行编辑。但是，请不要只是简单地将子节点添加给树节点：

selectedNode.add(newNode);//no!

如果你更改了节点的结构，你就改变了树的模型，但是相关的视图并没有得到修改的通知。你可以自己将一个通知发送出去 ，但是如果你使用DefaultTreeModel类的insertNodeInto方法，那么树模型的类将负责进行这项发送通知的工作。例如，调用下面这个方法，就可以将一个新节点作为选定的节点的最后一个子节点添加树，并且将添加的情况通知树视图。

model.insertNodeInto(newNode,selectedNode,selectedNode.getChildCount());

类似的removeNodeFromParent调用可以用于删除节点，并且将删除的情况通知树视图：

model.removeNodeFromParent(selectedNode);

如果你让节点结构保持不变，但是你改变了用户对象，那么你应该调用下面这个方法：

model.nodeChanged(changedNode);

请看树编辑程序完整的源代码：TreeEditTest.java

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.tree.*;

 

public class TreeEditTest {

   public static void main(String[] args) {

      JFrame frame = new TreeEditFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

class TreeEditFrame extends JFrame {

   public TreeEditFrame() {

      setTitle("TreeEditTest");

      setSize(WIDTH, HEIGHT);

      TreeNode root = makeSampleTree();

      model = new DefaultTreeModel(root);

      tree = new JTree(model);

      tree.setEditable(true);

      JScrollPane scrollPane = new JScrollPane(tree);

      getContentPane().add(scrollPane, BorderLayout.CENTER);

      makeButtons();

   }

 

   public TreeNode makeSampleTree() {

      DefaultMutableTreeNode root = new DefaultMutableTreeNode("World");

      DefaultMutableTreeNode country = new DefaultMutableTreeNode("USA");

      root.add(country);

      DefaultMutableTreeNode state = new DefaultMutableTreeNode("California");

      country.add(state);

      DefaultMutableTreeNode city = new DefaultMutableTreeNode("San Jose");

      state.add(city);

      city = new DefaultMutableTreeNode("Cupertino");

      state.add(city);

      state = new DefaultMutableTreeNode("Michigan");

      country.add(state);

      city = new DefaultMutableTreeNode("Ann Arbor");

      state.add(city);

      country = new DefaultMutableTreeNode("Germany");

      root.add(country);

      state = new DefaultMutableTreeNode("Schleswig-Holstein");

      country.add(state);

      city = new DefaultMutableTreeNode("Kiel");

      state.add(city);

      return root;

   }

 

   public void makeButtons() {

      JPanel panel = new JPanel();

      JButton addSiblingButton = new JButton("Add Sibling");

      addSiblingButton.addActionListener(new ActionListener() {

         public void actionPerformed(ActionEvent event) {

            DefaultMutableTreeNode selectedNode =(DefaultMutableTreeNode) tree

                   .getLastSelectedPathComponent();

 

            if (selectedNode == null)

                return;

 

            DefaultMutableTreeNode parent = (DefaultMutableTreeNode)selectedNode

                   .getParent();

 

            if (parent == null)

                return;

 

            DefaultMutableTreeNode newNode = newDefaultMutableTreeNode(

                   "New");

 

            int selectedIndex = parent.getIndex(selectedNode);

            model.insertNodeInto(newNode, parent, selectedIndex + 1);

            TreeNode[] nodes = model.getPathToRoot(newNode);

            TreePath path = new TreePath(nodes);

            tree.scrollPathToVisible(path);

         }

      });

      panel.add(addSiblingButton);

 

      JButton addChildButton = new JButton("Add Child");

      addChildButton.addActionListener(new ActionListener() {

         public void actionPerformed(ActionEvent event) {

            DefaultMutableTreeNode selectedNode =(DefaultMutableTreeNode) tree

                   .getLastSelectedPathComponent();

 

            if (selectedNode == null)

                return;

 

            DefaultMutableTreeNode newNode = newDefaultMutableTreeNode(

                   "New");

            model.insertNodeInto(newNode, selectedNode, selectedNode

                   .getChildCount());

 

            // now displaynew node

 

            TreeNode[] nodes = model.getPathToRoot(newNode);

            TreePath path = new TreePath(nodes);

            tree.scrollPathToVisible(path);

         }

      });

      panel.add(addChildButton);

 

      JButton deleteButton = new JButton("Delete");

      deleteButton.addActionListener(new ActionListener() {

         public void actionPerformed(ActionEvent event) {

            DefaultMutableTreeNode selectedNode =(DefaultMutableTreeNode) tree

                   .getLastSelectedPathComponent();

 

            if (selectedNode != null && selectedNode.getParent() != null)

                model.removeNodeFromParent(selectedNode);

         }

      });

      panel.add(deleteButton);

      getContentPane().add(panel, BorderLayout.SOUTH);

   }

 

   private DefaultTreeModel model;

 

   private JTree tree;

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 200;

}

运行结果见13.5


节点的枚举

有时，为了查找树中的一个节点，你必须从根节点开始，访问所有的子节点，才能找到你所需要的节点。DefaultMutableTreeNode类配有若干非常方便的方法，可以用来迭代遍历所有的节点。

breadthFirstEnumeration和depthFirstEnumeration这两个方法能够返回各个枚举对象，他们的nextElement方法能够使用宽度优先或者深度优先的遍历搜索法，访问当前节点的所有子节点。

请参看ClassTree.java

import java.awt.*;

import java.awt.event.*;

import java.lang.reflect.*;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.tree.*;

 

/**

 * This program demonstrates cell rendering by showing a tree of classes and

 * their superclasses.

 */

public class ClassTree {

   public static void main(String[] args) {

      JFrame frame = new ClassTreeFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame displays the class tree and a text field and add button to add

 * more classes into the tree.

 */

class ClassTreeFrame extends JFrame {

   public ClassTreeFrame() {

      setTitle("ClassTree");

      setSize(WIDTH, HEIGHT);

 

      // the root of the class treeis Object

      root = new DefaultMutableTreeNode(java.lang.Object.class);

      model = new DefaultTreeModel(root);

      tree = new JTree(model);

 

      // add this class to populatethe tree with some data

      addClass(getClass());

 

      // set up node icons

      ClassNameTreeCellRenderer renderer = newClassNameTreeCellRenderer();

      renderer.setClosedIcon(new ImageIcon("red-ball.gif"));

      renderer.setOpenIcon(new ImageIcon("yellow-ball.gif"));

      renderer.setLeafIcon(new ImageIcon("blue-ball.gif"));

      tree.setCellRenderer(renderer);

 

      getContentPane().add(new JScrollPane(tree), BorderLayout.CENTER);

 

      addTextField();

   }

 

   /**

    * Add the text field and "Add" button to add a new class.

    */

   public void addTextField() {

      JPanel panel = new JPanel();

 

      ActionListener addListener = new ActionListener() {

         public void actionPerformed(ActionEvent event) {

            // add the classwhose name is in the text field

            try {

                String text = textField.getText();

                addClass(Class.forName(text));

                // clear textfield to indicate success

                textField.setText("");

            } catch (ClassNotFoundException e) {

                JOptionPane.showMessageDialog(null, "Class not found");

            }

         }

      };

 

      // new class names are typedinto this text field

      textField = new JTextField(20);

      textField.addActionListener(addListener);

      panel.add(textField);

 

      JButton addButton = new JButton("Add");

      addButton.addActionListener(addListener);

      panel.add(addButton);

 

      getContentPane().add(panel, BorderLayout.SOUTH);

   }

 

   /**

    * Finds an object in the tree.

    *

    * @param obj

    *           the object to find

    * @return the node containing the object or null if the object is not

    *        present in the tree

    */

   public DefaultMutableTreeNode findUserObject(Object obj) {

      // find the node containing auser object

      Enumeration e = root.breadthFirstEnumeration();

      while (e.hasMoreElements()) {

         DefaultMutableTreeNode node = (DefaultMutableTreeNode) e

                .nextElement();

         if (node.getUserObject().equals(obj))

            return node;

      }

      return null;

   }

 

   public DefaultMutableTreeNode addClass(Class c) {

      if (c.isInterface() || c.isPrimitive())

         return null;

 

      DefaultMutableTreeNode node = findUserObject(c);

      if (node != null)

         return node;

 

      Class s = c.getSuperclass();

 

      DefaultMutableTreeNode parent;

      if (s == null)

         parent = root;

      else

         parent = addClass(s);

 

      DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(c);

      model.insertNodeInto(newNode, parent, parent.getChildCount());

      TreePath path = new TreePath(model.getPathToRoot(newNode));

      tree.makeVisible(path);

      return newNode;

   }

 

   private DefaultMutableTreeNode root;

 

   private DefaultTreeModel model;

 

   private JTree tree;

 

   private JTextField textField;

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 300;

}

 

class ClassNameTreeCellRenderer extends DefaultTreeCellRenderer {

   public Component getTreeCellRendererComponent(JTree tree,Object value,

         boolean selected, boolean expanded, boolean leaf, int row,

         boolean hasFocus) {

      super.getTreeCellRendererComponent(tree, value, selected,expanded,

            leaf, row, hasFocus);

 

      DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;

      Class c = (Class) node.getUserObject();

      if (plainFont == null) {

         plainFont = getFont();

         if (plainFont != null)

            italicFont = plainFont.deriveFont(Font.ITALIC);

      }

      // set font to italic if theclass is abstract

      if ((c.getModifiers() & Modifier.ABSTRACT) == 0)

         setFont(plainFont);

      else

         setFont(italicFont);

      return this;

   }

 

   private Font plainFont = null;

 

   private Font italicFont = null;

}

运行结果如图13.6


监听树事件

树组件与一些其他的组件成对地进行设置，这种情况是最常见的。当用户选定树节点时，某些信息就会显示在另一个窗口中。

若要取得这样的运行特性，你可以安装一个树选择监听器（tree selection listener）。该监听器必须实现TreeSelectionListener接口，这是配有下面这个单一方法的接口：

void  valueChanged(TreeSelectionEvent event)

每当用户选定或者撤消选定树的节点时，就要调用该方法。

你可以用通常的方法将监听器添加给树：

tree.addTreeSelectionListener(listener);

选择模式（单选，多选）同JList。

请看下面例子：ClassBrowserTest.java.

import java.awt.*;

import java.awt.event.*;

import java.lang.reflect.*;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.tree.*;

 

/**

 * This program demonstrates tree selection events.

 */

public class ClassBrowserTest {

   public static void main(String[] args) {

      JFrame frame = new ClassBrowserTestFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * A frame with a class tree, a text area to show the properties of the selected

 * class, and a text field to add new classes.

 */

class ClassBrowserTestFrame extends JFrame {

   public ClassBrowserTestFrame() {

      setTitle("ClassBrowserTest");

      setSize(WIDTH, HEIGHT);

 

      // the root of the class treeis Object

      root = new DefaultMutableTreeNode(java.lang.Object.class);

      model = new DefaultTreeModel(root);

      tree = new JTree(model);

 

      // add this class to populatethe tree with some data

      addClass(getClass());

 

      // set up selection mode

      tree.addTreeSelectionListener(new TreeSelectionListener() {

         public void valueChanged(TreeSelectionEvent event) {

            // the userselected a different node

            // --updatedescription

            TreePath path = tree.getSelectionPath();

            if (path == null)

                return;

            DefaultMutableTreeNode selectedNode =(DefaultMutableTreeNode) path

                   .getLastPathComponent();

            Class c = (Class) selectedNode.getUserObject();

            String description = getFieldDescription(c);

            textArea.setText(description);

         }

      });

      int mode = TreeSelectionModel.SINGLE_TREE_SELECTION;

      tree.getSelectionModel().setSelectionMode(mode);

 

      // this text area holds theclass description

      textArea = new JTextArea();

 

      // add tree and text area tothe content pane

      JPanel panel = new JPanel();

      panel.setLayout(new GridLayout(1, 2));

      panel.add(new JScrollPane(tree));

      panel.add(new JScrollPane(textArea));

 

      getContentPane().add(panel, BorderLayout.CENTER);

 

      addTextField();

   }

 

   /**

    * Add the text field and "Add" button to add a new class.

    */

   public void addTextField() {

      JPanel panel = new JPanel();

 

      ActionListener addListener = new ActionListener() {

         public void actionPerformed(ActionEvent event) {

            // add the classwhose name is in the text field

            try {

                String text = textField.getText();

                addClass(Class.forName(text));

                // clear textfield to indicate success

                textField.setText("");

            } catch (ClassNotFoundException e) {

                JOptionPane.showMessageDialog(null, "Class not found");

            }

         }

      };

 

      // new class names are typedinto this text field

      textField = new JTextField(20);

      textField.addActionListener(addListener);

      panel.add(textField);

 

      JButton addButton = new JButton("Add");

      addButton.addActionListener(addListener);

      panel.add(addButton);

 

      getContentPane().add(panel, BorderLayout.SOUTH);

   }

 

   /**

    * Finds an object in the tree.

    *

    * @param obj

    *           the object to find

    * @return the node containing the object or null if the object is not

    *        present in the tree

    */

   public DefaultMutableTreeNode findUserObject(Object obj) {

      // find the node containing auser object

      Enumeration e = root.breadthFirstEnumeration();

      while (e.hasMoreElements()) {

         DefaultMutableTreeNode node = (DefaultMutableTreeNode) e

                .nextElement();

         if (node.getUserObject().equals(obj))

            return node;

      }

      return null;

   }

 

   /**

    * Adds a new class and any parent classes that aren't yet part of the tree

    *

    * @param c

    *           the class to add

    * @return the newly added node.

    */

   public DefaultMutableTreeNode addClass(Class c) {

      // add a new class to thetree

      // skip non-class types

      if (c.isInterface() || c.isPrimitive())

         return null;

 

      // if the class is already inthe tree, return its node

      DefaultMutableTreeNode node = findUserObject(c);

      if (node != null)

         return node;

 

      // class isn't present--firstadd class parent recursively

      Class s = c.getSuperclass();

 

      DefaultMutableTreeNode parent;

      if (s == null)

         parent = root;

      else

         parent = addClass(s);

 

      // add the class as a childto the parent

      DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(c);

      model.insertNodeInto(newNode, parent, parent.getChildCount());

 

      // make node visible

      TreePath path = new TreePath(model.getPathToRoot(newNode));

      tree.makeVisible(path);

 

      return newNode;

   }

 

   /**

    * Returns a description of the fields of a class.

    *

    * @param the

    *           class to be described

    * @return a string containing all field types and names

    */

   public static String getFieldDescription(Class c) {

      // use reflection to findtypes and names of fields

      StringBuffer r = new StringBuffer();

      Field[] fields = c.getDeclaredFields();

      for (int i = 0; i < fields.length; i++) {

         Field f = fields[i];

         if ((f.getModifiers() & Modifier.STATIC) != 0)

            r.append("static");

         r.append(f.getType().getName());

         r.append(" ");

         r.append(f.getName());

         r.append("\n");

      }

      return r.toString();

   }

 

   private DefaultMutableTreeNode root;

 

   private DefaultTreeModel model;

 

   private JTree tree;

 

   private JTextField textField;

 

   private JTextArea textArea;

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 300;

}

运行结果见图13.7


定制树模型

在下面示例代码中，我们实现了一个用于查看某个变量的内容的程序，正如调试程序执行的操作一样。在执行进一步的操作之前，要先对该示例代码进行编译和运行！每个代码都对应于一个实例变量。如果该变量是个对象，那么请将它展开以便观察它的实例变量。该程序用于查看图文框窗口的内容。如果你仔细观察几个实例变量，你就能找到一些熟悉的类。你还能够对Swing用户界面的组件的复杂性有所了解。

该程序的出色之处在于它的树并不使用DefaulttreeModel。如果你已经拥有采取分层结构的数据，那么你就不必建立相重的树，也不必考虑如何保持各个树之间的同步问题。这正是我们的例子中的情况，你查看的对象已经通过对象的引用互相连接起来，因此没有必要复制对象的连接结构。

TreeModel接口只配有很少几个方法。第一组方法使得JTree能够找到各个树节点，方法是首先找到根节点，然后再查找子节点。JTree类只在用户实际展开一个节点时，才调用这些方法。

ObjectgetRoot()

intgetChildCount(Object parent)

ObjectgetChild(Object parent,int index)

该示例代码显示了为什么TreeModel接口与JTree类本身一样，不需要对节点有任何明确的了解。根节点和它的子节点可以是任何对象。TreeModel负责告诉JTree这些节点之间是如何连接的。

TreeModel接口的下一个方法是getChild的逆向方法：

intgetIndexOfChild(Object parent,Object child)

实际上，该方法可以用前面的3个代码来实现，请看下面的示例代码ObjectInspectorTest.java

该树模型负责告诉JTree，那些节点应该显示为叶节点：

BooleanisLeaf(Object node)

如果你的代码更改了树模型，那么该树必须得到通知，这样它就能够对自己进行刷新。该树将把自己作为一个TreeModelListener添加给树模型。因此，该模型必须支持下面这些通常的监听器管理方法：

voidaddTreeModelListener(TreeModelListener l)

voidremoveTreeModelListener(TreeModelListener l)

你可以在示例代码中看到这些方法的实现代码。

当该树模型修改树的内容时，它要调用TreeModelListener接口的下列4个方法中的一个方法：

voidtreeNodesChanged(TreeModelEvent e)

voidtreeNodesInserted(TreeModelEvent e)

voidtreeNodesRemoved(TreeModelEvent e)

voidtreeStructureChanged(TreeModelEvent e)

TreeModelEvent对象用于描述发生更改的位置。对描述插入事件或删除事件的树模型事件进行汇编的具体细节，具有很强的技术性。如果你的树实际上可以进行节点的添加和删除，那么你只需要考虑如何触发这些事件。在示例代码中，我们将要讲述如何触发一个事件，也就是如何用一个新对象来取代根节点。

最后要说明的是，如果用户要对树节点进行编辑，那么你的树模型将被下面这个修改所调用：

voidvalueForPathChanged(TreePath path,Object newValue)

如果你不允许编辑树节点，那么该方法永远不会被调用。

如果你不需要支持编辑功能，那么你可以非常容易地建立一个树模型。请实现下面3个方法。

ObjectgetToot()

int  getChildCount(Object parent)

ObjectgetChild(Object parent ,int index)

这些方法用于描述树的结构。

请看下面的代码：ObjectInspectorTest.java

import java.awt.*;

import java.awt.event.*;

import java.lang.reflect.*;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.tree.*;

 

/**

 * This program demonstrates how to use a custom tree model. It displays the

 * fields of an object.

 */

public class ObjectInspectorTest {

   public static void main(String[] args) {

      JFrame frame = new ObjectInspectorFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame holds the object tree.

 */

class ObjectInspectorFrame extends JFrame {

   public ObjectInspectorFrame() {

      setTitle("ObjectInspectorTest");

      setSize(WIDTH, HEIGHT);

 

      // we inspect this frameobject

 

      Variable v = new Variable(getClass(), "this", this);

      ObjectTreeModel model = new ObjectTreeModel();

      model.setRoot(v);

 

      // construct and show tree

 

      tree = new JTree(model);

      getContentPane().add(new JScrollPane(tree), BorderLayout.CENTER);

   }

 

   private JTree tree;

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 300;

}

 

/**

 * This tree model describes the tree structure of a Java object. Children are

 * the objects that are stored in instance variables.

 */

class ObjectTreeModel implements TreeModel {

   /**

    * Constructs an empty tree.

    */

   public ObjectTreeModel() {

      root = null;

   }

 

   /**

    * Sets the root to a given variable.

    *

    * @param v

    *           the variable that is being described by this tree

    */

   public void setRoot(Variable v) {

      Variable oldRoot = v;

      root = v;

      fireTreeStructureChanged(oldRoot);

   }

 

   public Object getRoot() {

      return root;

   }

 

   public int getChildCount(Object parent) {

      return ((Variable) parent).getFields().size();

   }

 

   public Object getChild(Object parent, int index) {

      ArrayList fields = ((Variable) parent).getFields();

      Field f = (Field) fields.get(index);

      Object parentValue = ((Variable) parent).getValue();

      try {

         return new Variable(f.getType(), f.getName(), f.get(parentValue));

      } catch (IllegalAccessException e) {

         return null;

      }

   }

 

   public int getIndexOfChild(Object parent, Object child) {

      int n = getChildCount(parent);

      for (int i = 0; i < n; i++)

         if (getChild(parent, i).equals(child))

            return i;

      return -1;

   }

 

   public boolean isLeaf(Object node) {

      return getChildCount(node) == 0;

   }

 

   public void valueForPathChanged(TreePath path, Object newValue) {

   }

 

   public void addTreeModelListener(TreeModelListener l) {

      listenerList.add(TreeModelListener.class, l);

   }

 

   public void removeTreeModelListener(TreeModelListener l) {

      listenerList.remove(TreeModelListener.class, l);

   }

 

   protected void fireTreeStructureChanged(Object oldRoot) {

      TreeModelEvent event = new TreeModelEvent(this,

            new Object[] { oldRoot });

      EventListener[] listeners = listenerList

            .getListeners(TreeModelListener.class);

      for (int i = 0; i < listeners.length; i++)

         ((TreeModelListener)listeners[i]).treeStructureChanged(event);

   }

 

   private Variable root;

 

   private EventListenerList listenerList = new EventListenerList();

}

 

/**

 * A variable with a type, name, and value.

 */

class Variable {

   /**

    * Construct a variable

    *

    * @param aType

    *           the type

    * @param aName

    *           the name

    * @param aValue

    *           the value

    */

   public Variable(Class aType, String aName, Object aValue) {

      type = aType;

      name = aName;

      value = aValue;

      fields = new ArrayList();

 

      /*

       * find all fields if wehave a class type except we don't expand

       * strings and nullvalues

       */

 

      if (!type.isPrimitive() && !type.isArray()

            && !type.equals(String.class) && value != null) {

         // get fields from the classand all superclasses

         for (Class c = value.getClass(); c != null; c = c.getSuperclass()) {

            Field[] f = c.getDeclaredFields();

            AccessibleObject.setAccessible(f, true);

 

            // get allnonstatic fields

            for (int i = 0; i < f.length; i++)

                if ((f[i].getModifiers() & Modifier.STATIC) == 0)

                   fields.add(f[i]);

         }

      }

   }

 

   /**

    * Gets the value of this variable.

    *

    * @return the value

    */

   public Object getValue() {

      return value;

   }

 

   /**

    * Gets all nonstatic fields of this variable.

    *

    * @return an array list of variables describing the fields

    */

   public ArrayList getFields() {

      return fields;

   }

 

   public String toString() {

      String r = type + " " + name;

      if (type.isPrimitive())

         r += "=" + value;

      else if (type.equals(String.class))

         r += "=" + value;

      else if (value == null)

         r += "=null";

      return r;

   }

 

   private Class type;

 

   private String name;

 

   private Object value;

 

   private ArrayList fields;

}

运行结果见图13.8


表格（JTable）

JTable组件用于显示一个二维对象表格。当然，表格在用户界面中是非常常见的。Swing开发小组将大量的精力用于表格控件的设计上。与其他Swing类相比，表格具有其固有的复杂性，但是它也许是设计的比较成功的组件，JTable组件将相当多的复杂性隐藏了起来。通过编写很少的几行代码，你就可以建立功能完善的，具备丰富运行特性的表格。当然，你也可以根据你的特定应用程序的需要，编写更多的代码，定制它的显示和运行方式。

简单的表格

与列表型控件的情况一样，JTable并不存储它自己的数据，而是从表格模型那里获得它的数据。JTable 类有一个构造器，将二维对象数组包装在一个默认模型之中。这是我们在第一个示例代码中使用的方法。在本章的后面部分中，我们将要介绍表格模型。

例：PlanetTable.java

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.table.*;

 

/**

 * This program demonstrates how to show a simple table

 */

public class PlanetTable {

   public static void main(String[] args) {

      JFrame frame = new PlanetTableFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame contains a table of planet data.

 */

class PlanetTableFrame extends JFrame {

   public PlanetTableFrame() {

      setTitle("PlanetTable");

      setSize(WIDTH, HEIGHT);

      JTable table = new JTable(cells, columnNames);

 

      getContentPane().add(new JScrollPane(table), BorderLayout.CENTER);

   }

 

   private Object[][] cells = {

         { "Mercury", new Double(2440), new Integer(0), Boolean.FALSE,

                Color.yellow },

         { "Venus", new Double(6052), new Integer(0), Boolean.FALSE,

                Color.yellow },

         { "Earth", new Double(6378), new Integer(1), Boolean.FALSE,

                Color.blue },

         { "Mars", new Double(3397), new Integer(2), Boolean.FALSE,

                Color.red },

         { "Jupiter", new Double(71492), new Integer(16), Boolean.TRUE,

                Color.orange },

         { "Saturn", new Double(60268), new Integer(18), Boolean.TRUE,

                Color.orange },

         { "Uranus", new Double(25559), new Integer(17), Boolean.TRUE,

                Color.blue },

         { "Neptune", new Double(24766), new Integer(8),Boolean.TRUE,

                Color.blue },

         { "Pluto", new Double(1137), new Integer(1), Boolean.FALSE,

               Color.black } };

 

   private String[] columnNames = { "Planet", "Radius", "Moons", "Gaseous",

         "Color" };

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 200;

}

运行结果见图13.9


表格模型

在上面这个示例代码中，表格提供的对象被存放在一个二维数组中。但是，在你自己的代码中一般不应该使用这种方法。如果你发现自己将数据转储到一个数组中，以便实现你所需要的大多数方法。你只需要提供下面3个方法：

publicint getRowCount();

publicint getColumnCount();

publicObject getValueAt(int row,int column)

 

例如：InvestmentTable.java

import java.awt.*;

import java.awt.event.*;

import java.text.*;

import javax.swing.*;

import javax.swing.table.*;

 

public class InvestmentTable {

   public static void main(String[] args) {

      JFrame frame = new InvestmentTableFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

class InvestmentTableFrame extends JFrame {

   public InvestmentTableFrame() {

      setTitle("InvestmentTable");

      setSize(WIDTH, HEIGHT);

      TableModel model = new InvestmentTableModel(30, 5, 10);

      JTable table = new JTable(model);

      getContentPane().add(new JScrollPane(table), "Center");

   }

 

   private static final int WIDTH = 600;

 

   private static final int HEIGHT = 300;

}

 

class InvestmentTableModel extends AbstractTableModel {

   public InvestmentTableModel(int y, int r1, int r2) {

      years = y;

      minRate = r1;

      maxRate = r2;

   }

 

   public int getRowCount() {

      return years;

   }

 

   public int getColumnCount() {

      return maxRate - minRate + 1;

   }

 

   public Object getValueAt(int r, int c) {

      double rate = (c + minRate) / 100.0;

      int nperiods = r;

      double futureBalance = INITIAL_BALANCE * Math.pow(1+ rate, nperiods);

      return NumberFormat.getCurrencyInstance().format(futureBalance);

   }

 

   public String getColumnName(int c) {

      double rate = (c + minRate) / 100.0;

      return NumberFormat.getPercentInstance().format(rate);

   }

 

   private int years;

 

   private int minRate;

 

   private int maxRate;

 

   private static double INITIAL_BALANCE = 100000.0;

}

运行结果见图13.10


排序过滤器

在上面的两个示例代码说明了这样一个问题，即表格并不存放单元格数据，它们是从表格模型那里得到数据的。表格模型也不必存放数据。它能够计算出单元格的值，或者从别的某个地方获取这些值。

在本节中，我们将要介绍另一个非常有用的技术，即过滤器模型（filter model），它可以用于显示来自另一个表格的，采用另一种格式的信息。在我们的示例中，我们将要对表格中的各个行进行排序。请运行示例代码中的程序，双击列标题中的一个。你将能够看到表格的各个行是如何被从新安排的，从而可以列的项目进行排序。

但是，我们并没有对数据表格模型中的各个行进行物理上的从新安排。相反，我们将使用一个过滤器模型，使数组带有从新排列的行索引。

该过滤器模型存放了一个对实际表格模型的引用。当JTable需要查看某个值时，过滤器模型便计算实际的行索引，并且从模型中获取该值。例如：

publicObject getValueAt(int r,int c)

{

   return model.getValueAt(actual row index ,c);

}

你只需要将其他所有的方法都传递给原始的模型。

publicString getColumnName(int c)

{

   return model.getColumnName(c);

}

下图显示了过滤器是如何被安排在JTable对象与实际的表格模型之间的。

表格模型的过滤器示意图

JTable--> getValueAt --> SortFilterModel --> getValueAt --> TableModel

当你实现这样一个排序过滤器时，会遇到两个复杂的问题。首先，当用户双击一个列标题时，必须要得到这个双击操作的通知。我们并不打算过分详细介绍这个技术问题。你可以在示例代码SortFilterModel类的addMouseListener方法中找到这个代码。下面是这个代码的设计思想。首先，要得到表格标题组件，并且附加一个鼠标监听器。当检测到一个双击操作时，必须确定鼠标点击操作落在表格的那一个列上。然后，必须将表格列转换成表格模型的列，如果用户将表格列随意移动的话，那么表格与表格模型的列是不同的。一旦你知道表格模型的列，你就可以对表格行进行排序。

 

例TableSortTest.java

import java.awt.*;

import java.awt.event.*;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.table.*;

 

/**

 * This program demonstrates how to sort a table column. Double-click on a table

 * columm to sort it.

 */

public class TableSortTest {

   public static void main(String[] args) {

      JFrame frame = new TableSortFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame contains a table of planet data.

 */

class TableSortFrame extends JFrame {

   public TableSortFrame() {

      setTitle("TableSortTest");

      setSize(WIDTH, HEIGHT);

 

      // set up table model andinterpose sorter

 

      DefaultTableModel model = new DefaultTableModel(cells, columnNames);

      final SortFilterModel sorter = new SortFilterModel(model);

 

      // show table

 

      final JTable table = new JTable(sorter);

      getContentPane().add(new JScrollPane(table), BorderLayout.CENTER);

 

      // set up double clickhandler for column headers

 

      table.getTableHeader().addMouseListener(new MouseAdapter() {

         public void mouseClicked(MouseEvent event) {

            // check fordouble click

            if (event.getClickCount() < 2)

                return;

 

            // find column ofclick and

            int tableColumn = table.columnAtPoint(event.getPoint());

 

            // translate totable model index and sort

            int modelColumn =table.convertColumnIndexToModel(tableColumn);

            sorter.sort(modelColumn);

         }

      });

   }

 

   private Object[][] cells = {

         { "Mercury", new Double(2440), new Integer(0), Boolean.FALSE,

                Color.yellow },

 

         { "Venus", new Double(6052), new Integer(0), Boolean.FALSE,

                Color.yellow },

         { "Earth", new Double(6378), new Integer(1), Boolean.FALSE,

                Color.blue },

         { "Mars", new Double(3397), new Integer(2), Boolean.FALSE,

                Color.red },

         { "Jupiter", new Double(71492), new Integer(16), Boolean.TRUE,

                Color.orange },

         { "Saturn", new Double(60268), new Integer(18), Boolean.TRUE,

                Color.orange },

         { "Uranus", new Double(25559), new Integer(17), Boolean.TRUE,

                Color.blue },

         { "Neptune", new Double(24766), new Integer(8),Boolean.TRUE,

                Color.blue },

         { "Pluto", new Double(1137), new Integer(1), Boolean.FALSE,

                Color.black } };

 

   private String[] columnNames = { "Planet", "Radius", "Moons", "Gaseous",

         "Color" };

 

   private static final int WIDTH = 400;

 

   private static final int HEIGHT = 200;

}

 

/**

 * This table model takes an existing table model and produces a new model that

 * sorts the rows so that the entries in a particular column are sorted.

 */

class SortFilterModel extends AbstractTableModel {

   /**

    * Constructs a sort filter model.

    *

    * @param m

    *           the table model to filter

    */

   public SortFilterModel(TableModel m) {

      model = m;

      rows = new Row[model.getRowCount()];

      for (int i = 0; i < rows.length; i++) {

         rows[i] = new Row();

         rows[i].index = i;

      }

   }

 

   /**

    * Sorts the rows.

    *

    * @param c

    *           the column that should become sorted

    */

   public void sort(int c) {

      sortColumn = c;

      Arrays.sort(rows);

      fireTableDataChanged();

   }

 

   // Compute the moved row for the threemethods that access

   // model elements

 

   public Object getValueAt(int r, int c) {

      return model.getValueAt(rows[r].index, c);

   }

 

   public boolean isCellEditable(int r, int c) {

      return model.isCellEditable(rows[r].index, c);

   }

 

   public void setValueAt(Object aValue, int r, int c) {

      model.setValueAt(aValue, rows[r].index, c);

   }

 

   // delegate all remaining methods to themodel

   public int getRowCount() {

      return model.getRowCount();

   }

 

   public int getColumnCount() {

      return model.getColumnCount();

   }

 

   public String getColumnName(int c) {

      return model.getColumnName(c);

   }

 

   public Class getColumnClass(int c) {

      return model.getColumnClass(c);

   }

 

   /**

    * This inner class holds the index of the model row Rows are compared by

    * looking at the model row entries in the sort column.

    */

   private class Row implements Comparable {

      public int index;

 

      public int compareTo(Object other) {

         Row otherRow = (Row) other;

         Object a = model.getValueAt(index, sortColumn);

         Object b = model.getValueAt(otherRow.index, sortColumn);

         if (a instanceof Comparable)

            return ((Comparable) a).compareTo(b);

         else

            return a.toString().compareTo(b.toString());

 

         // return index -otherRow.index;

      }

   }

 

   private TableModel model;

 

   private int sortColumn;

 

   private Row[] rows;

}

运行结果见图13.11


单元格的表示与编辑

在一个事例代码中，我们将再次显示我们的行星数据，不过这一次，我们想要为该表格提供更多的关于列类型的信息。如果你定义了你的表格模型的下面这个方法：

ClassgetColumnClass (int columnIndex)

以便返回用于描述列类型的类，那么JTable类就会为该类选折一个相应的绘制器。

默认的绘制器

类型

绘制为

ImageIcon

图形

Boolean

复选框

Object

字符串

如果是其他类型的类，你可以提供你自己的单元格绘制器。表格单元格绘制器与你在前面看到的树单元绘制器是类似的。它们都能够实现TableCellRenderer接口，该接口配有下面这个单一的方法：

ComponentgetTableCellRendererComponent(JTable table,Object value,boolean isSelected,boolean hasFocus,int row,int column)

参数：

 

table

包含要绘制的单元格的表格

value

要绘制的单元格

selected

如果单元格目前已经被选定 ，则 true

hasFocus

如果单元格目前已经被选定，则 true

row,column

单元格的行与列

当表格想要绘制一个单元格时，该方法便被调用。它返回一个组件，然后该paint方法将被调用，以便将数据填入单元格区域。

例：TableCellRenderTest.java

import java.awt.*;

import java.awt.event.*;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.table.*;

 

/**

 * This program demonstrates cell rendering and editing in a table.

 */

public class TableCellRenderTest {

   public static void main(String[] args) {

      JFrame frame = new TableCellRenderFrame();

      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      frame.show();

   }

}

 

/**

 * This frame contains a table of planet data.

 */

class TableCellRenderFrame extends JFrame {

   public TableCellRenderFrame() {

      setTitle("TableCellRenderTest");

      setSize(WIDTH, HEIGHT);

      TableModel model = new PlanetTableModel();

      JTable table = new JTable(model);

 

      // set up renderers andeditors

      table.setDefaultRenderer(Color.class, new ColorTableCellRenderer());

      table.setDefaultEditor(Color.class, new ColorTableCellEditor());

 

      JComboBox moonCombo = new JComboBox();

      for (int i = 0; i <= 20; i++)

         moonCombo.addItem(new Integer(i));

      TableColumnModel columnModel = table.getColumnModel();

      TableColumn moonColumn = columnModel

            .getColumn(PlanetTableModel.MOON_COLUMN);

      moonColumn.setCellEditor(new DefaultCellEditor(moonCombo));

 

      // show table

 

      table.setRowHeight(100);

      getContentPane().add(new JScrollPane(table), BorderLayout.CENTER);

   }

 

   private static final int WIDTH = 600;

 

   private static final int HEIGHT = 400;

}

 

/**

 * The planet table model specifies the values, rendering and editing properties

 * for the planet data.

 */

class PlanetTableModel extends AbstractTableModel {

   public String getColumnName(int c) {

      return columnNames[c];

   }

 

   public Class getColumnClass(int c) {

      return cells[0][c].getClass();

   }

 

   public int getColumnCount() {

      return cells[0].length;

   }

 

   public int getRowCount() {

      return cells.length;

   }

 

   public Object getValueAt(int r, int c) {

      return cells[r][c];

   }

 

   public void setValueAt(Object obj, int r, int c) {

      cells[r][c] = obj;

   }

 

   public boolean isCellEditable(int r, int c) {

      return c == NAME_COLUMN || c == MOON_COLUMN || c == GASEOUS_COLUMN

            || c == COLOR_COLUMN;

   }

 

   public static final int NAME_COLUMN = 0;

 

   public static final int MOON_COLUMN = 2;

 

   public static final int GASEOUS_COLUMN = 3;

 

   public static final int COLOR_COLUMN = 4;

 

   private Object[][] cells = {

         { "Mercury", new Double(2440), new Integer(0), Boolean.FALSE,

                Color.yellow, new ImageIcon("Mercury.gif") },

         { "Venus", new Double(6052), new Integer(0), Boolean.FALSE,

                Color.yellow, new ImageIcon("Venus.gif") },

         { "Earth", new Double(6378), new Integer(1), Boolean.FALSE,

                Color.blue, new ImageIcon("Earth.gif") },

         { "Mars", new Double(3397), new Integer(2), Boolean.FALSE,

                Color.red, new ImageIcon("Mars.gif") },

         { "Jupiter", new Double(71492), new Integer(16), Boolean.TRUE,

                Color.orange, new ImageIcon("Jupiter.gif") },

         { "Saturn", new Double(60268), new Integer(18), Boolean.TRUE,

                Color.orange, new ImageIcon("Saturn.gif") },

         { "Uranus", new Double(25559), new Integer(17), Boolean.TRUE,

                Color.blue, new ImageIcon("Uranus.gif") },

         { "Neptune", new Double(24766), new Integer(8), Boolean.TRUE,

                Color.blue, new ImageIcon("Neptune.gif") },

         { "Pluto", new Double(1137), new Integer(1), Boolean.FALSE,

                Color.black, new ImageIcon("Pluto.gif") } };

 

   private String[] columnNames = { "Planet", "Radius", "Moons", "Gaseous",

         "Color", "Image" };

}

 

/**

 * This renderer renders a color value as a panel with the given color.

 */

class ColorTableCellRenderer implements TableCellRenderer {

   public Component getTableCellRendererComponent(JTable table,Object value,

         boolean isSelected, Boolean hasFocus, int row, int column) {

      panel.setBackground((Color) value);

      return panel;

   }

 

   // the following panel is returned for allcells, with

   // the background color set to the Colorvalue of the cell

 

   private JPanel panel = new JPanel();

}

 

/**

 * This editor pops up a color dialog to edit a cell value

 */

class ColorTableCellEditor extends AbstractCellEditor implements

      TableCellEditor {

   ColorTableCellEditor() {

      panel = new JPanel();

      // prepare color dialog

 

      colorChooser = new JColorChooser();

      colorDialog = JColorChooser.createDialog(null, "Planet Color", false,

            colorChooser, new ActionListener() // OK button listener

            {

                public void actionPerformed(ActionEvent event) {

                   stopCellEditing();

                }

            }, new ActionListener() // Cancel button listener

            {

                public void actionPerformed(ActionEvent event) {

                   cancelCellEditing();

                }

            });

      colorDialog.addWindowListener(new WindowAdapter() {

         public void windowClosing(WindowEvent event) {

            cancelCellEditing();

         }

      });

   }

 

   public Component getTableCellEditorComponent(JTable table,Object value,

         boolean isSelected, int row, int column) {

      // this is where we get thecurrent Color value. We

      // store it in the dialog incase the user starts editing

      colorChooser.setColor((Color) value);

      return panel;

   }

 

   public boolean shouldSelectCell(EventObject anEvent) {

      // start editing

      colorDialog.setVisible(true);

 

      // tell caller it is ok toselect this cell

      return true;

   }

 

   public void cancelCellEditing() {

      // editing is canceled--hidedialog

      colorDialog.setVisible(false);

      super.cancelCellEditing();

   }

 

   public boolean stopCellEditing() {

      // editing is complete--hidedialog

      colorDialog.setVisible(false);

      super.stopCellEditing();

      // tell caller is is ok touse color value

      return true;

   }

 

   public Object getCellEditorValue() {

      return colorChooser.getColor();

   }

 

   private Color color;

 

   private JColorChooser colorChooser;

 

   private JDialog colorDialog;

 

   private JPanel panel;

}

运行结果见图13.12


内容总结

理解JList组件

n       使用列表模型

n       在列表模型中插入和删除值

n       列表模型中值的表示

理解树（JTree）状结构

n       树节点的枚举

n       监听树事件

n       定制树模型

理解表格（JTable）组件

n       简单的表格

n       表格模型的使用

n       排序过滤器

n       单元格的表示与编辑

你可能感兴趣的:(高级Swing 组件)

  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 如何部分格式化提示模板:LangChain中的高级技巧 nseejrukjhad langchainjava服务器python
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • 高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts信息可视化数据分析
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 2023-08-20 圆梦菌
    魔力宝贝最详细新手教程，新手该如何完美开局，建议收藏转发2023-08-2010:34《魔力宝贝》手游体力是什么?魔力宝贝体力恢复机制是每10分钟回复1点；体力作用：挑战关卡需消耗体力体力获取方式1、好友每天可以赠送15次，也就是15点体力2、系统每天中午12点以及下午6点赠送25体3、在商城使用神石购买《魔力宝贝》手游战斗力如何提升?1、宠物强化宠物通过融合进阶后可以大幅度提升战力，最高级的宠物
  • uniapp map组件自定义markers标记点 以对_ uni-app学习记录uni-appjavascript前端
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 绝招曝光！3小时高效利用ChatGPT写出精彩论文 kkai人工智能 chatgpt人工智能ai学习媒体
    在这份指南中，我将深入解析如何利用ChatGPT4.0的高级功能，指导整个学术研究和写作过程。从初步探索研究主题，到撰写结构严谨的学术论文，我将一步步展示如何在每个环节中有效运用ChatGPT。如果您还未使用PLUS版本，可以参考相关教程。**初步探索与主题的确定**起初，我处于庞大的知识领域中，寻找一个可深入研究的领域。ChatGPT如同灯塔，通过深入分析最新研究趋势和领域热点，帮助我在广阔的学
  • MyBatis 详解 阿贾克斯的黎明 javamybatis
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
  • 使用由 Python 编写的 lxml 实现高性能 XML 解析 hunyxv python笔记pythonxml
    转载自：文章lxml简介Python从来不出现XML库短缺的情况。从2.0版本开始，它就附带了xml.dom.minidom和相关的pulldom以及SimpleAPIforXML(SAX)模块。从2.4开始，它附带了流行的ElementTreeAPI。此外，很多第三方库可以提供更高级别的或更具有python风格的接口。尽管任何XML库都足够处理简单的DocumentObjectModel(DOM
  • 【加密算法基础——对称加密和非对称加密】 XWWW668899 网络安全服务器笔记
    对称加密与非对称加密对称加密和非对称加密是两种基本的加密方法，各自有不同的特点和用途。以下是详细比较：1.对称加密特点密钥:使用相同的密钥进行加密和解密。发送方和接收方必须共享这个密钥。速度:通常速度较快，适合处理大量数据。实现:算法相对简单，计算效率高。常见算法AES(高级加密标准)DES(数据加密标准)3DES(三重数据加密标准)RC4(流密码)应用场景文件加密磁盘加密传输大量数据时的加密2.
  • Python编程 - 函数进阶 易辰君 Python核心编程python开发语言
    目录前言一、函数参数的高级用法（一）缺省参数（二）命名参数（三）不定长参数二、拆包（一）函数返回值拆包（二）通过星号拆包（三）总结三、匿名函数（一）函数定义（二）使用匿名函数四、递归函数（一）简介（二）基本结构（三）简单示例（四）优缺点总结前言上篇文章主要了解了函数基础，如何定义函数，函数种类以及局部变量和全局变量的差异等，接下来就讲解python函数较为进阶的知识点，若有任何想法欢迎一起沟通讨论
  • 信息系统安全相关概念(上) YuanDaima2048 课程笔记基础概念安全信息安全笔记
    文章总览：YuanDaiMa2048博客文章总览下篇:信息系统安全相关概念(下)信息系统安全相关概念[上]信息系统概述信息系统信息系统架构信息系统发展趋势：信息系统日趋大型化、复杂化信息系统面临的安全威胁信息系统安全架构设计--以云计算为例信息系统安全需求及安全策略自主访问控制策略DAC强制访问控制策略MAC信息系统概述信息系统用于收集、存储和处理数据以及传递信息、知识和数字产品的一组集成组件。几
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换 让开，我要吃人了 OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
  • 内存保护学习（一）：tc27x的内存保护MPU设置浅析（个人理解） 剑从东方起 链接文件及功能安全开发语言c语言
    目录一、背景二、Tc27x相关寄存器1、注意点2、注意几个强相关寄存器1）、数据保护范围寄存器2）、代码保护范围寄存器3）、保护集启用寄存器命名约定4）、PSW（每个核都有一个）5）、SYSCON三、使用方法1、内存方面2、在ECUM里面初始化MPU3、OS回调CBK检查4、机理5、补充点一、背景根据低ASIL等级开发的软件组件可能会错误地访问具有较高ASIL等级的软件组件的内存区域，从而产生干扰
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • 详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因 hw_happy 开发语言前端vue.jsjavascript
    前情提要在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有exportdefault，在中，所有定义的变量、函数和组件都会自动被视为默认导出的组件内容。因此，不需要显式地使用exportdefault来导出组件。但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为TypeScript和Vue的默认导出
  • swing窗体打jar包后找不到图片的问题 zoyation javajarswingclassloaderimageeclipsejava
    今天打jar包遇到一个怪问题:打成jar包后双击运行没反应cmd运行有反应但出现下列问题Causedby:java.lang.ExceptionInInitializerErroratcom.zou.ui.MyDialog.init(MyDialog.java:92)atcom.zou.ui.MyDialog.(MyDialog.java:45)atcom.zou.ui.LoginDialog.(
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
  • ztree设置禁用节点 3213213333332132 JavaScriptztreejsonsetDisabledNodeAjax
    ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 $(function(){ showTree(); setDisabledNode(); });
  • JVM patch by Taobao bookjovi javaHotSpot
    在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。   7050685：jsdbproc64.sh has a typo in the package name 7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 7060619：C1 should respect inline and
  • 将session存储到数据库中 dcj3sjt126com sqlPHPsession
    CREATE TABLE sessions ( id CHAR(32) NOT NULL, data TEXT, last_accessed TIMESTAMP NOT NULL, PRIMARY KEY (id) );   <?php /** * Created by PhpStorm. * User: michaeldu * Date
  • Vector 171815164 vector
    public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) { for (int i = 0; i < cart.size(); i++) { if (cart.get(i).getId().equals(id)) { cart.remove(i);
  • 各连接池配置参数比较 g21121 连接池
            排版真心费劲，大家凑合看下吧，见谅~     Druid DBCP C3P0 Proxool 数据库用户名称 Username Username User   数据库密码 Password Password Password   驱动名
  • [简单]mybatis insert语句添加动态字段 53873039oycg mybatis
          mysql数据库,id自增,配置如下：       <insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id" parameterType=&
  • struts2拦截器配置 云端月影 struts2拦截器
    struts2拦截器interceptor的三种配置方法 方法1. 普通配置法 <struts>     <package name="struts2" extends="struts-default">         &
  • IE中页面不居中，火狐谷歌等正常 aijuans IE中页面不居中
    问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
  • String,int,Integer,char 几个类型常见转换 antonyup_2006 htmlsql.net
    如何将字串 String 转换成整数 int? int i = Integer.valueOf(my_str).intValue(); int i=Integer.parseInt(str); 如何将字串 String 转换成Integer ? Integer integer=Integer.valueOf(str); 如何将整数 int 转换成字串 String ? 1.
  • PL/SQL的游标类型 百合不是茶 显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)
    游标是oracle中的一个结果集,用于存放查询的结果;   PL/SQL中游标的声明; 1,声明游标 2,打开游标(默认是关闭的); 3,提取数据 4,关闭游标     注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标   隐式游标:主要是对DML数据的操作隐
  • JUnit4中@AfterClass @BeforeClass @after @before的区别对比 bijian1013 JUnit4单元测试
    一.基础知识 JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
  • 精通Oracle10编程SQL(12)开发包 bijian1013 oracle数据库plsql
    /* *开发包 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数） */ --包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成 --建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等 --在包规
  • 【EhCache二】ehcache.xml配置详解 bit1129 ehcache.xml
    在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ ehcache.xml ： http://ehcache.org/ehcache.xml ehcache.xsd ： http://ehcache.org/ehcache.xsd ehcache配置文件的根元素是ehcahe   ehcac
  • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL 白糖_ javaeclipsespringtomcatWeb
    今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>  随后启动
  • angular.element boyitech AngularJSAngularJS APIangular.element
    angular.element 描述:     包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）     如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
  • java-给定两个已排序序列，找出共同的元素。 bylijinnan java
    import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class CommonItemInTwoSortedArray { /** * 题目：给定两个已排序序列，找出共同的元素。 * 1.定义两个指针分别指向序列的开始。 * 如果指向的两个元素
  • sftp 异常，有遇到的吗？求解 Chen.H javajcraftauthjschjschexception
    com.jcraft.jsch.JSchException: Auth cancel at com.jcraft.jsch.Session.connect(Session.java:460) at com.jcraft.jsch.Session.connect(Session.java:154) at cn.vivame.util.ftp.SftpServerAccess.connec
  • [生物智能与人工智能]神经元中的电化学结构代表什么? comsci 人工智能
         我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色....      我们可以尝试一下...在某些神经
  • 通过LAC和CID获取经纬度信息 dai_lm laccid
    方法1： 用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度 方法2： 发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
  • JAVA的困难分析 datamachine java
    前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。   -----------------------------------------------------------------------------------------
  • 小学5年级英语单词背诵第二课 dcj3sjt126com englishword
    money 钱 paper 纸 speak 讲，说 tell 告诉   remember 记得，想起 knock 敲，击，打 question 问题 number 数字，号码   learn 学会，学习 street 街道 carry 搬运，携带 send 发送，邮寄，发射   must 必须 light 灯，光线，轻的 front
  • linux下面没有tree命令 dcj3sjt126com linux
    centos p安装 yum -y install tree   mac os安装 brew install tree   首先来看tree的用法 tree 中文解释：tree 功能说明：以树状图列出目录的内容。 语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
  • Map迭代方式，Map迭代，Map循环 蕃薯耀 Map循环Map迭代Map迭代方式
    Map迭代方式，Map迭代，Map循环   >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年
  • Spring Cache注解+Redis hanqunfeng spring
    Spring3.1 Cache注解  依赖jar包： <!-- redis --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId>
  • Guava中针对集合的 filter和过滤功能 jackyrong filter
    在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子：    @Test public void whenFilterWithIterables_thenFiltered() { List<String> names = Lists.newArrayList("John"
  • 学习编程那点事 lampcy 编程androidPHPhtml5
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
  • 架构师之流处理---------bytebuffer的mark,limit和flip nannan408 ByteBuffer
    1.前言。   如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。 2.例子. 例子代码: String str = "helloWorld"; ByteBuffer buff = ByteBuffer.wrap(str.getBytes()); Sy
  • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1 Everyday都不同 $转义el表达式
    最近在做Highcharts的过程中，在写js时，出现了以下异常：   严重: Servlet.service() for servlet jsp threw exception org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1,
  • 用Java实现发送邮件到163 tntxia java实现
    /* 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。 本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。 此篇仅介绍用
  • 探索实体类存在的真正意义 java小叶檀 POJO
    一. 实体类简述    实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 POJO（Plain Old Java Objects）简单的Java对象   它的一般格式就是 public class A{ private String id; public Str
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他