Java 8 XML文件检索工具开发咨询：数据结构与遍历方案

Hey there! Let's tackle your Java 8 tool-building problem, focusing on the flexibility you've prioritized over performance. Here's a breakdown of your two core questions, with practical code examples to back things up:

The key here is to model your XML data in a way that makes arbitrary querying easy—whether it's single-condition lookups, multi-condition combinations, or targeted ID+FACT queries.

Custom POJO to Represent XML Records #

First, create a simple class to encapsulate each XML file's data. This gives you a clean, type-safe way to handle the <id> and <FactValue> pairs:

public class XmlRecord {
    private final String id;
    private final Map<String, String> factValues;

    public XmlRecord(String id) {
        this.id = id;
        this.factValues = new HashMap<>();
    }

    // Add a FactValue pair (using the FACT code suffix as the key)
    public void addFact(String factSuffix, String value) {
        factValues.put(factSuffix, value);
    }

    // Getters for flexibility
    public String getId() { return id; }
    public Map<String, String> getFactValues() { return factValues; }
    // Optional: Add a helper to get a specific FactValue directly
    public String getFactValue(String suffix) { return factValues.get(suffix); }
}

Using a Map<String, String> for fact values lets you easily access any FACT by its suffix (or even the full name if you skip the suffix extraction—just adjust the key logic later).

Storage for All Records #

For maximum flexibility, store all parsed XmlRecord objects in a List<XmlRecord>. Java 8's Stream API works seamlessly with lists, letting you build any query logic you need with filter(), map(), and other stream operations.

If you frequently query by ID (a common use case), you can optionally maintain a secondary Map<String, XmlRecord> (keyed by the <id> value) for O(1) lookups. This doesn't sacrifice flexibility—it just adds a performance boost for specific queries.

Java 8 provides clean, concise ways to iterate over files in a directory. We'll use Files.walk() (since it's easy to extend to subdirectories later if needed) and filter for .xml files.

Full File Traversal + Parsing Example #

Here's how to scan the folder, parse each XML file, and populate your XmlRecord list:

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class XmlQueryTool {
    public static void main(String[] args) {
        Path folderPath = Paths.get("/path/to/your/xml/directory");
        List<XmlRecord> allRecords = new ArrayList<>();

        // Walk the directory (depth=1 means only the current folder, no subdirectories)
        try (Stream<Path> fileStream = Files.walk(folderPath, 1)) {
            fileStream
                .filter(path -> !Files.isDirectory(path)) // Skip folders
                .filter(path -> path.getFileName().toString().toLowerCase().endsWith(".xml")) // Filter XML files
                .forEach(path -> parseXmlFile(path, allRecords)); // Parse each file
        } catch (IOException e) {
            System.err.println("Error traversing directory: " + e.getMessage());
            e.printStackTrace();
        }

        // Now allRecords contains all parsed data—ready for queries!
        runExampleQueries(allRecords);
    }

    private static void parseXmlFile(Path filePath, List<XmlRecord> records) {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse(filePath.toFile());
            doc.getDocumentElement().normalize();

            // Extract the <id> value
            String recordId = doc.getElementsByTagName("id").item(0).getTextContent().trim();
            XmlRecord record = new XmlRecord(recordId);

            // Extract all <FactValue> nodes
            NodeList factNodes = doc.getElementsByTagName("FactValue");
            for (int i = 0; i < factNodes.getLength(); i++) {
                Node node = factNodes.item(i);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    Element factElement = (Element) node;
                    String factName = factElement.getElementsByTagName("name").item(0).getTextContent().trim();
                    String factValue = factElement.getElementsByTagName("valueString").item(0).getTextContent().trim();

                    // Extract the FACT code suffix (adjust this if your naming pattern differs)
                    String factSuffix = factName.replaceFirst("^FACT_", "");
                    record.addFact(factSuffix, factValue);
                }
            }

            records.add(record);
        } catch (Exception e) {
            System.err.println("Failed to parse file: " + filePath.getFileName());
            e.printStackTrace();
        }
    }

    private static void runExampleQueries(List<XmlRecord> records) {
        // Example 1: Get a specific FACT value for a given ID
        String targetId = "USER_001";
        String targetFactSuffix = "EMAIL";
        records.stream()
            .filter(r -> r.getId().equals(targetId))
            .findFirst()
            .ifPresent(r -> System.out.printf(
                "ID: %s, FACT后缀: %s, 值: %s%n",
                r.getId(), targetFactSuffix, r.getFactValue(targetFactSuffix)
            ));

        // Example 2: Multi-condition query (e.g., age > 30 AND city = "Shanghai")
        System.out.println("\nMulti-condition query results:");
        records.stream()
            .filter(r -> {
                String ageStr = r.getFactValue("AGE");
                String city = r.getFactValue("CITY");
                // Handle null values to avoid NPE
                return ageStr != null && Integer.parseInt(ageStr) > 30 
                       && "Shanghai".equals(city);
            })
            .forEach(r -> r.getFactValues().forEach((suffix, value) -> 
                System.out.printf("ID: %s, FACT后缀: %s, 值: %s%n", r.getId(), suffix, value)
            ));
    }
}

Key Notes on Flexibility #

• If your <FactValue> name doesn't follow a FACT_XXX pattern, just remove the replaceFirst() call and use the full name as the map key.
• The Stream API lets you build any query logic you can think of—fuzzy matches, range filters, combinations of multiple facts, etc.—without changing the underlying data structure.
• For larger datasets, you could switch to a Stream<XmlRecord> (lazy loading) instead of a List, but a list is better if you need to run multiple queries without re-parsing files.

内容的提问来源于stack exchange，提问作者Jesus Paradinas