Как Использовать Деревья

С JTree class, можно вывести на экран иерархические данные. A JTree объект фактически не содержит Ваши данные; это просто обеспечивает представление данных. Как любой нетривиальный компонент Swing, дерево получает данные, запрашивая его модель данных. Вот изображение дерева:

Поскольку предыдущие данные показывают, JTree выводит на экран его данные вертикально. Каждая строка, выведенная на экран деревом, содержит точно один элемент данных, которые вызывают узлом. У каждого дерева есть корневой узел, от которого убывают все узлы. По умолчанию дерево выводит на экран корневой узел, но можно установить декретом иначе. У узла могут или быть дочерние элементы или нет. Мы обращаемся к узлам, у которых могут быть дочерние элементы — есть ли у них в настоящий момент дочерние элементы — как узлы ответвления. Узлы, у которых не может быть дочерних элементов, являются вершинами.

У узлов ответвления может быть любое число дочерних элементов. Как правило, пользователь может развернуть и свернуть узлы ответвления — создание их дочерних элементов, видимых или невидимых — щелкая по ним. По умолчанию все узлы ответвления кроме корневого узла начинаются свернутый. Программа может обнаружить изменения в состоянии расширения узлов ответвления, прислушиваясь к древовидному расширению, или события "дерево расширятся", как описано в том, Как Записать Древовидному Слушателю Расширения и Как Записать, что Слушатель "дерево Расширится".

Определенный узел в дереве может быть идентифицирован или TreePath, объект, который инкапсулирует узел и всех его предков, или его строкой дисплея, где каждая строка в области дисплея выводит на экран один узел.

• Расширенный узел является узлом, не являющимся листом, который выведет на экран его дочерние элементы, когда все его предки будут расширены.
• Свернутый узел является тем, который скрывает их.
• Скрытый узел является тем, который находится под контролем свернутого предка.

Остальная часть этого раздела обсуждает следующие темы:

• Создание Дерева
• Отвечание на Выбор Узла
• Настройка Дисплея Дерева
• Динамически Изменение Дерева
• Создание Модели данных
• Древовидный API
• Примеры то Использование Деревья

Создание Дерева

Вот изображение приложения, верхняя часть которого выводит на экран дерево в области прокрутки.

Следующий код, взятый от TreeDemo.java, создает JTree возразите и помещает это в область прокрутки:

//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);
    
    //Swing Tutorial
    book = new DefaultMutableTreeNode(new BookInfo
        ("The 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; в таком сценарии можно переопределить convertValueToText JTree, чтобы отобразить объект от модели в строку, которая выводится на экран.

Например, BookInfo class, используемым в предыдущем фрагменте кода, является пользовательский class, который содержит две части данных: имя книги, и URL для файла HTML, описывающего книгу. toString метод реализуется, чтобы возвратить название книги. Таким образом каждый узел связался с a BookInfo возразите выводит на экран название книги.

Чтобы подвести итог, можно создать дерево, вызывая JTree конструктор, определяя class, который реализует TreeNode как параметр. Следует, вероятно, поместить дерево в области прокрутки, так, чтобы дерево не заняло бы слишком много места. Вы не должны сделать ничего, чтобы заставить древовидные узлы расшириться и выйти из строя в ответ на пользовательские щелчки. Однако, действительно необходимо добавить некоторый код, чтобы заставить дерево ответить, когда пользователь выбирает узел — щелкая по узлу, например.

Отвечание на Выбор Узла

Отвечание на древовидные выборы узла просто. Вы реализуете древовидного слушателя выбора и регистрируете это на дереве. Следующий код показывает связанный с выбором код от TreeDemo программа:

//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); 
    }
}

Предыдущий код выполняет эти задачи:

• Получает значение по умолчанию TreeSelectionModel для дерева, и затем устанавливает это так, чтобы самое большее один древовидный узел за один раз мог быть выбран.
• Регистрирует обработчик событий на дереве. Обработчик событий является объектом, который реализует TreeSelectionListener интерфейс.
• В конечном счете обработчик, определяет, какой узел выбирается, вызывая дерево getLastSelectedPathComponent метод.
• Использование getUserObject метод, чтобы связать данные с узлом.

Для получения дополнительной информации об обработке древовидных событий выбора, см., Как Записать Древовидному Слушателю Выбора.

Настройка Дисплея Дерева

Вот изображение некоторых древовидных узлов, как оттянуто Java, Windows, и реализациями стили Mac OS.

Стиль Java	Стиль Windows	Стиль Mac OS

Поскольку предыдущие данные показывают, дерево традиционно выводит на экран значок и некоторый текст для каждого узла. Можно настроить их, поскольку мы покажем коротко.

Дерево обычно также выполняет некоторый стиль определенное рисование, чтобы указать на отношения между узлами. Можно настроить это рисование ограниченным способом. Во-первых, можно использовать tree.setRootVisible(true) показать корневой узел или tree.setRootVisible(false) скрыть это. Во-вторых, можно использовать tree.setShowsRootHandles(true) чтобы запросить что, у высокоуровневых узлов дерева — корневого узла (если это видимо) или его дочерние элементы (если не) — есть дескрипторы, которые позволяют им быть расширенными или свернутыми.

