Java中字符串处理

在Java开发过程中经常会遇到字符处理的问题，比如接收到xml格式的字符串，需要把它转换成对象。对象需要转化成xml字符串发送出去。

这里收藏两篇文章供日后参考。

1.利用jdom把xml字符串转化为对象

JAVA解析XML格式字符串

http://zhenhu5131420.blog.163.com/blog/static/439143252009102351346784/

http://blog.sina.com.cn/s/blog_700dec940100spox.html

 

package com.freesky.xml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

import java.io.IOException;
import java.io.StringReader;
import java.util.List;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.Namespace;
import org.jdom.input.SAXBuilder;
import org.xml.sax.InputSource;

public class DuXMLDoc {
public List xmlElements(String xmlDoc) {
//创建一个新的字符串
StringReader read = new StringReader(xmlDoc);
//创建新的输入源SAX 解析器将使用 InputSource 对象来确定如何读取 XML 输入
InputSource source = new InputSource(read);
//创建一个新的SAXBuilder
SAXBuilder sb = new SAXBuilder();
try {
//通过输入源构造一个Document
Document doc = sb.build(source);
//取的根元素
Element root = doc.getRootElement();
System.out.println(root.getName());//输出根元素的名称（测试）
//得到根元素所有子元素的集合
List jiedian = root.getChildren();
//获得XML中的命名空间（XML中未定义可不写）
Namespace ns = root.getNamespace();
Element et = null;
for(int i=0;i<jiedian.size();i++){
et = (Element) jiedian.get(i);//循环依次得到子元素

System.out.println(et.getChild("users_id",ns).getText());
System.out.println(et.getChild("users_address",ns).getText());
}

et = (Element) jiedian.get(0);
List zjiedian = et.getChildren();
for(int j=0;j<zjiedian.size();j++){
Element xet = (Element) zjiedian.get(j);
System.out.println(xet.getName());
}
} catch (JDOMException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
return null;
}
public static void main(String[] args){
DuXMLDoc doc = new DuXMLDoc();
// String xml = "<?xml version=\"1.0\" encoding=\"gb2312\"?>"+
// "<Result xmlns=\"http://www.fiorano.com/fesb/activity/DBQueryOnInput2/Out\">"+
// "<row resultcount=\"1\">"+
// "<users_id>1001 </users_id>"+
// "<users_name>wangwei </users_name>"+
// "<users_group>80 </users_group>"+
// "<users_address>1001号 </users_address>"+
// "</row>"+
// "<row resultcount=\"1\">"+
// "<users_id>1002 </users_id>"+
// "<users_name>wangwei </users_name>"+
// "<users_group>80 </users_group>"+
// "<users_address>1002号 </users_address>"+
// "</row>"+
// "</Result>";
// doc.xmlElements(xml);

File file = new File("./xml/outparam.xml");
try {
FileReader fr = new FileReader(file);
char[] values = new char[800];
int length = fr.read(values);
String s = new String(values, 0 , length);

System.out.println(s);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

 

2.自定义格式，把对象转换成xml字符串。

Java生成XML格式的字符串

http://padden.blog.51cto.com/2514314/578685

 

package com.freesky.xml;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* 根据该对象可以构造Xml字符串
*
*
*/
public class XmlObject {
private static String HEAD = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
private String name;
private Object value;
private List<Attribute> attributes;
private List<XmlObject> subXmlObjects;


public static void main(String[] args) {
XmlObject xmlObject = new XmlObject("deviceparams");
xmlObject.setAttribute("type", "input");
xmlObject.setAttribute("id", "123123123");

XmlObject paramObject = new XmlObject("param");
paramObject.setAttribute("name", "techtype");
paramObject.setAttribute("value", "HW123");
xmlObject.addSubXmlObject(paramObject);

XmlObject inputObject = new XmlObject("inputparams");
inputObject.addSubXmlObject(paramObject);
xmlObject.addSubXmlObject(inputObject);

System.out.println(xmlObject.toFormatXml());
}

/**
* 根据name构造XmlObject
*
* @param name
* 生成xml时标签名，如name="html"，则生成xml为<html/>
*/
public XmlObject(String name) {
this.name = name;
}

/**
* 获得当前对象的名称
*
* @return 返回当前对象的名称
*/
public final String getName() {
return name;
}

/**
* 设置当前对象的名称
*
* @param name
* 给定名称
*/
public final void setName(String name) {
this.name = name;
}

/**
* 获得当前对象的值
*
* @return 返回当前对象的值
*/
public final Object getValue() {
return value;
}

/**
* 设置当前对象的值
*
* @param value
* 给定值
*/
public final void setValue(Object value) {
this.value = value;
}

/**
* 为当前XmlObject添加属性
*
* @param name
* 属性名
* @param value
* 属性值
*/
public final void setAttribute(String name, Object value) {
if (attributes == null) {
attributes = new ArrayList<Attribute>();
}
Attribute attribute = null;
for (Attribute att : attributes) {
if (name.equalsIgnoreCase(att.getName())) {
attribute = att;
break;
}
}
if (attribute == null) {
attribute = new Attribute(name, value);
attributes.add(attribute);
} else {
attribute.setValue(value);
}
}

/**
* 根据属性名称获得当前XmlObject对象的属性值
*
* @param name
* 属性名称
* @return 属性值
*/
public final Object getAttributeValue(String name) {
return getAttributeValue(name, null);
}

/**
* 根据属性名称获得当前XmlObject对象的属性值
*
* @param name
* 属性名称
* @param defaultValue
* 默认值
* @return 若属性存在，则返回属性值，否则返回默认值
*/
public final Object getAttributeValue(String name, Object defaultValue) {
Attribute attribute = null;
for (Attribute att : attributes) {
if (name.equalsIgnoreCase(att.getName())) {
attribute = att;
break;
}
}
if (attribute == null) {
return defaultValue;
} else {
return attribute.getValue();
}
}

/**
* 为当前XmlObject对象添加子XmlObject对象
*
* @param xmlObject
* 给定XmlObject对象
*/
public final void addSubXmlObject(XmlObject xmlObject) {
if (subXmlObjects == null) {
subXmlObjects = new ArrayList<XmlObject>();
}
subXmlObjects.add(xmlObject);
}

/**
* 构造当前对象的压缩XML字符串
*
* @return XML字符串
*/
public final String toCompactXml() {
return HEAD + getNoHeadXml("", "");
}

/**
* 根据格式化留白("\t")和默认的行分隔符("\t")构造当前对象的XML字符串
*
* @return XML字符串
*/
public String toFormatXml() {
return toFormatXml("\t");
}

/**
* 根据格式化留白和默认的行分隔符("\n")构造当前对象的XML字符串
*
* @param blank
* 格式化留白
* @return XML字符串
*/
protected final String toFormatXml(String blank) {
return HEAD + "\n" + getNoHeadXml(blank, "\n");
}

/**
* 根据格式化留白和行分隔符构造当前对象的无头的XML字符串
*
* @param blank
* 格式化留白
* @param split
* 行分隔符
* @return 无头的XML字符串
*/
protected final String getNoHeadXml(String blank, String split) {
return getNoHeadXml(blank, split, 0);
}

private final String getNoHeadXml(String blank, String split, int count) {
String blanks = "";
for (int i = 0; i < count; i++) {
blanks += blank;
}
StringBuffer sb = new StringBuffer();
sb.append(blanks + "<" + name);
if (attributes != null) {
Iterator<Attribute> iterator = attributes.iterator();
while (iterator.hasNext()) {
Attribute attribute = iterator.next();
sb.append(" " + attribute.getName() + "=\""
+ attribute.getValue() + "\"");
}
}
if (subXmlObjects == null) {
if (value == null) {
sb.append("/>" + split);
} else {
sb.append(">");
sb.append(value);
sb.append("</" + name + ">" + split);
}
} else {
sb.append(">" + split);
Iterator<XmlObject> iterator = subXmlObjects.iterator();
count += 1;
while (iterator.hasNext()) {
XmlObject xmlObject = iterator.next();
sb.append(xmlObject.getNoHeadXml(blank, split, count));
}
sb.append(blanks + "</" + name + ">" + split);
}
return sb.toString();
}

class Attribute {
private String name;
private Object value;

public Attribute(String name, Object value) {
this.name = name;
this.value = value;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Object getValue() {
return value;
}

public void setValue(Object value) {
this.value = value;
}
}
}

3. 利用JDK1.5中javax.xml包对字符串进行处理，其中提供了DOM解析和SAX解析。下面这个例子演示了如何解析xml文件，如何构造xml字符串，以及如何解析xml字符串 。

package com.freesky.xml;

/** 要读的xml文件

<?xml version="1.0" encoding="GB2312"?>
<学生花名册>
<学生 性别 = "男">
<姓名>李华</姓名>
<年龄>14</年龄>
</学生>
<学生 性别 = "男">
<姓名>张三</姓名>
<年龄>16</年龄>
</学生>
</学生花名册>

*/

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.Iterator;
import java.util.Vector;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

public class DomTest {
Vector<Student> students_Vector;

/**
* 功能：读取XML文件中的信息
*/
public Vector<Student> readXMLFile(String file) throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(file); // 获取到xml文件
// 下面开始读取
loadDocument(doc);
return students_Vector;
}

/**
* 功能：直接提取XML格式字符串中的信息
*/
public Vector<Student> readXMLString(String xmlStr) throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbf.newDocumentBuilder();
InputStream inputStream = new ByteArrayInputStream(xmlStr.getBytes());
Document doc = builder.parse(inputStream); //
// 下面开始读取
loadDocument(doc);

return students_Vector;
}

private void loadDocument(Document doc) {
// 下面开始读取
Element root = doc.getDocumentElement(); // 获取根元素
NodeList students = root.getElementsByTagName("学生");
students_Vector = new Vector<Student>();
for (int i = 0; i < students.getLength(); i++) {
// 一次取得每一个学生元素
Element ss = (Element) students.item(i);

// 创建一个学生的实例
Student stu = new Student();
stu.setSex(ss.getAttribute("性别"));

NodeList names = ss.getElementsByTagName("姓名");
Element e = (Element) names.item(0);
Node t = e.getFirstChild();
stu.setName(t.getNodeValue());

NodeList ages = ss.getElementsByTagName("年龄");
e = (Element) ages.item(0);
t = e.getFirstChild();
stu.setAge(Integer.parseInt(t.getNodeValue()));

students_Vector.add(stu);
}

}

// 将Document内容 写入XML字符串并返回
private String callWriteXmlString(Document doc, String encoding) {

try {
Source source = new DOMSource(doc);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
OutputStreamWriter write = new OutputStreamWriter(outStream);
Result result = new StreamResult(write);

Transformer xformer = TransformerFactory.newInstance()
.newTransformer();
xformer.setOutputProperty(OutputKeys.ENCODING, encoding);

xformer.transform(source, result);
return outStream.toString();

} catch (TransformerConfigurationException e) {
e.printStackTrace();
return null;
} catch (TransformerException e) {
e.printStackTrace();
return null;
}

}

/**
* 功能：生成XML格式的字符串
*/
public String writeXMLString() {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = null;
try {
builder = dbf.newDocumentBuilder();
} catch (Exception e) {
}
Document doc = builder.newDocument();

Element root = doc.createElement("学生花名册");
doc.appendChild(root); // 将根元素添加到文档上

// 获取学生信息
for (Student s : students_Vector) {
// 创建一个学生
Element stu = doc.createElement("学生");
stu.setAttribute("性别", s.getSex());
root.appendChild(stu);// 添加属性

// 创建文本姓名节点
Element name = doc.createElement("姓名");
stu.appendChild(name);
Text tname = doc.createTextNode(s.getName());
name.appendChild(tname);

// 创建文本年龄节点
Element age = doc.createElement("年龄");
stu.appendChild(age); // 将age添加到学生节点上
Text tage = doc.createTextNode(String.valueOf(s.getAge()));
age.appendChild(tage); // 将文本节点放在age节点上
}
try {
String result = callWriteXmlString(doc, "gb2312");
return result;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}

/**
* 主函数
*/
public static void main(String args[]) {
String str = "xml\\Student.xml";
DomTest t = new DomTest();
System.out.println("解析原始XML文件：");
try {
Vector<Student> v = t.readXMLFile(str);
Iterator<Student> it = v.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName() + "\t" + s.getAge() + "\t"
+ s.getSex());
}
} catch (Exception e) {
e.printStackTrace();

}
String xmlStr = t.writeXMLString();
System.out.println("\n生成的XML字符串：\n" + xmlStr);
try {
Vector<Student> v = t.readXMLString(xmlStr);
Iterator<Student> it = v.iterator();
System.out.println("\n解析生成的XML字符串：");
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName() + "\t" + s.getAge() + "\t"
+ s.getSex());
}
} catch (Exception e) {

e.printStackTrace();
}
}
}

class Student {
private String sex;
private String name;
private int age;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public void setSex(String s) {
sex = s;
}

public String getSex() {
return sex;
}

public void setName(String n) {
name = n;
}

public String getName() {
return name;
}
}