Java JAXB-un/marshalling：使用数组和列表之间有区别吗？

我是JAXB的新手，非常想了解更多。 我注意到，在编组时，数组和列表中对象的XML表示形式是相同的

我感兴趣的是了解JAXB在取消编组/编组时如何处理这两个数据结构，以及是否最好将其标准化为使用一个数据结构而不是另一个数据结构？ 如果是这样，两者之间的区别是什么（性能方面的，等等）？ 此外，当我为对象选择容器时，我应该考虑什么？

---

如有任何信息，将不胜感激。谢谢大家!

在XML表示中，数组和列表的形式相同。当解组XML时，JAXB将选择Java类中的类型

可以将集合解组到从

列表

编组的数组，反之亦然

数组和

List

s都有各自的优缺点。为你的目的使用更好的东西。一般来说，

List

更容易使用，因为您有像这样的实用方法，但是

List

s不能用于基本类型。阵列可以更快，但灵活性较差

---

真正取决于您使用哪种方法，哪种方法更适合您。

用于编组或解编组的列表或数组之间没有区别。它可以在两种意义上工作，当封送一个数组/列表时，可以解封一个列表/数组

有一个简单的例子：

@XmlRootElement(name = "ROOT")
@XmlAccessorType(XmlAccessType.FIELD)
public class JAXBExample {

    @XmlElement(name = "list")
    private List<Elm> list;
    @XmlElement(name = "array")
    private Elm[] array;

    public JAXBExample() {
        this.list = new ArrayList<>();
        this.array = new Elm[0];
    }

    public void addList(Elm elm) {
        this.list.add(elm);
    }

    public void addArray(Elm elm) {
        Elm[] tmp = new Elm[array.length+1];
        System.arraycopy(array, 0, tmp, 0, array.length);
        tmp[array.length] = elm;
        this.array = tmp;
    }

    private void clear() {
        this.array = null;
        this.list.clear();
    }

    @XmlRootElement(name = "element")
    @XmlAccessorType(XmlAccessType.FIELD)
    static class Elm {

        @XmlElement(name = "name")
        private final String name;

        public Elm() {
            this.name = "noname";
        }

        public Elm(String name) {
            this.name = name;
        }
    }

    public static void main(String... arg) throws JAXBException {
        JAXBContext context = JAXBContext.newInstance(JAXBExample.class,
            Elm.class);
        Marshaller marshaller = context.createMarshaller();
        Unmarshaller unmarshaller = context.createUnmarshaller();

        JAXBExample jaxb = new JAXBExample();
        jaxb.addArray(new Elm("Elm1"));
        jaxb.addArray(new Elm("Elm3"));
        jaxb.addArray(new Elm("Elm5"));
        jaxb.addArray(new Elm("Elm7"));
        jaxb.addArray(new Elm("Elm9"));
        jaxb.addList(new Elm("Elm2"));
        jaxb.addList(new Elm("Elm4"));
        jaxb.addList(new Elm("Elm6"));
        jaxb.addList(new Elm("Elm8"));
        jaxb.addList(new Elm("Elm10"));

        File f = new File("example.xml");
        marshaller.marshal(jaxb, f);

        jaxb.clear();
        jaxb = null;

        jaxb = (JAXBExample) unmarshaller.unmarshal(f);
        for (Elm elm : jaxb.array) {
            System.out.println("ArrayElm: " + elm.name);
        }
        for (Elm elm : jaxb.list) {
            System.out.println("ListElm: " + elm.name);
        }

    }
}

@XmlRootElement（name=“ROOT”）
@XmlAccessorType（XmlAccessType.FIELD）
公共类JAXBE示例{
@xmlement（name=“list”）
私人名单；
@xmlement（name=“array”）
私有Elm[]数组；
公共JAXBExample（）{
this.list=new ArrayList（）；
this.array=new Elm[0]；
}
公共无效地址列表（Elm Elm）{
此.list.add（elm）；
}
公共void addArray（Elm-Elm）{
Elm[]tmp=newelm[array.length+1]；
数组复制（array，0，tmp，0，array.length）；
tmp[array.length]=elm；
this.array=tmp；
}
私人空位清除（）{
this.array=null；
this.list.clear（）；
}
@XmlRootElement（name=“element”）
@XmlAccessorType（XmlAccessType.FIELD）
静态类Elm{
@xmlement（name=“name”）
私有最终字符串名；
公共榆树（）{
this.name=“noname”；
}
公共Elm（字符串名称）{
this.name=名称；
}
}
公共静态void main（字符串…arg）抛出JAXBEException{
JAXBContext context=JAXBContext.newInstance（JAXBExample.class，
榆树类）；
Marshaller=context.createMarshaller（）；
Unmarshaller Unmarshaller=context.createUnmarshaller（）；
JAXBExample jaxb=新的JAXBExample（）；
addArray（新Elm（“Elm1”）；
addArray（新Elm（“Elm3”）；
addArray（新Elm（“Elm5”）；
addArray（新Elm（“Elm7”）；
addArray（新Elm（“Elm9”）；
jaxb.addList（新Elm（“Elm2”）；
jaxb.addList（新Elm（“Elm4”）；
jaxb.addList（新Elm（“Elm6”）；
jaxb.addList（新Elm（“Elm8”）；
jaxb.addList（新Elm（“Elm10”）；
文件f=新文件（“example.xml”）；
marshaller.marshall（jaxb，f）；
jaxb.clear（）；
jaxb=null；
jaxb=（JAXBExample）unmarshaller.unmarshal（f）；
for（Elm-Elm:jaxb.array）{
System.out.println（“ArrayElm:+elm.name”）；
}
for（Elm-Elm:jaxb.list）{
System.out.println（“ListElm:+elm.name”）；
}
}
}

这将产生：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ROOT>
    <list>
        <name>Elm2</name>
    </list>
    <list>
        <name>Elm4</name>
    </list>
    <list>
        <name>Elm6</name>
    </list>
    <list>
        <name>Elm8</name>
    </list>
    <list>
        <name>Elm10</name>
    </list>
    <array>
        <name>Elm1</name>
    </array>
    <array>
        <name>Elm3</name>
    </array>
    <array>
        <name>Elm5</name>
    </array>
    <array>
        <name>Elm7</name>
    </array>
    <array>
        <name>Elm9</name>
    </array>
</ROOT>

Elm2
榆树4
埃尔姆6
Elm8
埃尔姆10
Elm1
Elm3
Elm5
榆树7
榆树9

---

如您所见，数组和列表的存储格式相同。

需要考虑以下几点：

JAXB实现可能会使用SAX或StAX解析器来处理XML。因为它不容易知道XML中最终会出现多少项，所以它很可能首先将它们放在

列表中，然后将其转换为数组

JAXB impls支持多维数组，但不支持多维列表