Java 从文件中填充N叶树

我已经构建了一个具有预定义最大级别的N叶树

我填写的数据大约是1.5亿个字符

我填充树的方法是创建一个长度等于最大级别的

list

，然后调用

addNodes（list）

方法。（下面是源代码）

现在的问题是，最高级别越高，所需时间就越长，这是显而易见的。使用

level=6

大约需要4分钟，而使用

level=7

则需要20分钟

我正在寻找的是一种可能并行填充树的方法（我不知道如何做，或者它是否会有任何好处），或者使填充过程更高效，内存不是问题（至少目前是这样）

源代码：

节点：

公共类节点{
节点父节点；
列出儿童名单；
字符键值；
整数计数；
//构造函数&getter和setter方法
}

树：

公共类树{
节点根
公共无效addListToTree（列表）{
//检查list.i是否为空
if（root.children.isEmpty（））{
节点父节点=根节点；
用于（字符e:列表）{
节点=新节点（父节点，e，1，0）；
parent.addChildren（节点）；
父节点=节点；
}
}否则{
节点tmp=根；
对于（int i=0；i

ReadFileContents：

public void start() {

    String file_contents = "";
    try {
        FileReader fr = new FileReader(new File(filepath));
        BufferedReader br = new BufferedReader(fr);

        String tmp;
        while ((tmp = br.readLine()) != null) {
            file_contents += tmp;
        }
        br.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    ArrayList<Character> tmp = new ArrayList<Character>();
    for (char e : file_contents.toCharArray()) {
        tmp.add(e);
        // System.out.println("Chunksize: " + chunksize);
        if (chunksize == tmp.size()) {
            toTrain.addListToTree(tmp);
            tmp.remove(0);
        }
    }
    while (tmp.size() > 0) {
        toTrain.addListToTree(tmp);
        tmp.remove(0);
    }
}

public void start（）{
字符串文件_contents=“”；
试一试{
FileReader fr=新文件读取器（新文件（文件路径））；
BufferedReader br=新的BufferedReader（fr）；
串tmp；
而（（tmp=br.readLine（））！=null）{
文件内容+=tmp；
}
br.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
ArrayList tmp=新的ArrayList（）；
for（char e:file_contents.toCharArray（））{
tmp.add（e）；
//System.out.println（“Chunksize:+Chunksize”）；
if（chunksize==tmp.size（））{
toTrain.addListToTree（tmp）；
tmp.remove（0）；
}
}
而（tmp.size（）>0）{
toTrain.addListToTree（tmp）；
tmp.remove（0）；
}
}

public class Tree{
    Node root

    public void addListToTree(List<Character> list){
        //check if list.isEmpty
        if(root.children.isEmpty()){
            Node parent = root;

            for (Character e : list) {
                Node node = new Node(parent, e, 1, 0);
                parent.addChildren(node);
                parent = node;
            }
        } else {
            Node tmp = root;

            for (int i = 0; i < list.size(); i++) {
                Node node = new Node(null, list.get(i), 1, 0);

                if (-1 != tmp.getChildIndex(node)) {
                    tmp = tmp.getChild(node);
                    tmp.setCount(1); //increments counter by 1
                } else {
                    node.setParent(tmp);
                    tmp.addChildren(node);
                    tmp = node;
                }
            }
        }
    }
}

public void start() {

    String file_contents = "";
    try {
        FileReader fr = new FileReader(new File(filepath));
        BufferedReader br = new BufferedReader(fr);

        String tmp;
        while ((tmp = br.readLine()) != null) {
            file_contents += tmp;
        }
        br.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    ArrayList<Character> tmp = new ArrayList<Character>();
    for (char e : file_contents.toCharArray()) {
        tmp.add(e);
        // System.out.println("Chunksize: " + chunksize);
        if (chunksize == tmp.size()) {
            toTrain.addListToTree(tmp);
            tmp.remove(0);
        }
    }
    while (tmp.size() > 0) {
        toTrain.addListToTree(tmp);
        tmp.remove(0);
    }
}