public class Tree {
    private List<Tree> leaves = new LinkedList<Tree>();
    private Tree parent = null;
    private String data;

    public Tree(String data, Tree parent) {
        this.data = data;
        this.parent = parent;
    }
}

显然，您可以添加实用方法来添加/删除子级。

java中没有适合您需求的特定数据结构。您的需求非常具体，为此您需要设计自己的数据结构。看看您的需求，任何人都可以说您需要某种具有特定功能的n元树。您可以按以下方式设计数据结构：
结构类似于节点的树，内容类似于节点和子节点的列表：类节点{字符串值；列出子项；}
您需要检索给定字符串的子级，因此可以使用2种方法1:node searchnode（string str），将返回与给定输入具有相同值的节点（使用bfs进行搜索）2:list getchildren（string str）：此方法将在内部调用searchnode以获取具有相同字符串的节点，然后创建子节点的所有字符串值的列表并返回。
您还需要在树中插入一个字符串。您必须编写一个方法，比如void insert（string parent，string value）：这将再次搜索值等于parent的节点，然后您可以创建一个具有给定值的节点，并将其添加到找到的父节点的子节点列表中。
我建议，您在一个类中编写节点的结构，比如类节点{string value；列出子项；}以及其他所有方法，如search、insert和getchildren在另一个nodeutils类中，这样您也可以传递树的根来对特定的树执行操作，如：class nodeutils{public static node search（node root，string value）{//perform bfs and return node}

不使用集合框架的树的自定义树实现。它包含树实现所需的不同基本操作。

class Node {

    int data;
    Node left;
    Node right;

    public Node(int ddata, Node left, Node right) {
        this.data = ddata;
        this.left = null;
        this.right = null;      
    }

    public void displayNode(Node n) {
        System.out.print(n.data + " "); 
    }

}

class BinaryTree {

    Node root;

    public BinaryTree() {
        this.root = null;
    }

    public void insertLeft(int parent, int leftvalue ) {
        Node n = find(root, parent);
        Node leftchild = new Node(leftvalue, null, null);
        n.left = leftchild;
    }

    public void insertRight(int parent, int rightvalue) {
        Node n = find(root, parent);
        Node rightchild = new Node(rightvalue, null, null);
        n.right = rightchild;
    }

    public void insertRoot(int data) {
        root = new Node(data, null, null);
    }

    public Node getRoot() {
        return root;
    }

    public Node find(Node n, int key) {     
        Node result = null;

        if (n == null)
            return null;

        if (n.data == key)
            return n;

        if (n.left != null)
            result = find(n.left, key);

        if (result == null)
            result = find(n.right, key);

        return result;
    } 

    public int getheight(Node root){
        if (root == null)
            return 0;

        return Math.max(getheight(root.left), getheight(root.right)) + 1; 
    }

    public void printTree(Node n) {     
        if (n == null)
            return;

        printTree(n.left);
        n.displayNode(n);
        printTree(n.right);             
    }

}

java中有两种树数据结构，例如jdk swing中的defaultmutabletreenode、stanford parser包中的树，以及其他玩具代码。但这些都不足以满足一般用途。
javatree项目试图用java提供另一种通用的树数据结构。这和其他的区别是
完全免费。你可以在任何地方使用它（除了你的家庭作业：p）
小但足够一般。我把所有的数据结构都放在一个类文件中，所以很容易复制/粘贴。
不仅仅是玩具。我知道很多java树代码只能处理二叉树或有限的操作。这个树节点远不止那个。它提供了不同的节点访问方式，如前序、后序、广度优先、叶子、根路径等，并且还提供了迭代器以保证访问的充分性。
将添加更多实用程序。我愿意添加更多的操作，使这个项目全面，特别是如果你通过github发送请求。

例如：

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @author X2
 *
 * @param <T>
 */
public class HisTree<T> 
{
    private Node<T> root;

    public HisTree(T rootData) 
    {
        root = new Node<T>();
        root.setData(rootData);
        root.setChildren(new ArrayList<Node<T>>());
    }

}

class Node<T> 
{

    private T data;
    private Node<T> parent;
    private List<Node<T>> children;

    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    public Node<T> getParent() {
        return parent;
    }
    public void setParent(Node<T> parent) {
        this.parent = parent;
    }
    public List<Node<T>> getChildren() {
        return children;
    }
    public void setChildren(List<Node<T>> children) {
        this.children = children;
    }
}

由于问题需要可用的数据结构，因此可以从列表或数组构建树：

Object[] tree = new Object[2];
tree[0] = "Hello";
{
  Object[] subtree = new Object[2];
  subtree[0] = "Goodbye";
  subtree[1] = "";
  tree[1] = subtree;
}
``` `instanceof` 可用于确定元素是子树还是终端节点。

可以在java.util.*中使用treeset类。它就像二叉搜索树一样工作，所以它已经被排序了。treeset类实现了iterable、collection和set接口。您可以像一个集合一样使用迭代器遍历树。

TreeSet<String> treeSet = new TreeSet<String>();
Iterator<String> it  = treeSet.Iterator();
while(it.hasNext()){
...
}

你可以查一下，java文档和其他一些。

public abstract class Node {
  List<Node> children;

  public List<Node> getChidren() {
    if (children == null) {
      children = new ArrayList<>();
    }
    return chidren;
  }
}

它简单易用。要使用它，请扩展它：

public class MenuItem extends Node {
  String label;
  String href;
  ...
}

// TestTree.java
// A simple test to see how we can build a tree and populate it
//
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;

public class TestTree extends JFrame {

  JTree tree;
  DefaultTreeModel treeModel;

  public TestTree( ) {
    super("Tree Test Example");
    setSize(400, 300);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
  }

  public void init( ) {
    // Build up a bunch of TreeNodes. We use DefaultMutableTreeNode because the
    // DefaultTreeModel can use it to build a complete tree.
    DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
    DefaultMutableTreeNode subroot = new DefaultMutableTreeNode("SubRoot");
    DefaultMutableTreeNode leaf1 = new DefaultMutableTreeNode("Leaf 1");
    DefaultMutableTreeNode leaf2 = new DefaultMutableTreeNode("Leaf 2");

    // Build our tree model starting at the root node, and then make a JTree out
    // of it.
    treeModel = new DefaultTreeModel(root);
    tree = new JTree(treeModel);

    // Build the tree up from the nodes we created.
    treeModel.insertNodeInto(subroot, root, 0);
    // Or, more succinctly:
    subroot.add(leaf1);
    root.add(leaf2);

    // Display it.
    getContentPane( ).add(tree, BorderLayout.CENTER);
  }

  public static void main(String args[]) {
    TestTree tt = new TestTree( );
    tt.init( );
    tt.setVisible(true);
  }
}