Если Вы используете стиль Java, можно настроить, проводятся ли линии, чтобы показать отношения между древовидными узлами. По умолчанию стиль Java проводит повернутые линии между узлами. Устанавливая JTree.lineStyle клиентское свойство дерева, можно определить различное соглашение. Например, чтобы запросить, чтобы стиль Java использовал только горизонтальные строки, чтобы сгруппировать узлы, используйте следующий код:

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

Чтобы определить, что стиль Java не должен провести линии, используйте этот код:

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

Следующие снимки показывают результаты установки JTree.lineStyle свойство, при использовании стили Java.

"Angled" (значение по умолчанию)	"Horizontal"	"None"

Независимо от того, что стиль, значок значения по умолчанию, выведенный на экран узлом, определяется тем, является ли узел листом и, в противном случае расширяется ли это. Например, в Windows и реализациях стили Мотива, значок значения по умолчанию для каждой вершины является точкой; в стили Java листовой значок значения по умолчанию является подобным бумаге символом. Во всех реализациях стили мы показали, узлы ответвления отмечаются с подобными папке символами. У некоторого взгляда и чувств могли бы быть различные значки для расширенных ответвлений против свернутых ответвлений.

Можно легко изменить значок значения по умолчанию, используемый для листа, расширенного ответвления, или свернутых узлов ответвления. Чтобы сделать так, Вы сначала создаете экземпляр DefaultTreeCellRenderer. Вы могли всегда создавать свою собственную реализацию TreeCellRenderer с нуля, снова используя любые компоненты, которые Вы любите. Затем, определите значки, чтобы использовать, вызывая один или больше следующих методов на средстве рендеринга: setLeafIcon (для вершин), setOpenIcon (для расширенных узлов ответвления), setClosedIcon (для свернутых узлов ответвления). Если Вы хотите, чтобы дерево не вывело на экран значка для типа узла, то определите null для значка. Как только Вы установили значки, используйте дерево setCellRenderer метод, чтобы определить, что DefaultTreeCellRenderer нарисуйте его узлы. Вот пример, взятый от TreeIconDemo.java:

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

Вот снимок экрана TreeIconDemo:

Если Вы хотите более прекрасное управление значками узла, или Вы хотите обеспечить подсказки, можно сделать так, создавая подкласс DefaultTreeCellRenderer и переопределение getTreeCellRendererComponent метод. Поскольку DefaultTreeCellRenderer подкласс JLabel, можно использовать любого JLabel метод — такой как setIcon — настроить DefaultTreeCellRenderer.

Следующий код, от TreeIconDemo2.java, создает средство рендеринга ячейки, которое изменяет листовой значок в зависимости от того, является ли слово "Tutorial" в текстовых данных узла. Средство рендеринга также определяет текст подсказки как полужирное шоу строк.

//...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;
    }
}

Вот результат:

Вы могли бы задаваться вопросом, как работает средство рендеринга ячейки. Когда дерево красит каждый узел, ни один JTree ни его стиль, определенная реализация фактически содержит код, который красит узел. Вместо этого дерево использует код рисования средства рендеринга ячейки, чтобы нарисовать узел. Например, чтобы нарисовать вершину, у которой есть строка "Язык программирования Java", дерево просит, чтобы его средство рендеринга ячейки возвратило компонент, который может нарисовать вершину той строкой. Если средство рендеринга ячейки является a DefaultTreeCellRenderer, тогда это возвращает метку, которая красит листовой значок значения по умолчанию сопровождаемым строкой.

Средство рендеринга ячейки только красит; это не может обработать события. Если Вы хотите добавить обработку событий к дереву, Вы должны зарегистрировать свой обработчик или на дереве или на, если обработка происходит только, когда узел выбирается, редактор ячейки дерева. Для получения информации о редакторах ячейки см. Понятия: Редакторы и Средства рендеринга. Тот раздел обсуждает табличных редакторов ячейки и средства рендеринга, которые подобны древовидным редакторам ячейки и средствам рендеринга.

Динамически Изменение Дерева

Следующие данные показывают приложение под названием DynamicTreeDemo, который позволяет Вам добавлять узлы к и удалять узлы из видимого дерева. Можно также отредактировать текст в каждом узле.

Приложение основано на примере, обеспеченном учебным читателем Ричардом Стэнфордом.

Вот код, который инициализирует дерево:

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);

Явно создавая модель дерева, код гарантирует, что модель дерева является экземпляром DefaultTreeModel. Тем путем мы знаем все методы, которые поддерживает древовидная модель. Например, мы знаем, что можем вызвать модель insertNodeInto метод, даже при том, что тот метод не требуется TreeModel интерфейс.

