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

Question

我一直在编写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

到目前为止，这是我得到的(分隔第一个和第二个标记):

import java.util.StringTokenizer;
import java.io.*;
public class TestDependency {
    public static void main(String[] args) {
        try{
        FileInputStream fstream = new FileInputStream("input-file");
        BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
            String strLine;
        while ((strLine = br.readLine()) != null)   {
            StringTokenizer items = new StringTokenizer(strLine, ":");
            System.out.println("I: " + items.nextToken().trim());
            StringTokenizer depn = new StringTokenizer(items.nextToken().trim(), " ");
                while(depn.hasMoreTokens()) {
                    System.out.println( "D: " + depn.nextToken().trim() );
            }
        }
        } catch (Exception e){//Catch exception if any
        System.err.println("Error: " + e.getMessage());
        }
    }
}

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

Answer 1

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

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

然后，你可以像这样从你的程序中调用它:

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

同样，输出没有排序，但这应该是微不足道的。

Answer 2

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