Java 我能'；无法使用StAX将单词正确写入xml

我有个问题，我想得到这样的东西：

<text>
<sentence>
    <word>a</word>
    <word>had</word>
    <word>lamb</word>
    <word>little</word>
    <word>Mary</word>
</sentence>
<sentence>
    <word>Aesop</word>
    <word>and</word>
    <word>called</word>
    <word>came</word>
    <word>for</word>
    <word>Peter</word>
    <word>the</word>
    <word>wolf</word>
</sentence>
<sentence>
    <word>Cinderella</word>
    <word>likes</word>
    <word>shoes</word>
</sentence>

A.
有
羔羊
小的
玛丽
伊索
和
打电话
来了
对于
彼得
这个
狼
灰姑娘
喜欢
鞋

但我只得到这个：

  <text>
<sentence>
    <word>a</word>
    <word>had</word>
    <word>lamb</word>
    <word>little</word>
    <word>Mary</word>
</sentence></text>

A.
有
羔羊
小的
玛丽

示例文本

“玛丽有一只小羊羔

彼得叫狼来，伊索来了。 灰姑娘喜欢鞋子……”

我的班级呢

public class StaxWriteXmlTest {

/**
 * @param args
 * @throws FileNotFoundException
 * @throws XMLStreamException
 */
public static void main(String[] args) throws FileNotFoundException,
        XMLStreamException {
    String[] word = initItems();

    String itemXmlFile = "D:\\items.xml";
    // xml event writer with output stream
    XMLOutputFactory xmlOutFactory = XMLOutputFactory.newInstance();
    OutputStream outputStream = new FileOutputStream(itemXmlFile);
    XMLEventWriter eventWriter = xmlOutFactory
            .createXMLEventWriter(outputStream);
    ByteArrayOutputStream outStream = new ByteArrayOutputStream();
    XMLEventWriter xmlWrite = (XMLOutputFactory.newInstance())
            .createXMLEventWriter(outStream);

    XMLEventFactory eventFactory = XMLEventFactory.newInstance();
    XMLEvent end = createNewLine(eventFactory);
    XMLEvent tab = createTab(eventFactory);

    // Create start tag
    StartDocument startDocument = eventFactory.createStartDocument();
    EndDocument endDocument = eventFactory.createEndDocument();
    eventWriter.add(startDocument);

    // create config open tag
    eventWriter.add(end);
    StartElement configStartElement = eventFactory.createStartElement("",
            "", "text");
    eventWriter.add(configStartElement);
    eventWriter.add(end);





    eventWriter.add(tab);
    StartElement itemStartElement = eventFactory.createStartElement("", "",
            "sentence");
    eventWriter.add(itemStartElement);
    eventWriter.add(end);
    eventWriter.add(tab);

    // add words
    for (String words : word) {
        eventWriter.add(tab);
        createItemNode(eventFactory, eventWriter, "word", words);
        eventWriter.add(tab);
    }
    // eventWriter.add(tab);
    EndElement itemEndElement = eventFactory.createEndElement("", "",
            "sentence");
    eventWriter.add(itemEndElement);
    eventWriter.add(end);

    EndElement configEndElement = eventFactory.createEndElement("", "",
            "text");
    eventWriter.add(configEndElement);
    eventWriter.add(end);

    eventWriter.add(endDocument);
    eventWriter.close();

}

public static void createItemNode(XMLEventFactory eventFactory,
        XMLEventWriter eventWriter, String elementName, String value)
        throws XMLStreamException {
    XMLEvent end = eventFactory.createDTD("\n");
    StartElement startElement = eventFactory.createStartElement("", "",
            elementName);
    eventWriter.add(startElement);
    Characters characters = eventFactory.createCharacters(value);
    eventWriter.add(characters);
    EndElement endElement = eventFactory.createEndElement("", "",
            elementName);
    eventWriter.add(endElement);
    eventWriter.add(end);
}

public static XMLEvent createTab(XMLEventFactory eventFactory) {
    return eventFactory.createDTD("\t");
}

public static XMLEvent createNewLine(XMLEventFactory eventFactory) {
    return eventFactory.createDTD("\n");
}



public static String[] initItems() {

    FileReader fr = null;

    try {
        fr = new FileReader("text.txt");
    } catch (FileNotFoundException e1) {

        e1.printStackTrace();
    }
    BufferedReader inputText = new BufferedReader(fr);
    String text = "", newText = "";
    String allTogether = "";
    try {
        while ((text = inputText.readLine()) != null) {
            newText += text.replaceAll("\\s+", " ").replaceAll(" ,", ",")
                    .replaceAll(" \\.", ".").replaceAll("\\..", ".");

            allTogether = newText.replaceAll("\\s+", " ");

            String[] splitText = allTogether.split(".");

        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    String[] splitText = allTogether.split("[.]");
    for (int i = 0; i < splitText.length; i++) {
        // System.out.println(splitText[i]);
        String[] nexSplit = splitText[i].split("[ \t]");

        for (int x = 0; x < nexSplit.length; x++) {
            Arrays.sort(nexSplit, String.CASE_INSENSITIVE_ORDER);
            // System.out.println(nexSplit[x]);

            return nexSplit;

        }

    }
    return splitText;

}}

公共类StaxWriteXmlTest{
/**
*@param args
*@抛出FileNotFoundException
*@XMLStreamException
*/
公共静态void main（字符串[]args）引发FileNotFoundException，
XMLStreamException{
字符串[]word=initItems（）；
String itemXmlFile=“D:\\items.xml”；
//具有输出流的xml事件编写器
XMLOutputFactory xmlOutFactory=XMLOutputFactory.newInstance（）；
OutputStream OutputStream=新文件OutputStream（itemXmlFile）；
XMLEventWriter eventWriter=xmlOutFactory
.createXMLEventWriter（outputStream）；
ByteArrayOutputStream outStream=新建ByteArrayOutputStream（）；
XMLEventWriter xmlWrite=（XMLOutputFactory.newInstance（））
.createXMLEventWriter（扩展）；
XMLEventFactory eventFactory=XMLEventFactory.newInstance（）；
XMLEvent end=createNewLine（eventFactory）；
XMLEvent tab=createTab（eventFactory）；
//创建开始标记
StartDocument StartDocument=eventFactory.createStartDocument（）；
EndDocument EndDocument=eventFactory.createEndDocument（）；
eventWriter.add（startDocument）；
//创建配置打开标记
eventWriter.add（结束）；
StartElement configStartElement=eventFactory.createStartElement（“”，
“文本”；
添加（配置StartElement）；
eventWriter.add（结束）；
添加（选项卡）；
StartElement项StartElement=eventFactory.createStartElement（“，”，
“判决”）；
eventWriter.add（itemStartElement）；
eventWriter.add（结束）；
添加（选项卡）；
//加词
for（字符串：word）{
添加（选项卡）；
createItemNode（eventFactory、eventWriter、“word”、word）；
添加（选项卡）；
}
//添加（选项卡）；
EndElement itemEndElement=eventFactory.createEndElement（“，”，
“判决”）；
添加（itemEndElement）；
eventWriter.add（结束）；
EndElement configEndElement=eventFactory.createEndElement（“，”，
“文本”）；
添加（configEndElement）；
eventWriter.add（结束）；
eventWriter.add（endDocument）；
eventWriter.close（）；
}
公共静态void createItemNode（XMLEventFactory eventFactory，
XMLEventWriter事件编写器，字符串元素名称，字符串值）
抛出XMLStreamException{
XMLEvent end=eventFactory.createDTD（“\n”）；
StartElement StartElement=eventFactory.createStartElement（“，”，
元素名称）；
eventWriter.add（startElement）；
Characters Characters=eventFactory.createCharacters（值）；
添加（字符）；
EndElement EndElement=eventFactory.createEndElement（“，”，
元素名称）；
eventWriter.add（endElement）；
eventWriter.add（结束）；
}
公共静态XMLEvent createTab（XMLEventFactory eventFactory）{
返回eventFactory.createDTD（“\t”）；
}
公共静态XMLEvent createNewLine（XMLEventFactory eventFactory）{
返回eventFactory.createDTD（“\n”）；
}
公共静态字符串[]initItems（）{
FileReader fr=null；
试一试{
fr=新文件读取器（“text.txt”）；
}捕获（FileNotFoundException e1）{
e1.printStackTrace（）；
}
BufferedReader inputText=新的BufferedReader（fr）；
字符串text=“”，newText=“”；
串在一起=”；
试一试{
而（（text=inputText.readLine（））！=null）{
newText+=text.replaceAll（“\\s+”，”）.replaceAll（“，”，”，”）
.replaceAll（“\\”，“）.replaceAll（“\\…”，”）；
allTogether=newText.replaceAll（“\\s+”，“”）；
String[]splitText=allTogether.split（“.”）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
String[]splitText=allTogether.split（“[.]”）；
for（int i=0；i

我还没有分析您的所有代码，但这一部分看起来可疑：

String[] splitText = allTogether.split("[.]");
for (int i = 0; i < splitText.length; i++) {
    // System.out.println(splitText[i]);
    String[] nexSplit = splitText[i].split("[ \t]");

    for (int x = 0; x < nexSplit.length; x++) {
        Arrays.sort(nexSplit, String.CASE_INSENSITIVE_ORDER);
        // System.out.println(nexSplit[x]);

        return nexSplit;

    }

}
return splitText;

String[]splitText=allTogether.split（[.]）；
for（int i=0；i

您真的想在一次迭代后返回到该内部循环中吗？我对此表示怀疑

---

另外，请确保在

initItems（）

方法中关闭阅读器。

请选择一个描述性标题。你的问题可能是这里任何问题的标题。好吧，我同意，但我怎么能改变这个