Java-将StringTokenizer保存到数组中，以便在其他方法中进行进一步处理

我已经编写了很多Perl和Python代码，这次我被指派用Java编写代码。所以我不太熟悉用Java处理数据

我的任务包括创建一个输入文件，在该文件中我需要检查依赖项，然后输出具有可传递依赖项的依赖项。更清晰的想法如下：

输入文件：

A: B C
B: C E
C: G
D: A

输出文件：

A: B C E G
B: C E G
C: G
D: A B C E G

到目前为止，我得到的是（分离第一个和第二个令牌）：

---

谢谢你的帮助。我可以想象Perl或Python可以轻松地处理这个问题。只需要在Java中实现它。

这在内存方面不是很有效，需要良好的输入，但应该运行良好

String s = "A: B C D";
String i = s.split(":")[0];
String dep[] = s.split(":")[1].trim().split(" ");
System.out.println("i = "+i+", dep = "+Arrays.toString(dep));

public class NodeParser {

    // Map holding references to nodes
    private Map<String, List<String>> nodeReferenceMap;

    /**
     * Parse file and create key/node array pairs
     * @param inputFile
     * @return
     * @throws IOException
     */
    public Map<String, List<String>> parseNodes(String inputFile) throws IOException {

        // Reset list if reusing same object
        nodeReferenceMap = new HashMap<String, List<String>>();

        // Read file
        FileInputStream fstream = new FileInputStream(inputFile);
        BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
        String strLine;

        // Parse nodes into reference mapping
        while((strLine = br.readLine()) != null) {
            // Split key from nodes
            String[] tokens = strLine.split(":");
            String key = tokens[0].trim();
            String[] nodes = tokens[1].trim().split(" ");
            // Set nodes as an array list for key
            nodeReferenceMap.put(key, Arrays.asList(nodes));
        }

        // Recursively build node mapping
        Map<String, Set<String>> parsedNodeMap = new HashMap<String, Set<String>>();
        for(Map.Entry<String, List<String>> entry : nodeReferenceMap.entrySet()) {
            String key = entry.getKey();
            List<String> nodes = entry.getValue();
            // Create initial node set
            Set<String> outSet = new HashSet<String>();
            parsedNodeMap.put(key, outSet);
            // Start recursive call
            addNode(outSet, nodes);
        }

        // Sort keys
        List<String> sortedKeys = new ArrayList<String>(parsedNodeMap.keySet());
        Collections.sort(sortedKeys);

        // Sort nodes
        Map<String, List<String>> sortedParsedNodeMap = new LinkedHashMap<String, List<String>>();
        for(String key : sortedKeys) {
            List<String> sortedNodes = new ArrayList<String>(parsedNodeMap.get(key));
            Collections.sort(sortedNodes);
            sortedParsedNodeMap.put(key, sortedNodes);
        }

        // Return sorted key/node mapping
        return sortedParsedNodeMap;
    }

    /**
     * Recursively add nodes by referencing the previously generated list mapping
     * @param outSet
     * @param nodes
     */
    private void addNode(Set<String> outSet, List<String> nodes) {
        // Add each node to the set mapping
        for(String node : nodes) {
            outSet.add(node);
            // Get referenced nodes
            List<String> nodeList = nodeReferenceMap.get(node);
            if(nodeList != null) {
                // Create array list from abstract list for remove support
                List<String> referencedNodes = new ArrayList<String>(nodeList);
                // Remove already searched nodes to prevent infinite recursion
                referencedNodes.removeAll(outSet);
                // Recursively search more node paths
                if(!referencedNodes.isEmpty()) {
                    addNode(outSet, referencedNodes);
                }
            }
        }
    }
}

