Java 将类似树的字符串列表转换为xml

我需要转换存储在ArrayList中的这些类型的字符串：

Alpha.Beta.Com.
Alpa.Xeta.Hash.
Alpha.Eta.Dot.
Alpha.Eta.Comma.
Alpha.Eta.Dollar.
Alpha.Xeta.Tilde
Alpha.Beta.Com.Xeta.

这里是Alpha.Beta.Com。将Xeta作为子对象，但Xeta在该对象中不能将哈希和Tilde作为子对象。 仅Alpha.Xeta对象将哈希和波浪线作为子对象

这些字符串类似于树状结构（n个级别），这意味着Alpha将Beta、Xeta和Eta作为子级。 此外，Beta还有Com， Xeta有Hash和Tilde， 埃塔小时候有逗号、美元和圆点

我们需要使用java程序识别每个父级和子级，然后将其构建为XML。

检查以下内容：

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class StringsToXmlConverter {

    private static final String SEPARTOR = "\\.";

    List<String> list;

    Map<String, XmlElement> elements = new HashMap<String,XmlElement>();

    public StringsToXmlConverter(List<String> list) {
        this.list = list;
    }

    public String getXml() {
        for (String xmlPaths: list) {
            String[] splitedElements = xmlPaths.split(SEPARTOR);
            XmlElement parent = null;
            for (String elem : splitedElements) {
                XmlElement currentElem = null;
                if (elements.containsKey(elem)) {
                    currentElem = elements.get(elem);
                    if (parent != null) {
                        addChild(parent, currentElem);
                    } 
                } else {
                    currentElem = createNewElement(parent, elem);
                    elements.put(elem, currentElem);
                }
                parent = currentElem;
            }
        }

        return buildXml().toString();
    }

    private void addChild(XmlElement parent, XmlElement currentElem) {
        currentElem.parent = parent;
        parent.childs.add(currentElem);
    }

    private XmlElement createNewElement(XmlElement parent, String name) {
        XmlElement currentElem;
        currentElem = new XmlElement();
        currentElem.name = name;
        if (parent != null) {
            addChild(parent, currentElem);
        }
        return currentElem;
    }

    private StringBuilder buildXml() {
        StringBuilder xml = new StringBuilder();
        for(XmlElement elem : elements.values()) {
            if (elem.parent == null) {
                xml.append(elem.toXml());
            }
        }
        return xml;
    }

    private class XmlElement {
        String name;
        Set<XmlElement> childs = new HashSet<XmlElement>();
        XmlElement parent = null;
        boolean isPrinted = false;

        private Set<XmlElement> getNoPrintedChilds() {
           Set<XmlElement> notPrintedChilds = new HashSet<XmlElement>();
           Iterator<XmlElement> iterator = childs.iterator();
           while(iterator.hasNext()) {
               XmlElement node = iterator.next();
               if (!node.isPrinted) {
                   notPrintedChilds.add(node);
               }
           }
           return notPrintedChilds;
        }

        public String toXml() {
           StringBuilder xml = new StringBuilder();
           if (!isPrinted) {
               xml.append("<" + name); 
               if (getNoPrintedChilds().isEmpty()) {
                xml.append("/>");
               } else {
                   xml.append(">");
                   for (XmlElement elem : getNoPrintedChilds()) {
                       xml.append(elem.toXml());
                   }
                   xml.append("</" + name + ">");
               }
           }
           isPrinted = true;
           return xml.toString();
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + getOuterType().hashCode();
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            XmlElement other = (XmlElement) obj;
            if (!getOuterType().equals(other.getOuterType()))
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
        private StringsToXmlConverter getOuterType() {
            return StringsToXmlConverter.this;
        }
    }

    public static void main(String[] args) {
        List<String> list= Arrays.asList("Alpha.Beta.Com", 
                                         "Alpha.Xeta.Hash", 
                                         "Alpha.Eta.Dot",
                                         "Alpha.Eta.Comma",
                                         "Alpha.Eta.Dollar",
                                         "Alpha.Xeta.Tilde");
        StringsToXmlConverter converter = new StringsToXmlConverter(list);
        System.out.println(converter.getXml());
    }


}

导入java.util.array；
导入java.util.HashMap；
导入java.util.HashSet；
导入java.util.Iterator；
导入java.util.List；
导入java.util.Map；
导入java.util.Set；
公共类StringsToXmlConverter{
私有静态最终字符串分隔符=“\\”；
名单；
Map elements=newhashmap（）；
公共StringsToXmlConverter（列表）{
this.list=列表；
}
公共字符串getXml（）{
for（字符串xmlPaths:list）{
String[]splitedElements=xmlPaths.split（separator）；
XmlElement父元素=null；
for（字符串元素：拆分元素）{
XmlElement currentElem=null；
if（元素容器（元素））{
currentElem=elements.get（elem）；
如果（父项！=null）{
addChild（父级，currentElem）；
} 
}否则{
currentElem=createNewElement（父元素，elem）；
元素。put（elem，currentElem）；
}
父项=当前元素；
}
}
返回buildXml（）.toString（）；
}
私有void addChild（XmlElement父级，XmlElement currentElem）{
currentElem.parent=父项；
parent.childs.add（currentElem）；
}
私有XmlElement createNewElement（XmlElement父级，字符串名称）{
xml元素currentElem；
currentElem=新的XmlElement（）；
currentElem.name=名称；
如果（父项！=null）{
addChild（父级，currentElem）；
}
返回电流元素；
}
私有StringBuilder buildXml（）{
StringBuilder xml=新的StringBuilder（）；
对于（xmlementelem:elements.values（））{
if（elem.parent==null）{
append（elem.toXml（））；
}
}
返回xml；
}
私有类XmlElement{
字符串名；
Set childs=new HashSet（）；
XmlElement父元素=null；
布尔值isPrinted=false；
私有集getNoPrintedChilds（）{
Set notPrintedChilds=new HashSet（）；
迭代器迭代器=childs.Iterator（）；
while（iterator.hasNext（））{
XmlElement节点=迭代器.next（）；
如果（！node.isPrinted）{
notPrintedChilds.add（节点）；
}
}
返回未打印的儿童；
}
公共字符串toXml（）{
StringBuilder xml=新的StringBuilder（）；
如果（！已打印）{
xml.append（“”）；
}否则{
xml.append（“>”）；
对于（xmlementelem:getNoPrintedChilds（））{
append（elem.toXml（））；
}
xml.append（“”）；
}
}
isPrinted=true；
返回xml.toString（）；
}
@凌驾
公共int hashCode（）{
最终整数素数=31；
int结果=1；
result=prime*result+getOuterType（）.hashCode（）；
result=prime*result+（（name==null）？0:name.hashCode（）；
返回结果；
}
@凌驾
公共布尔等于（对象obj）{
if（this==obj）
返回true；
if（obj==null）
返回false；
如果（getClass（）！=obj.getClass（））
返回false；
XmlElement其他=（XmlElement）obj；
如果（！getOuterType（）.equals（other.getOuterType（）））
返回false；
if（name==null）{
if（other.name！=null）
返回false；
}如果（！name.equals（other.name））
返回false；
返回true；
}
私有StringsToXmlConverter getOuterType（）{
返回StringsToXmlConverter.this；
}
}
公共静态void main（字符串[]args）{
List=Arrays.asList（“Alpha.Beta.Com”，
“Alpha.Xeta.Hash”，
“Alpha.Eta.Dot”，
“Alpha.Eta.逗号”，
“阿尔法·埃塔·美元”，
“Alpha.Xeta.Tilde”）；
StringsToXmlConverter converter=新的StringsToXmlConverter（列表）；
System.out.println（converter.getXml（））；
}
}

可能的答案太多，或者好的答案对于这种格式来说太长。请添加详细信息以缩小答案集或隔离可以在几个段落中回答的问题。嗨，Guido，感谢您的回复，您能否回答或发送此问题的参考链接。是否有任何限制，我收到stackoverflow错误，在第79行和第80行中，它们是：79）for（XmlElement elem:childs）{80）xml.append（elem.toXml（））；您遇到了什么异常？您使用的是相同的测试数据还是其他数据？更正了，实际上在我的分隔字符串中，一些点分隔字符是相同的，这导致了该异常。Alpha.Eta.Dollar.Xeta。正在返回Tilde和Hash作为Alpha.Eta.Dollar.Xeta的子项。请在这方面提供帮助。请查看更新的qq问题。