Чтобы сделать текст в узлах дерева доступным для редактирования, мы вызываем setEditable(true) на дереве. Когда пользователь закончил редактировать узел, модель генерирует древовидное событие модели, которое говорит любым слушателям — включая JTree — тот древовидные узлы изменились. Отметьте это хотя DefaultMutableTreeNode имеет методы для того, чтобы изменить контент узла, изменения должны пройти через DefaultTreeModel методы покрытия. Иначе, древовидные события модели не были бы сгенерированы, и слушатели, такие как дерево не будут знать об обновлениях.

Чтобы быть уведомленными относительно изменений узла, мы можем реализовать a TreeModelListener. Вот пример древовидного слушателя модели, который обнаруживает, когда пользователь ввел новое имя для древовидного узла:

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) {
    }
}

Вот код что использование обработчика событий кнопки Add, чтобы добавить новый узел к дереву:

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;
}

Код создает узел, вставляет, он в древовидную модель, и затем, если приспособлено, запрашивает, чтобы узлы выше его были расширены и дерево, прокрученное так, чтобы новый узел был видим. Чтобы вставить узел в модель, код использует insertNodeInto метод, обеспеченный DefaultTreeModel class.

Создание Модели данных

Если DefaultTreeModel не удовлетворяет Вашим потребностям, тогда Вы должны будете записать пользовательскую модель данных. Ваша модель данных должна реализовать TreeModel интерфейс. TreeModel определяет методы для того, чтобы получить определенный узел дерева, получая число дочерних элементов определенного узла, определяя, является ли узел листом, уведомляя модель изменения в дереве, и добавляя и удаляя древовидных слушателей модели.

Интересно, TreeModel интерфейс принимает любой вид объекта как древовидный узел. Это не требует, чтобы узлы были представлены DefaultMutableTreeNode объекты, или даже что узлы реализуют TreeNode интерфейс. Таким образом, если TreeNode интерфейс не является подходящим для Вашей древовидной модели, не стесняйтесь разрабатывать свое собственное представление для древовидных узлов. Например, если у Вас есть существующая ранее иерархическая структура данных, Вы не должны копировать ее или вызвать ее в TreeNode пресс-форма. Вы только должны реализовать свою древовидную модель так, чтобы она использовала информацию в существующей структуре данных.

Следующие данные показывают приложение под названием GenealogyExample, который выводит на экран потомков или предков определенного человека. (Благодаря учебному читателю Оливье Берланжеру для того, чтобы обеспечить этот пример.)

Можно найти пользовательскую древовидную реализацию модели в GenealogyModel.java. Поскольку модель реализуется как Object подкласс вместо, скажем, подкласса DefaultTreeModel, это должно реализовать TreeModel взаимодействуйте через интерфейс непосредственно. Это требует методов реализации для того, чтобы получить информацию об узлах, такой как, который является корнем и что является дочерними элементами определенного узла. В случае GenealogyModel, каждый узел представляется объектом типа Person, пользовательский class, который не реализует TreeNode.

Древовидная модель должна также реализовать методы для добавления и удаления древовидных слушателей модели, и должна стрелять TreeModelEvents тем слушателям, когда структура дерева или изменения данных. Например, когда пользователь дает GenealogyExample команду переключаться от показа предков к показу потомков, древовидная модель производит изменение и затем запускает событие, чтобы сообщить его слушателям (таким как древовидный компонент).

Как Загрузить Дочерние элементы Лениво

Ленивая загрузка является характеристикой приложения, когда фактическая загрузка и инстанцирование class задерживаются до точки непосредственно перед тем, как фактически используется экземпляр.

Мы получаем что-нибудь, загружая их лениво? Да, это определенно добавило бы к производительности приложения. Лениво загружаясь, можно выделить ресурсы памяти, чтобы загрузить и инстанцировать объекта только, когда он фактически используется. Можно также ускорить начальное время загрузки приложения.

Один из способов, которыми можно лениво загрузить дочерние элементы Дерева, используя интерфейс TreeWillExpandListener. Например, можно объявить и загрузить корень, прародителя и родителя Дерева наряду с приложением как показано в следующем коде:

Давайте объявим корень, прародителя и давайте породим как показано ниже:

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;
        }

Можно загрузиться выше объявленных узлов к дереву как показано в следующем коде:

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

Теперь, можно загрузить дочерние элементы лениво в приложение всякий раз, когда родительский узел Restaurants видимо в приложении. Чтобы сделать это, давайте объявим два дочерних элемента в отдельном методе и давайте вызовем тот метод как показано в следующем коде:

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();
        }

См., Как Записать, что Слушатель "дерево Развернет" для описания слушателей "дерево, Расширится".

Древовидный API

Древовидный API довольно обширен. Следующие таблицы приводят только немного API, концентрирующийся на следующих категориях:

• Связанные с деревом Классы и Интерфейсы
• Создание и Установка Дерева
• Реализация Выбора
• Показ и Сокрытие Узлов

Для получения дополнительной информации о древовидном API, см. документацию API для JTree и для различных классов и интерфейсов в древовидном пакете. Также обратитесь к Классу JComponent для информации о API JTree наследовался от его суперкласса.

Примеры то Использование Деревья

Эта таблица приводит примеры то использование JTree и где те примеры описываются.

Если Вы программируете в JavaFX, см. Структурный вид.