公共类节点分配器{
//包含对节点的引用的映射
私有映射节点引用映射；
/**
*解析文件并创建密钥/节点数组对
*@param输入文件
*@返回
*@抛出异常
*/
公共映射parseNodes（字符串输入文件）引发IOException{
//如果重复使用同一对象，则重置列表
noderereferencemap=newhashmap（）；
//读取文件
FileInputStream fstream=新的FileInputStream（inputFile）；
BufferedReader br=新的BufferedReader（新的InputStreamReader（fstream））；
弦斯特林；
//将节点解析为引用映射
而（（strLine=br.readLine（））！=null）{
//从节点分割关键点
String[]tokens=strLine.split（“：”）；
String key=tokens[0]。trim（）；
String[]nodes=tokens[1].trim（）.split（“”）；
//将节点设置为键的数组列表
nodeReferenceMap.put（key，Arrays.asList（nodes））；
}
//递归构建节点映射
Map parsedNodeMap=newhashmap（）；
对于（Map.Entry:nodeReferenceMap.entrySet（））{
String key=entry.getKey（）；
列表节点=entry.getValue（）；
//创建初始节点集
Set start=newhashset（）；
parsedNodeMap.put（键，开始）；
//启动递归调用
addNode（开始，节点）；
}
//排序键
List sortedKeys=newarraylist（parsedNodeMap.keySet（））；
收集。分类（分类键）；
//排序节点
Map sortedParsedNodeMap=新建LinkedHashMap（）；
用于（字符串键：sortedKeys）{
List sortedNodes=newarraylist（parsedNodeMap.get（key））；
集合。排序（分类节点）；
sortedParsedNodeMap.put（键，sortedNodes）；
}
//返回已排序的键/节点映射
返回分类ParsedNodeMap；
}
/**
*通过引用先前生成的列表映射递归地添加节点
*@param
*@param节点
*/
私有void addNode（设置起始点，列出节点）{
//将每个节点添加到集合映射
用于（字符串节点：节点）{
添加（节点）；
//获取引用节点
List nodeList=nodeReferenceMap.get（节点）；
if（节点列表！=null）{
//从抽象列表创建数组列表以删除支持
List referencedNodes=new ArrayList（节点列表）；
//删除已搜索的节点以防止无限递归
referencedNodes.removeAll（开始）；
//递归搜索更多节点路径
如果（！referencedNodes.isEmpty（））{
addNode（开始，referencedNodes）；
}
}
}
}
}

然后，您可以从您的程序中调用它，如下所示：

    public static void main(String[] args) {
        try {
            NodeParser nodeParser = new NodeParser();
            Map<String, List<String>> nodeSet = nodeParser.parseNodes("./res/input.txt");
            for(Map.Entry<String, List<String>> entry : nodeSet.entrySet()) {
                String key = entry.getKey();
                List<String> nodes = entry.getValue();
                System.out.println(key + ": " + nodes);
            }
        } catch (IOException e){
            System.err.println("Error: " + e.getMessage());
        }
    }

publicstaticvoidmain（字符串[]args）{
试一试{
NodeParser NodeParser=新的NodeParser（）；
Map nodeSet=nodeParser.parseNodes（“./res/input.txt”）；
对于（Map.Entry:nodeSet.entrySet（））{
String key=entry.getKey（）；
列表节点=entry.getValue（）；
System.out.println（键+“：”+节点）；
}
}捕获（IOE异常）{
System.err.println（“错误：+e.getMessage（））；
}
}

---

此外，输出没有排序，但这应该很简单。

你能用python描述一下你的算法吗？这是家庭作业吗？在我看来，它就像DB理论：>。你不能使用

String.split（）

方法吗？为什么不试试Groovy呢？是的，这是家庭作业。索塔。与霍比有关。是的，我似乎再也不知道它的算法了。我需要一些时间来消化这些东西。哈哈。。不，只是想学编程。看起来很复杂，给你。我添加了排序并修复了一个无限递归错误。祝你好运

    public static void main(String[] args) {
        try {
            NodeParser nodeParser = new NodeParser();
            Map<String, List<String>> nodeSet = nodeParser.parseNodes("./res/input.txt");
            for(Map.Entry<String, List<String>> entry : nodeSet.entrySet()) {
                String key = entry.getKey();
                List<String> nodes = entry.getValue();
                System.out.println(key + ": " + nodes);
            }
        } catch (IOException e){
            System.err.println("Error: " + e.getMessage());
        }
    }