解析Newick格式的Java库或代码？

有谁知道一个好的Java库可以用来轻松解析Newick文件？或者如果你有一些我可以使用的经过测试的源代码

---

我想读取java中的newick文件，并生成该文件的可视化表示。我见过一些java程序可以做到这一点，但不容易在代码中找到解析的工作方式。

似乎包括一个（但每个文件仅限于一棵树）。

请查看FigTree和BEAST fame的jebl（java进化生物学库）。可能比您需要的树功能多得多，但它是一个坚实的库。

在寻找Java Newick解析器时偶然发现了这个问题

我也遇到过，它似乎是来自Juxtaposer的Newick解析器的更新版本。

我喜欢使用基于库的库。它可以做的远不止解析和可视化树，但它的使用仍然非常简单，即使对于基本任务：

import java.io.IOException;    
import org.forester.archaeopteryx.Archaeopteryx;
import org.forester.phylogeny.Phylogeny;

public class PhylogenyTree {
    public static void main(String[] args) throws IOException{
        String nhx = "(mammal,(turtle,rayfinfish,(frog,salamander)))";
        Phylogeny ph = Phylogeny.createInstanceFromNhxString(nhx);
        Archaeopteryx.createApplication(ph);
    }

}

---

这是我为个人使用而编写的Newick解析器。健康地使用它；没有包括可视化

import java.util.ArrayList;

/**
 * Created on 12/18/16
 *
 * @author @author <a href="mailto:knapp@american.edu">Adam Knapp</a>
 * @version 0.1
 */
public class NewickTree {

    private static int node_uuid = 0;
    ArrayList<Node> nodeList = new ArrayList<>();
    private Node root;

    static NewickTree readNewickFormat(String newick) {
        return new NewickTree().innerReadNewickFormat(newick);
    }

    private static String[] split(String s) {

        ArrayList<Integer> splitIndices = new ArrayList<>();

        int rightParenCount = 0;
        int leftParenCount = 0;
        for (int i = 0; i < s.length(); i++) {
            switch (s.charAt(i)) {
                case '(':
                    leftParenCount++;
                    break;
                case ')':
                    rightParenCount++;
                    break;
                case ',':
                    if (leftParenCount == rightParenCount) splitIndices.add(i);
                    break;
            }
        }

        int numSplits = splitIndices.size() + 1;
        String[] splits = new String[numSplits];

        if (numSplits == 1) {
            splits[0] = s;
        } else {

            splits[0] = s.substring(0, splitIndices.get(0));

            for (int i = 1; i < splitIndices.size(); i++) {
                splits[i] = s.substring(splitIndices.get(i - 1) + 1, splitIndices.get(i));
            }

            splits[numSplits - 1] = s.substring(splitIndices.get(splitIndices.size() - 1) + 1);
        }

        return splits;
    }

    private NewickTree innerReadNewickFormat(String newick) {

        // single branch = subtree (?)
        this.root = readSubtree(newick.substring(0, newick.length() - 1));

        return this;
    }

    private Node readSubtree(String s) {

        int leftParen = s.indexOf('(');
        int rightParen = s.lastIndexOf(')');

        if (leftParen != -1 && rightParen != -1) {

            String name = s.substring(rightParen + 1);
            String[] childrenString = split(s.substring(leftParen + 1, rightParen));

            Node node = new Node(name);
            node.children = new ArrayList<>();
            for (String sub : childrenString) {
                Node child = readSubtree(sub);
                node.children.add(child);
                child.parent = node;
            }

            nodeList.add(node);
            return node;
        } else if (leftParen == rightParen) {

            Node node = new Node(s);
            nodeList.add(node);
            return node;

        } else throw new RuntimeException("unbalanced ()'s");
    }

    static class Node {
        final String name;
        final int weight;
        boolean realName = false;
        ArrayList<Node> children;
        Node parent;

        /**
         * @param name name in "actualName:weight" format, weight defaults to zero if colon absent
         */
        Node(String name) {

            int colonIndex = name.indexOf(':');
            String actualNameText;
            if (colonIndex == -1) {
                actualNameText = name;
                weight = 0;
            } else {
                actualNameText = name.substring(0, colonIndex);
                weight = Integer.parseInt(name.substring(colonIndex + 1, name.length()));
            }

            if (actualNameText.equals("")) {
                this.realName = false;
                this.name = Integer.toString(node_uuid);
                node_uuid++;
            } else {
                this.realName = true;
                this.name = actualNameText;
            }
        }

        @Override
        public int hashCode() {
            return name.hashCode();
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Node)) return false;
            Node other = (Node) o;
            return this.name.equals(other.name);
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            if (children != null && children.size() > 0) {
                sb.append("(");
                for (int i = 0; i < children.size() - 1; i++) {
                    sb.append(children.get(i).toString());
                    sb.append(",");
                }
                sb.append(children.get(children.size() - 1).toString());
                sb.append(")");
            }
            if (name != null) sb.append(this.getName());
            return sb.toString();
        }

        String getName() {
            if (realName)
                return name;
            else
                return "";
        }
    }

    @Override
    public String toString() {
        return root.toString() + ";";
    }

}

import java.util.ArrayList；
/**
*创建于2016年12月18日
*
*@author@author
*@version 0.1
*/
公共类NewickTree{
私有静态int节点_uuid=0；
ArrayList nodeList=新的ArrayList（）；
私有节点根；
静态NewickTree readNewickFormat（字符串newick）{
返回新的NewickTree（）.innerReadNewickFormat（newick）；
}
私有静态字符串[]拆分（字符串s）{
ArrayList SplitIndexes=新的ArrayList（）；
int rightParenCount=0；
int leftParenCount=0；
对于（int i=0；i0）{
某人加上（“”）；
对于（int i=0；i

我查看了它，下载了jar，但在其中的任何地方都找不到该类。一定是旧版本。