针对使用Java将XML文件转换为CSV文件和java将xml转换为对象这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展Javaxml文件转换为map集合、JAVA将xml文件转换成Stri
针对使用Java将XML文件转换为CSV文件和java将xml转换为对象这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展Java xml文件转换为map集合、JAVA 将xml文件转换成String、Java如何解析某个目录下xml文件，将XML文件转换为报表数据源？、java实现excel文件转换为xml文件等相关知识，希望可以帮助到你。
本文目录一览：- 使用Java将XML文件转换为CSV文件（java将xml转换为对象）
- Java xml文件转换为map集合
- JAVA 将xml文件转换成String
- Java如何解析某个目录下xml文件，将XML文件转换为报表数据源？
- java实现excel文件转换为xml文件
使用Java将XML文件转换为CSV文件（java将xml转换为对象）
我需要帮助来理解使用java将XML文件转换为CSV文件所涉及的步骤。这是XML文件的示例
<?xml version="1.0"?>
<Sites>
<Site id="101" name="NY-01" location="New York">
<Hosts>
<Host id="1001">
<Host_Name>srv001001</Host_Name>
<IP_address>10.1.2.3</IP_address>
<OS>Windows</OS>
<Load_avg_1min>1.3</Load_avg_1min>
<Load_avg_5min>2.5</Load_avg_5min>
<Load_avg_15min>1.2</Load_avg_15min>
</Host>
<Host id="1002">
<Host_Name>srv001002</Host_Name>
<IP_address>10.1.2.4</IP_address>
<OS>Linux</OS>
<Load_avg_1min>1.4</Load_avg_1min>
<Load_avg_5min>2.5</Load_avg_5min>
<Load_avg_15min>1.2</Load_avg_15min>
</Host>
<Host id="1003">
<Host_Name>srv001003</Host_Name>
<IP_address>10.1.2.5</IP_address>
<OS>Linux</OS>
<Load_avg_1min>3.3</Load_avg_1min>
<Load_avg_5min>1.6</Load_avg_5min>
<Load_avg_15min>1.8</Load_avg_15min>
</Host>
<Host id="1004">
<Host_Name>srv001004</Host_Name>
<IP_address>10.1.2.6</IP_address>
<OS>Linux</OS>
<Load_avg_1min>2.3</Load_avg_1min>
<Load_avg_5min>4.5</Load_avg_5min>
<Load_avg_15min>4.2</Load_avg_15min>
</Host>
</Hosts>
</Site>
</Sites>
这是生成的CSV文件。
site_id,site_name,site_location,host_id,host_name,ip_address,operative_system,load_avg_1min,load_avg_5min,load_avg_15min
101,NY-01,New York,1001,srv001001,10.1.2.3,Windows,1.3,2.5,1.2
101,1002,srv001002,10.1.2.4,Linux,1.4,1003,srv001003,10.1.2.5,3.3,1.6,1.8
101,1004,srv001004,10.1.2.6,2.3,4.5,4.2
我当时正在考虑使用DOM解析器读取xml文件。我遇到的问题是，我需要按名称指定要编码的特定元素，但我希望它能够解析它而不这样做。
Java中是否有任何工具或库可以帮助我实现这一目标。
如果我下面有这种格式的XML文件，并且想在与MSgId相同的行中添加InitgPty的值（请注意：InitgPty在下一个标记级别，因此它将在下一行中打印该值）
<?xml version="1.0"?>
<CstmrCdtTrfInitn>
<GrpHdr>
<MsgId>XYZ07/ABC</MsgId>
<NbOfTxs>100000</NbOfTxs>
<InitgPty>
<Nm>XYZ</Nm>
</InitgPty>
Java xml文件转换为map集合
public class XmlToMap {
public static Map<String, Object> Dom2Map(Document doc){
Map<String, Object> map = new HashMap<String, Object>();
if(doc == null)
return map;
Element root = doc.getRootElement();
for (Iterator iterator = root.elementIterator(); iterator.hasNext();) {
Element e = (Element) iterator.next();
//System.out.println(e.getName());
List list = e.elements();
if(list.size() > 0){
map.put(e.getName(), Dom2Map(e));
}else
map.put(e.getName(), e.getText());
}
return map;
}
public static Map Dom2Map(Element e){
Map map = new HashMap();
List list = e.elements();
if(list.size() > 0){
for (int i = 0;i < list.size(); i++) {
Element iter = (Element) list.get(i);
List mapList = new ArrayList();
if(iter.elements().size() > 0){
Map m = Dom2Map(iter);
if(map.get(iter.getName()) != null){
Object obj = map.get(iter.getName());
if(!obj.getClass().getName().equals("java.util.ArrayList")){
mapList = new ArrayList();
mapList.add(obj);
mapList.add(m);
}
if(obj.getClass().getName().equals("java.util.ArrayList")){
mapList = (List) obj;
mapList.add(m);
}
map.put(iter.getName(), mapList);
}else
map.put(iter.getName(), m);
}
else{
if(map.get(iter.getName()) != null){
Object obj = map.get(iter.getName());
if(!obj.getClass().getName().equals("java.util.ArrayList")){
mapList = new ArrayList();
mapList.add(obj);
mapList.add(iter.getText());
}
if(obj.getClass().getName().equals("java.util.ArrayList")){
mapList = (List) obj;
mapList.add(iter.getText());
}
map.put(iter.getName(), mapList);
}else
map.put(iter.getName(), iter.getText());
}
}
}else
map.put(e.getName(), e.getText());
return map;
}
}
JAVA 将xml文件转换成String
调用webservice方法的时候，参数有时经常是xml文件的字符串形式，简单的拼个字符串还好说，比如：
StringBuilder str = new StringBuilder("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
str.append("<REQUEST>");
str.append("<NAME>").append("echo").append("</NAME>");
str.append("<AGE>").append("6").append("</AGE>");
str.append("</REQUEST>");
System.out.println(str.toString());但是，对于比较复杂的xml手动拼字符串就太过麻烦了……，所以想办法将xml转化成了字符串，在此记录一下：
import java.io.File;
import java.io.StringWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
private String turnDocumentToString() {
try {
// 读取 xml 文件
File fileinput = new File("E:/test.xml");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(fileinput);
// 方法1：将xml文件转化为String
// StringWriter sw = new StringWriter();
// TransformerFactory tf = TransformerFactory.newInstance();
// Transformer transformer = tf.newTransformer();
// transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,
// "no");
// transformer.setOutputProperty(OutputKeys.METHOD, "xml");
// transformer.setOutputProperty(OutputKeys.INDENT, "yes");
// transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
// transformer.transform(new DOMSource(doc), new StreamResult(sw));
//方法2：和方法1类似
DOMSource domSource = new DOMSource(doc);
StringWriter writer = new StringWriter();
StreamResult result = new StreamResult(writer);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
transformer.transform(domSource, result);
// 将转换过的xml的String 样式打印到控制台
System.out.println(writer.toString());
return writer.toString();
} catch (Exception e) {
e.printStackTrace();
return null;
}
Java如何解析某个目录下xml文件，将XML文件转换为报表数据源？
在Java开发的报表工具FineReport中，假如在目录下保存了几个XML文件，希望把XML文件转换为报表数据源，同时希望展示动态xml数据源的效果，这时可通过参数的方式，动态获取xml字段中的值再作为报表数据源。 Northwind.xml记录数据格式如下：
<?xml version="1.0" encoding="UTF-8"?>
<Northwind>
<Customers>
<CustomerID>ALFKI</CustomerID>
<CompanyName>ALfreds Futterkiste</CompanyName>
<ContactName>Maria Anders</ContactName>
<ContactTitle>Sales Representative</ContactTitle>
<Address>Obere Str.57</Address>
<City>Berlin</City>
<PostalCode>12209</PostalCode>
<Country>Germany</Country>
<Phone>030-0074321</Phone>
<Fax>030-0076545</Fax>
</Customers>
</Northwind>
最终用于制作报表的数据源形式如下： 
对于这样的情况我们如何来实现呢？FineReport中可以通过自定义程序数据集来对xml字段数据进行解析，最终返回所希望的数据表。实现步骤如下： 1、 定义XMLColumnNameType4Demo封装类 首先定义参数name及type，供其他类直接调用，安全性比较高，详细代码如下：
package com.fr.data;
public class XMLColumnNameType4Demo {
private int type = -1;
private String name = null;
public XMLColumnNameType4Demo(String name, int type) {
this.name = name;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
}
2、定义XMLParseDemoDataModel.java类文件 定义XMLParseDemoDataModel.java类继承AbstractDataModel接口，实现getColumnCount、getColumnName、getRowCount、getValueAt四个方法，详细代码如下：
package com.fr.data;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import com.fr.base.FRContext;
import com.fr.data.AbstractDataModel;
import com.fr.general.ComparatorUtils;
import com.fr.general.data.TableDataException;
/**
* XMLParseDemoDataModel
*
* DataModel是获取数据的接口
*
* 这里通过init方法一次性取数后，构造一个二维表对象来实现DataModel的各个取数方法
*/
public class XMLParseDemoDataModel extends AbstractDataModel {
// 数据类型标识
public static final int COLUMN_TYPE_STRING = 0;
public static final int COLUMN_TYPE_INTEGER = 1;
public static final int COLUMN_TYPE_BOOLEAN = 2;
// 缓存取出来的数据
protected List row_list = null;
// 数据对应的节点路径
private String[] xPath;
// 节点路径下包含的需要取数的节点
private XMLColumnNameType4Demo[] columns;
private String filePath;
public XMLParseDemoDataModel(String filename, String[] xPath,
XMLColumnNameType4Demo[] columns) {
this.filePath = filename;
this.xPath = xPath;
this.columns = columns;
}
/**
* 取出列的数量
*/
public int getColumnCount() throws TableDataException {
return columns.length;
}
/**
* 取出相应的列的名称
*/
public String getColumnName(int columnIndex) throws TableDataException {
if (columnIndex < 0 || columnIndex >= columns.length)
return null;
String columnName = columns[columnIndex] == null ? null
: columns[columnIndex].getName();
return columnName;
}
/**
* 取出得到的结果集的总的行数
*/
public int getRowCount() throws TableDataException {
this.init();
return row_list.size();
}
/**
* 取出相应位置的值
*/
public Object getValueAt(int rowIndex, int columnIndex)
throws TableDataException {
this.init();
if (rowIndex < 0 || rowIndex >= row_list.size() || columnIndex < 0
|| columnIndex >= columns.length)
return null;
return ((Object[]) row_list.get(rowIndex))[columnIndex];
}
/**
* 释放一些资源，取数结束后，调用此方法来释放资源
*/
public void release() throws Exception {
if (this.row_list != null) {
this.row_list.clear();
this.row_list = null;
}
}
/** ************************************************** */
/** ***********以上是实现DataModel的方法*************** */
/** ************************************************** */
/** ************************************************** */
/** ************以下为解析XML文件的方法**************** */
/** ************************************************** */
// 一次性将数据取出来
protected void init() throws TableDataException {
if (this.row_list != null)
return;
this.row_list = new ArrayList();
try {
// 使用SAX解析XML文件， 使用方法请参见JAVA SAX解析
SAXParserFactory f = SAXParserFactory.newInstance();
SAXParser parser = f.newSAXParser();
parser.parse(new File(XMLParseDemoDataModel.this.filePath),
new DemoHandler());
} catch (Exception e) {
e.printStackTrace();
FRContext.getLogger().error(e.getMessage(), e);
}
}
/**
* 基本原理就是解析器在遍历文件时 发现节点开始标记时，调用startElement方法 读取节点内部内容时，调用characters方法
* 发现节点结束标记时，调用endElement
*/
private class DemoHandler extends DefaultHandler {
private List levelList = new ArrayList(); // 记录当前节点的路径
private Object[] values; // 缓存一条记录
private int recordIndex = -1; // 当前记录所对应的列的序号，-1表示不需要记录
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
// 记录下
levelList.add(qName);
if (isRecordWrapTag()) {
// 开始一条新数据的记录
values = new Object[XMLParseDemoDataModel.this.columns.length];
} else if (needReadRecord()) {
// 看看其对应的列序号，下面的characters之后执行时，根据这个列序号来设置值存放的位置。
recordIndex = getColumnIndex(qName);
}
}
public void characters(char[] ch, int start, int length)
throws SAXException {
if (recordIndex > -1) {
// 读取值
String text = new String(ch, start, length);
XMLColumnNameType4Demo type = XMLParseDemoDataModel.this.columns[recordIndex];
Object value = null;
if (type.getType() == COLUMN_TYPE_STRING) {
value = text;
}
if (type.getType() == COLUMN_TYPE_INTEGER) {
value = new Integer(text);
} else if (type.getType() == COLUMN_TYPE_BOOLEAN) {
value = new Boolean(text);
}
values[recordIndex] = value;
}
}
public void endElement(String uri, String localName, String qName)
throws SAXException {
try {
if (isRecordWrapTag()) {
// 一条记录结束，就add进list中
XMLParseDemoDataModel.this.row_list.add(values);
values = null;
} else if (needReadRecord()) {
recordIndex = -1;
}
} finally {
levelList.remove(levelList.size() - 1);
}
}
// 正好匹配路径，确定是记录外部的Tag
private boolean isRecordWrapTag() {
if (levelList.size() == XMLParseDemoDataModel.this.xPath.length
&& compareXPath()) {
return true;
}
return false;
}
// 需要记录一条记录
private boolean needReadRecord() {
if (levelList.size() == (XMLParseDemoDataModel.this.xPath.length + 1)
&& compareXPath()) {
return true;
}
return false;
}
// 是否匹配设定的XPath路径
private boolean compareXPath() {
String[] xPath = XMLParseDemoDataModel.this.xPath;
for (int i = 0; i < xPath.length; i++) {
if (!ComparatorUtils.equals(xPath[i], levelList.get(i))) {
return false;
}
}
return true;
}
// 获取该字段的序号
private int getColumnIndex(String columnName) {
XMLColumnNameType4Demo[] nts = XMLParseDemoDataModel.this.columns;
for (int i = 0; i < nts.length; i++) {
if (ComparatorUtils.equals(nts[i].getName(), columnName)) {
return i;
}
}
return -1;
}
}
}
3、定义程序数据集XMLDemoTableData 通过参数filename，动态显示xml文件内容，首先xml文件需要放到某个目录下，如下代码是放到D盘，并且定义需要解析的数据列，这边定义的数据列名称，根xml内字段名称是一一对用的。详细代码如下：
packagecom.fr.data;
importjava.io.BufferedInputStream;
importjava.io.ByteArrayInputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.InputStream;
importjava.io.Reader;
importjava.util.*;
importjavax.xml.stream.XMLEventReader;
importjavax.xml.stream.XMLInputFactory;
importjavax.xml.stream.XMLStreamException;
importjavax.xml.stream.events.XMLEvent;
importcom.fr.base.Parameter;
importcom.fr.data.AbstractParameterTableData;
importcom.fr.general.data.DataModel;
importcom.fr.script.Calculator;
importcom.fr.stable.ParameterProvider;
importcom.fr.stable.StringUtils;
/**
* XMLDemoTableData
*
* 这是一个按参数来解析不同地址XML文件的demo
*
* AbstractParameterTableData 包装了有参数数据集的基本实现
*/
publicclass XMLDemoTableData extends AbstractParameterTableData {
// 构造函数
public XMLDemoTableData() {
// 定义需要的参数，这里定义一个参数，参数名为filename，给其一个默认值"Northwind.xml"
this.parameters = newParameter[1];
this.parameters[0] = newParameter("filename", "Northwind");
}
/**
* 返回获取数据的执行对象
* 系统取数时，调用此方法来返回一个获取数据的执行对象
* 注意！当数据集需要根据不同参数来多次取数时，此方法在一个计算过程中会被多次调用。
*/
@SuppressWarnings("unchecked")
public DataModel createDataModel(Calculatorcalculator) {
// 获取传进来的参数
ParameterProvider[] params =super.processParameters(calculator);
// 根据传进来的参数，等到文件的路径
String filename = null;
for (int i = 0; i < params.length;i++) {
if (params[i] == null)continue;
if("filename".equals(params[i].getName())) {
filename =(String)params[i].getValue();
}
}
String filePath;
if (StringUtils.isBlank(filename)){
filePath ="D://DefaultFile.xml";
} else {
filePath = "D://" +filename + ".xml";
}
// 定义需要解析的数据列，机器
// XMLColumnNameType4Demo[] columns = newXMLColumnNameType4Demo[7];
// columns[0] = newXMLColumnNameType4Demo("CustomerID",XMLParseDemoDataModel.COLUMN_TYPE_STRING);
// columns[1] = newXMLColumnNameType4Demo("CompanyName",XMLParseDemoDataModel.COLUMN_TYPE_STRING);
// columns[2] = newXMLColumnNameType4Demo("ContactName",XMLParseDemoDataModel.COLUMN_TYPE_STRING);
// columns[3] = newXMLColumnNameType4Demo("ContactTitle",XMLParseDemoDataModel.COLUMN_TYPE_STRING);
// columns[4] = newXMLColumnNameType4Demo("Address",XMLParseDemoDataModel.COLUMN_TYPE_STRING);
// columns[5] = newXMLColumnNameType4Demo("City",XMLParseDemoDataModel.COLUMN_TYPE_STRING);
// columns[6] = new XMLColumnNameType4Demo("Phone",XMLParseDemoDataModel.COLUMN_TYPE_STRING);
List list=new ArrayList();
XMLInputFactory inputFactory =XMLInputFactory.newInstance();
InputStream in;
try {
in = new BufferedInputStream(newFileInputStream(new File(filePath)));
XMLEventReader reader =inputFactory.createXMLEventReader(in);
readCol(reader,list);
in.close();
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
XMLColumnNameType4Demo[]columns=(XMLColumnNameType4Demo[])list.toArray(newXMLColumnNameType4Demo[0]);
// 定义解析的数据在xml文件结构中的位置
String[] xpath = new String[2];
xpath[0] = "Northwind";
xpath[1] = "Customers";
/*
* 说明
* 提供的样例xml文件的格式是：
* <Notrhwind>
* <Customers>
* <CustomerID>ALFKI</CustomerID>
* <CompanyName>AlfredsFutterkiste</CompanyName>
* <ContactName>MariaAnders</ContactName>
* <ContactTitle>SalesRepresentative</ContactTitle>
* <Address>Obere Str. 57</Address>
* <City>Berlin</City>
* <PostalCode>12209</PostalCode>
* <Country>Germany</Country>
* <Phone>030-0074321</Phone>
* <Fax>030-0076545</Fax>
* </Customers>
* </Northwind>
*
* 上面定义的意义就是
* /Northwind/Customers路径所表示的一个Customers节点为一条数据，它包含的节点中的CustomerID...等等是需要获取的列值
*/
// 构造一个实际去取值的执行对象
return new XMLParseDemoDataModel(filePath,xpath, columns);
}
private int deep=0;
private static final int COL_DEEP=3;
private boolean flag=false;
private void readCol(XMLEventReader reader,List list)
throws XMLStreamException {
while (reader.hasNext()) {
XMLEvent event =reader.nextEvent();
if (event.isStartElement()) {
//deep是控制层数的，只把xml中对应的层的加入到列名中
deep++;
//表示已经进入到了列名那一层
if(deep==COL_DEEP){
flag=true;
}
//如果在高层，并且已经进入到了col层，则退出
if(deep<COL_DEEP&&flag){
return;
}
if(deep!=COL_DEEP){
continue;
}
// println("name: " +event.asStartElement().getName());
XMLColumnNameType4Democolumn=new XMLColumnNameType4Demo(event.asStartElement().getName().toString(),XMLParseDemoDataModel.COLUMN_TYPE_STRING);
list.add(column);
readCol(reader,list);
} else if (event.isCharacters()){
//对数据值不做处理
} else if (event.isEndElement()){
deep--;
return;
}
}
}
private void readCol0(XMLEventReader reader)
throws XMLStreamException {
while (reader.hasNext()) {
XMLEvent event = reader.nextEvent();
if (event.isStartElement()) {
//deep是控制层数的，只把xml中对应的层的加入到列名中
deep++;
//表示已经进入到了列名那一层
if(deep==COL_DEEP){
flag=true;
}
//如果在高层，并且已经进入到了col层，则退出
if(deep<COL_DEEP&&flag){
return;
}
if(deep!=COL_DEEP){
continue;
}
System.out.println("name:" + event.asStartElement().getName());
readCol0(reader);
} else if (event.isCharacters()){
//对数据值不做处理
} else if (event.isEndElement()){
deep--;
return;
}
}
}
public static void main(String[]args){
XMLInputFactory inputFactory =XMLInputFactory.newInstance();
// in = new FileReader(newFile(filePath));
// XMLEventReader reader = inputFactory.createXMLEventReader(in);
// readCol(reader,list);
BufferedInputStream in;
try {
in = new BufferedInputStream(newFileInputStream(new File("D:/tmp/f.xml")));
byte[] ba=new byte[3];
in.read(ba,0,3);
// System.out.println(in)
XMLEventReader reader =inputFactory.createXMLEventReader(in);
newXMLDemoTableData().readCol0(reader);
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
}
}
注：如果xml文件的格式上问题描述处所展示的xml格式不一致，则需要修改类中的deep变量，把列名所在的节点层数改成相对应的数值。 注：XMLDemoTableData里面的filename并不是文件名，而是xml里面某个标签名。 4、编译程序数据源 分别编译XMLColumnNameType4Demo.java、XMLParseDemoDataModel.java、XMLDemoTableData.java三个类文件，将生成的class文件放于%FR_HOME%\WebReport\WEB-INF\classes\com\fr\data下。
5 配置程序数据源 新建报表，模板数据集>程序数据集，选择我们定义好的程序数据集XMLDemoTableData.class文件，名字可以自定义，如程序1。 
6、使用程序数据源 在模板数据集窗口，点击预览按钮，弹出参数对话框，输入要显示的xml文件名称，点击确定则可以把Northwind.xml文件里面的数据读取出来转换报表数据源了，如下图： 
java实现excel文件转换为xml文件
一、导包：
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.17</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-examples</artifactId>
<version>3.16</version>
</dependency>
<dependency>
<groupId>org.jdom</groupId>
<artifactId>jdom</artifactId>
<version>1.1.3</version>
</dependency>
二、代码部分：
public class AnalysisEtoX {
public static void main(String[] args) {
try {
System.out.println("=============");
// 用输入流从本地拿到对应的Excel文件
InputStream stream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\试题.xlsx");
// 指定要生成的xml的路径，并构建文件对象
File f = new File("test.xml");// 新建个file对象把解析之后得到的xml存入改文件中
writerXML(stream, f);// 将数据以xml形式写入文本
} catch (FileNotFoundException e) {
System.out.println("未找到指定路径的文件!");
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void writerXML(InputStream stream, File f) throws IOException {
System.out.println("into writerXML");
FileOutputStream fo = new FileOutputStream(f);// 得到输入流
Document doc = readExcell(stream);// 读取EXCEL函数
Format format = Format.getCompactFormat().setEncoding("UTF-8").setIndent("");
XMLOutputter XMLOut = new XMLOutputter(format);// 在元素后换行，每一层元素缩排四格
XMLOut.output(doc, fo);
fo.close();
}
private static Document readExcell(InputStream stream) {
System.out.println("into readExcell");
// 设置根<tax_institutions></tax_institutions>元素
Element root = new Element("tax_institutions");
Document doc = new Document(root);
try {
HSSFWorkbook hw = new HSSFWorkbook(stream);
// 获取工作薄的个数，即一个excel文件中包含了多少个Sheet工作簿
int WbLength = hw.getNumberOfSheets();
System.out.println("WbLength=" + WbLength);
for (int i = 0; i < WbLength; i++) {
HSSFSheet shee = hw.getSheetAt(i);
int length = shee.getLastRowNum();
System.out.println("行数：" + length);
for (int j = 1; j <= length; j++) {
HSSFRow row = shee.getRow(j);
if (row == null) {
continue;
}
int cellNum = row.getPhysicalNumberOfCells();// 获取一行中最后一个单元格的位置
System.out.println("列数cellNum：" + cellNum);
Element e = null;
// 设置根元素下的并列元素<tax_institution></tax_institution>
e = new Element("tax_institution");
// Element[] es = new Element[16];
for (int k = 0; k < cellNum; k++) {
HSSFCell cell = row.getCell((short) k);
String temp = get(k);
System.out.print(k + " " + temp + ":");
Element item = new Element(temp);
if (cell == null) {
item.setText("");
e.addContent(item);
cellNum++;// 如果存在空列，那么cellNum增加1，这一步很重要。
continue;
}
else {
String cellvalue = "";
switch (cell.getCellType()) {
// 如果当前Cell的Type为NUMERIC
case HSSFCell.CELL_TYPE_NUMERIC:
case HSSFCell.CELL_TYPE_FORMULA: {
// 判断当前的cell是否为Date
if (HSSFDateUtil.isCellDateFormatted(cell)) {
// 如果是Date类型则，转化为Data格式
// 方法1：这样子的data格式是带时分秒的：2011-10-12 0:00:00
// cellvalue =
cell.getDateCellValue().toLocaleString();
// 方法2：这样子的data格式是不带带时分秒的：2011-10-12
Date date = cell.getDateCellValue();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
cellvalue = sdf.format(date);
item.setText(cellvalue);
}
// 如果是纯数字
else {
// 取得当前Cell的数值
cellvalue = String.valueOf((int) cell.getNumericCellValue());
item.setText(cellvalue);
}
break;
}
// 如果当前Cell的Type为STRIN
case HSSFCell.CELL_TYPE_STRING:
// 取得当前的Cell字符串
cellvalue = cell.getRichStringCellValue().getString();
item.setText(cellvalue);
break;
// 默认的Cell值
default:
cellvalue = " ";
item.setText(cellvalue);
}
e.addContent(item);
System.out.println(cellvalue);
}
}
root.addContent(e);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
stream.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
return doc;
}
// 设置并列元素里的子元素名
private static String get(int k) {
String test = "";
switch (k) {
case 0:
test = "org_name";
break;
case 1:
test = "legal_mobile_phone";
break;
case 2:
test = "org_address";
break;
case 3:
test = "cert_type";
break;
case 4:
test = "postal_code";
break;
case 5:
test = "reg_sum";
break;
case 6:
test = "business_scope";
break;
case 7:
test = "social_credit_code";
break;
case 8:
test = "reg_type";
break;
case 9:
test = "legal_person_name";
break;
case 10:
test = "cert_number";
break;
case 11:
test = "found_time";
break;
case 12:
test = "service_status";
break;
case 13:
test = "staff_sum";
break;
case 14:
test = "partner_sum";
break;
case 15:
test = "is_branch_org";
break;
default:
}
return test;
}
}转载地址csdn：https://blog.csdn.net/weixin_40420734/article/details/79538772
注意：
excel版本保存文件的后缀名问题，如果是.xls，使用HSSFWorkbook；如果是xlsx，使用XSSFWorkbook。
版本错误会抛出OfficeXmlFileException！！！
原文出处：https://www.cnblogs.com/Pamper-Chen/p/10291004.html
今天关于使用Java将XML文件转换为CSV文件和java将xml转换为对象的分享就到这里，希望大家有所收获，若想了解更多关于Java xml文件转换为map集合、JAVA 将xml文件转换成String、Java如何解析某个目录下xml文件，将XML文件转换为报表数据源？、java实现excel文件转换为xml文件等相关知识，可以在本站进行查询。
本文标签：
