java基础第十九篇之Xml

2023年6月15日 129次阅读

1:xml的概述
1.1 xml是什么
标记语言:语言中出现了<a></a>的标签
a:HTML 超文本标记语言（语法非常严格，不能随意的定义标签）
b:XML 可扩展的标记语言(用户可以根据自己的需求，随意的定义标签)
开发的组织:w3c
版本:使用 1.0

1.2 xml有什么用
a:存储数据
b:作为配置文件
1.3 xml怎么用

<?xml version=”1.0″ encoding=”UTF-8″?>
<persons>
<person id=”p001″>
<name>张三</name>
</person>
<person id=”p002″>
<name>李四</name>
</person>
</persons>

//——————————-
<students>
<student id=”i001″>
<name>zhangsan</name>
</student>

</students>

2:xml的语法
2.1 文档声明
<?xml version=”1.0″ encoding=”UTF-8″?>
1) 文档声明必须为<?xml开头，以?>结束；
2) 文档声明必须从文档的0行0列位置开始；
3) 文档声明只有2个属性：
a) versioin：指定XML文档版本。只会选择1.0；
b) encoding：指定当前文档保存时编码方式。可选属性，默认值是UTF-8；

例题:
<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans SYSTEM “bean.dtd” >
<beans>

</beans>

2.2 元素(element)
1. 元素是XML文档中最重要的组成部分，开始标签元素体结束标签
2. 普通元素的结构开始标签、元素体、结束标签组成。例如：<hello> 大家好 </hello>
3. 元素体：元素体可以是元素，也可以是文本，例如：<b><a>你好</a></b>
4. 空元素：元素没有元素体,空元素只有开始标签，而没有结束标签，但元素必须自己闭合，例如：<c/>
5. 元素命名：
a) 区分大小写
b) 不能使用空格，不能使用冒号:
c) 不建议以XML、xml、Xml开头
6. 格式化良好的XML文档，必须只有一个根元素。除了根元素，所有元素必须被其他元素包含

2.3 属性(attribute)
1. 属性是元素的一部分，它必须出现在元素的开始标签中
2. 属性的定义格式：属性名=属性值，其中属性值必须使用单引或双引
3. 一个元素可以有0~N个属性，但一个元素中不能出现同名属性
4. 属性名不能使用空格、冒号等特殊字符，且必须以字母开头

属性和子元素的选择
a:如果你描述的数据是对元素的标识(id)，则应该放在属性中
b:如果你描述的数据需要进行再次扩展，必须放在子元素中
2.4 注释
XML的注释，以“<!–”开始，以“–>”结束。注释内容会被XML解析器忽略！
a)注释不能放在文件的第一行
b)注释的快捷键
注释：ctrl + shift + /
反注释：ctrl + shift + \

<?xml version=”1.0″ encoding=”UTF-8″?>

<!– 这个是注释 –>
<阿拉基>
<student stuid=”it001″>
<name>zhangsan</name>
<age>18</age>
</student>
<student stuid=”it002″>
<name>lisi</name>
<age>20</age>
</student>
</阿拉基>

2.4 转义字符
 转义字符
因为很多符号已经被XML文档结构所使用，所以在元素体或属性值中想使用这些符号就必须使用转义字符，例如：“<”、“>”、“’”、“””、“&”。
< –> <
> –> >
” –> "
‘ –> '
& –> &amp
2.5 CDATA区
<![CDATA[
任意内容
]]>
当你的标签内容有大量的转义字符时，则可以使用CDATA区，一次性全部转义

例题:
<?xml version=”1.0″ encoding=”UTF-8″?>

3:xml的约束
xml约束:xml中的标签默认是可以随便扩展，这样就造成了xml的随意性太大，为了给xml一个统一的规范,就必须使用xml约束

3.1 DTD约束
DTD（Document Type Definition），文档类型定义
约束：标签的名字，标签的属性，标签的顺序
我们的任务就是根据已经提供好的DTD约束文档来定义xml文件

3.2 DTD约束步骤
 步骤1：创建bean-dtd.xml文档，并将“bean.dtd”拷贝相同目录下
步骤2：从DTD文档开始处，拷贝需要的“文档声明”
步骤3：完成xml内容编写

3.4 DTD的文档声明
1: 内部DTD，在XML文档内部嵌入DTD，只对当前XML有效。
<?xml version=”1.0″ encoding=”utf-8″ ?>
<!DOCTYPE beans [
… //具体的语法
]>
<beans>
</beans>

2: 本地DTD，DTD文档在本地系统上，公司内部自己项目使用。
<?xml version=”1.0″ encoding=”utf-8″ ?>
<!DOCTYPE beans SYSTEM”bean.dtd”>
<beans>
</beans>

3: 外部DTD—公共DTD，DTD文档在网络上，一般都有框架提供。
需要有网络，当第一次使用之后，则会在本地缓存。
<?xml version=”1.0″ encoding=”UTF-8″?>
<!– DTD的名字–>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN 2.0//EN”
<!– DTD的网络位置–>
“http://www.springframework.org/dtd/spring-beans-2.0.dtd”>
<beans>

3.5 元素
<!ELEMENT 元素名元素描述>
?:可以出现，但只能出现一次
*:允许出现多次，也可以是0次
+:该对象至少出现一次，但可以是多次
,:元素按照指定的顺序出现

//——————————————
根元素:beans 而且有两个子元素：bean(0次或多次) 和import(0次或多次,而且必须按照指定的顺序出现
#PCDATA:表示元素体是文本

<!ELEMENT beans (bean*,import*) >
<!ELEMENT bean (property*)>
<!ELEMENT property (#PCDATA)>

<!ELEMENT import (#PCDATA)>

bean有三个属性:id className type
<!ATTLIST bean id ID #REQUIRED
className CDATA #REQUIRED
type CDATA #IMPLIED
>

<!ATTLIST property name CDATA #REQUIRED
value CDATA #REQUIRED
>

<!ATTLIST import resource CDATA #REQUIRED>

3.2 Schema约束
Schema是新的XML文档约束；
Schema要比DTD强大很多，是DTD 替代者；
Schema本身也是XML文档，但Schema文档的扩展名为xsd，而不是xml。
Schema 功能更强大，数据类型更完善
Schema 支持名称空间
3.3 约束文档和XML关系
W3C提出Schema约束规范时，就提供“官方约束文档”。我们通过官方文档，必须“自定义schema 约束文档”，开发中“自定义文档”由框架编写者提供。我们提供“自定义文档”限定，编写出自己的xml文档。
3.3 命名空间
默认的命名空间
xmlns=”http://www.baidu.cn/bean”
显式的命名空间
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
使用标签时，必须加前缀
xsi:xxx

必须指定xsd文件的位置

//命名空间约束文件的名字
xsi:schemaLocation=”http://www.baidu.cn/bean bean-schema.xsd”>

案例:

<?xml version=”1.0″ encoding=”UTF-8″?>
<!–
ns:namespac:命名空间类似于java中包

当我们去使用一个约束文件（w3c的约束除外）时，除了必须对该约束声明之外，
还必须指定该约束文件的名字

xsi:schemaLocation=”http://www.baidu.cn/bean bean-schema.xsd”

–>
<beans xmlns=”http://www.baidu.cn/bean”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.baidu.cn/bean bean-schema.xsd”>
<bean className=”” id=””>
<property value=””/>
<ele/>
</bean>
<import resource=””/>
</beans>

例题:
<?xml version=”1.0″ encoding=”UTF-8″?>

“xmlns”是XHTML namespace的缩写，叫做”名字空间”声明。名字空间是什么作用呢？我的理解是：

由于xml允许你自己定义自己的标识，你定义的标识和其他人定义的标识有可能相同，但表示不同的意义。当文件交换或者共享的时候就容易产生错误。为了避免这种错误发生，XML采用名字空间声明，允许你通过一个网址指向来识别你的标识。

比如在一个文档<table>wood table</table>中<table>表示桌子，而在另一个文档<table>namelist</table>中<table>表示表格。如果我需要同时处理这两个文档，就会发生名字冲突。为了解决这个问题，我们引进了namespaces这个概念。namespaces通过给标识名称加一个网址(URL)定位的方法来区别这些名称相同的标识。
Namespaces同样需要在XML文档的开头部分声明，声明的语法如下：
<document xmlns:yourname=’URL’>

其中yourname是由你定义的namespaces的名称，URL就是名字空间的网址。
假设上面的”桌子<table>”文档来自http://www.zhuozi.com/，我们就可以声明为
<document xmlns:zhuozi=’http://www.zhuozi.com’>;

然后在后面的标识中使用定义好的名字空间：
<zhuozi:table>wood table</table>
这样就将这两个<table>区分开来。注意的是：设置URL并不是说这个标识真的要到那个网址去读取，仅仅作为一种区别的标志而已。

命名冲突请看下面两个例子
这个 XML 文档在table元素中携带了水果的信息:
<table>
<tr>
<td>Apples</td>
<td>Bananas</td>
</tr>
</table>

这个 XML 文档在table元素中携带了桌子的信息(家具，不能吃的哦):
<table>
<name>African Coffee Table</name>
<width>80</width>
<length>120</length>
</table>
如果上面两个XML文档片断碰巧在一起使用的话，那么将会出现命名冲突的情况。因为这两个片断都包含了<table>元素，而这两个table元素的定义与所包含的内容又各不相同。

——————————————————————————–
使用前缀解决命名冲突问题
下面的XML文档在table元素中携带了信息:
<h:table>
<h:tr>
<h:td>Apples</h:td>
<h:td>Bananas</h:td>
</h:tr>
</h:table>

下面的XML文档携带了家具table的信息:
<f:table>
<f:name>African Coffee Table</f:name>
<f:width>80</f:width>
<f:length>120</f:length>
</f:table>

现在已经没有元素命名冲突的问题了，因为这两个文档对各自的table元素使用了不同的前缀，table元素在两个文档中分别是(<h:table> 和<f:table>)。
通过使用前缀，我们创建了两个不同的table元素。

——————————————————————————–
使用命名空间
下面的XML文档在table元素中携带了信息:
<h:table xmlns:h=”http://www.w3.org/TR/html4/”>
<h:tr>
<h:td>Apples</h:td>
<h:td>Bananas</h:td>
</h:tr>
</h:table>

下面的XML文档携带了家具table的信息:
<f:table xmlns:f=”http://www.w3schools.com/furniture”>
<f:name>African Coffee Table</f:name>
<f:width>80</f:width>
<f:length>120</f:length>
</f:table>
在上面两个例子中除了使用前缀外，两个table元素都使用了xmlns属性，使元素和不同的命名空间关联到一起。

——————————————————————————–
命名空间属性
命名空间属性一般放置在元素的开始标记处，其使用语法如下所示:
xmlns:namespace-prefix=”namespace”

在上面的例子中，命名空间定义了一个Internet 地址:
xmlns:f=”http://www.w3schools.com/furniture”

W3C 命名规范声明命名空间本身就是一个统一资源标示符，Uniform Resource Identifier (URI)。

当我们在元素的开始标记处使用命名空间时，该元素所有的子元素都将通过一个前缀与同一个命名空间相互关联。
注意：用来标识命名空间的网络地址并不被XML解析器调用，XML解析器不需要从这个网络地址中查找信息，该网络地址的作用仅仅是给命名空间一个唯一的名字，因此这个网络地址也可以是虚拟的，然而又很多公司经常把这个网络地址指向一个真实的Web页面，这个地址包含了关于当前命名空间更详细的信息。
可以访问http://www.w3.org/TR/html4/.

——————————————————————————–
统一资源标识符
通用资源标识符（A Uniform Resource Identifier (URI)）是一个标识网络资源的字符串。最普通的URI应该是统一资源定位符Uniform Resource Locator (URL)。URL用于标识网络主机的地址。另一方面，另一个不常用的URI是通用资源名字Universal Resource Name (URN)。在我们的例子中，一般使用的是URLs。
既然前面的例子使用的URL地址来标识命名空间，我们可以确信这个命名空间是唯一的。

——————————————————————————–
默认的命名空间
定义一个默认的XML命名空间使得我们在子元素的开始标记中不需要使用前缀。他的语法如下所示:
<element xmlns=”namespace”>
下面的XML文档在table元素中包含了水果的信息:
<table xmlns=”http://www.w3.org/TR/html4/”>
<tr>
<td>Apples</td>
<td>Bananas</td>
</tr>
</table>
下面的XML文档包含了家具table的信息:
<table xmlns=”http://www.w3schools.com/furniture”>
<name>African Coffee Table</name>
<width>80</width>
<length>120</length>
</table>

——————————————————————————–
使用命名空间
档开始使用XSL的时候,就会发现命名空间使用的是如此频繁。XSL样式单主要用于将XML文档转换成类似于HTML文件的格式。
如果看一下下面的XSL文档，就会发现有很多标记都是HTML标记。那些标记并不是HTML标记，是加了前缀的XSL,这个XSL前缀由命名空间”http://www.w3.org/TR/xsl”所标识:
<?xml version=”1.0″ encoding=”ISO-8859-1″?>
<xsl:stylesheet xmlns:xsl=”http://www.w3.org/TR/xsl”>
<xsl:template match=”/”>
<html>
<body>
<table border=”2″ bgcolor=”yellow”>
<tr>
<th>Title</th>
<th>Artist</th>
</tr>
<xsl:for-each select=”CATALOG/CD”>
<tr>
<td><xsl:value-of select=”TITLE”/></td>
<td><xsl:value-of select=”ARTIST”/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

4:xml解析
就是取出xml存储的数据(属性和文本)
<!– xml文件–>

常用API如下：
1. SaxReader对象
a) read(…) 加载执行xml文档
2. Document对象
a) getRootElement() 获得根元素
3. Element对象
a) elements(…) 获得指定名称的所有子元素。可以不指定名称
b) element(…) 获得指定名称第一个子元素。可以不指定名称
c) getName() 获得当前元素的元素名
d) attributeValue(…) 获得指定属性名的属性值
e) elementText(…) 获得指定名称子元素的文本值
f) getText() 获得当前元素的文本内容
h) attributes() 表示获得这个元素所有的属性名,返回一个集合来存储它们
代码如下:获得属性名的集合后(集合的类型为attribute) ,这样就得到了一个元素里
面的每一个属性名对象(而类型是attribute),再调用geiName(),得到每一个属性名的名字

例子:

public class Test1 {
public static void main(String[] args) throws Exception {
SAXReader sr = new SAXReader();
Document read = sr.read(“did.xml”);
Element rootElement = read.getRootElement();
List<Element> elements = rootElement.elements();;
Student s = new Student();
for (Element element : elements) {
List<Attribute> attributes = element.attributes();
for (Attribute attribute : attributes) {
String name = attribute.getName();
System.out.println(name);
}
List<Element> elements1 = element.elements();
for (Element element1 : elements1) {
String text = element1.getText();
String name = element1.getName();
BeanUtils.setProperty(s,name,text);
System.out.println(name);
System.out.println(text);
}
}
System.out.println(s);
}

}

例题:书架

<?xml version=”1.0″ encoding=”utf-8″ ?>
<书架>
<书 ISBN = “IT12306”>
<书名>Java就业培训教程</书名>
<作者>张孝祥</作者>
<售价>39.00元</售价>
</书>
<书 ISBN = “IT10086”>
<书名>JavaScript网页开发</书名>
<作者>张孝祥</作者>
<售价>199.00元</售价>
</书>
</书架>

import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class XMLParse {
public static void main(String[] args) throws DocumentException {
//1: 创建SAXReader对象
SAXReader sr = new SAXReader();
//2:将整个xml读取到内存
Document document = sr.read(“books.xml”);
//3: 获取根元素
Element rootElement = document.getRootElement();
//4:获取根元素的子元素：书
List<Element> elements = rootElement.elements();
//5:遍历集合，获取书架的子元素
for (Element element : elements) {
//5.1获取书的属性值ISBN
String value = element.attributeValue(“ISBN”);
System.out.println(value);
//6:获取书的子元素:书名作者售价
List<Element> elements2 = element.elements();
for (Element element2 : elements2) {
//获取书名作者售价的文本值
String text = element2.getText();
System.out.println(element2.getName()+”:”+text);
}
}
}
}

例题:给自定义的类加上自定义的注解,进行排序

package pack02_homework;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
public abstract String myRun();
public abstract String myOrder();
}

package pack02_homework;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Demo{
private int index;
private Method method;
public Demo() {
super();
// TODO Auto-generated constructor stub
}
public Demo(int index, Method method) {
super();
this.index = index;
this.method = method;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}

}
public class TestDemo {
public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
Class<?> clazz = UseAnnotation.class;
Object obj = clazz.newInstance();
ArrayList<Demo> list = new ArrayList<Demo>();
Method[] methods = clazz.getMethods();

for (Method method : methods) {
boolean bl = method.isAnnotationPresent(MyAnnotation.class);
if(bl){
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
String run = annotation.myRun();
if(run.equals(“run”)){
String order = annotation.myOrder();
if(order.equals(“first”)){
list.add(new Demo(1,method));
}
if(order.equals(“second”)){
list.add(new Demo(2,method));
}
if(order.equals(“third”)){
list.add(new Demo(3,method));
}
if(order.equals(“forth”)){
list.add(new Demo(4,method));
}
}
}

}
//对集合进行排序
Collections.sort(list, new Comparator<Demo>() {

@Override
public int compare(Demo o1, Demo o2) {
return o1.getIndex() – o2.getIndex();
}
});
for(Demo d : list){
Method method = d.getMethod();
method.invoke(obj);
}
}
}

//加强版

package pack03_homework;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

}
public class TestDemo {
public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
Class<?> clazz = UseAnnotation.class;
Object obj = clazz.newInstance();
TreeMap<Integer, Method> tm = new TreeMap<>();
Method[] methods = clazz.getMethods();

for (Method method : methods) {
boolean bl = method.isAnnotationPresent(MyAnnotation.class);
if(bl){
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
String run = annotation.myRun();
if(run.equals(“run”)){
String order = annotation.myOrder();
if(order.equals(“first”)){
tm.put(1, method);
}
if(order.equals(“second”)){
tm.put(2, method);
}
if(order.equals(“third”)){
tm.put(3, method);
}
if(order.equals(“forth”)){
tm.put(4, method);
}
}
}

}

Set<Entry<Integer,Method>> entrySet = tm.entrySet();
for (Entry<Integer, Method> entry : entrySet) {
Method method = entry.getValue();
method.invoke(obj);
}
}
}

例题:在集合中存储自定义类型,并排序

package pack01_kuozhan;

import java.util.Comparator;

public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return “Student [name=” + name + “, age=” + age + “]”;
}

}

package pack01_kuozhan;

import java.util.Comparator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class Demo05TreeMap {
public static void main(String[] args) {
TreeMap<Student,String> tm = new TreeMap<Student,String>(new Comparator<Student>() {

@Override
public int compare(Student o1, Student o2) {
return o1.getAge() – o2.getAge();
}
});

tm.put(new Student(“liutao”,32), “上海”);
tm.put(new Student(“liuyan”,35), “上海”);
tm.put(new Student(“abao”,33), “上海”);
tm.put(new Student(“shishi”,50), “上海”);

Set<Entry<Student, String>> entrySet = tm.entrySet();
for (Entry<Student, String> entry : entrySet) {
Student key = entry.getKey();
System.out.println(key);
}
}
}

package com.baidu_01;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test7 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student>();

list.add(new Student(“赵四12”,24));
list.add(new Student(“王五3”,21));
list.add(new Student(“李三456”,35));
list.add(new Student(“张二”,11));

/*Collections.sort(list, new Comparator<Student>() {

@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
return o1.getAge() – o2.getAge();
}
});*/

Collections.sort(list, new Comparator<Student>() {

@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
return o1.getName().length() – o2.getName().length();
}
});

System.out.println(list);

}
}

//扩展Timer类的使用

package com.baidu_02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

import javax.xml.crypto.Data;

public class Demo08Timer {
public static void main(String[] args) throws Exception {

Timer timer = new Timer();
//在指定的时间调用方法
//安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
//timer.schedule(new MyTask(), 1000, 2000);

//安排在指定的时间执行指定的任务。
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
Date data = sdf.parse(“2017-06-30 1:42:25”);
timer.schedule(new MyTask(), data);
}
}

class MyTask extends TimerTask {

@Override
public void run() {
// TODO Auto-generated method stub
//这里可以做一些事情,比如调用一些方法用于提醒,
System.out.println(“砰爆炸了!!!!!”);
}

}

扩展:进行小数相加的类

package pack01_kuozhan;

import java.math.BigDecimal;
import java.math.BigInteger;

public class Demo07Method {
public static void main(String[] args) {

double d1 = 0.01;
double d2 = 0.09;

double d3 = d1 + d2;

System.out.println(d3);

// ‘8’ + ‘9’
// ‘8’ – ‘0’ + (‘9’-‘0’)
System.out.println(“—————-“);
BigDecimal b1 = new BigDecimal(“0.039080396803968906803969”);
BigDecimal b2 = new BigDecimal(“0.090830648064064846068409”);

//进行小数相加的类

//相加
BigDecimal b3 = b1.add(b2);
//相乘
// BigDecimal b4 = b1.multiply(b2);
//相除
// BigDecimal b5 = b1.divide(b2);
System.out.println(b3);

System.out.println(“——————–“);
//可以进行超出long范围的加法运算
BigInteger bi1 = new BigInteger(“9068069804980694809489048904890484907”);
BigInteger bi2 = new BigInteger(“9068069804980694809489048904890484907”);

BigInteger bi3 = bi1.add(bi2);
System.out.println(bi3);
}
}

beans.xml

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans>
<bean className=”cn.baidu.demo.Student” methodName=”study”>
<property name=”name” value=”liutao”></property>
<property name=”age” value=”35″></property>
</bean>
</beans>

//1:创建cn.baidu.demo.Student类对象,调用study方法
//2:将变量name的值设为liutao
//3:判断study方式是否有注解，如果有，获取属性值

//对XML的增删改

package pack01_kuozhan;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/*
<persons>
<person id=”it001″>
<name>zhangsan</name>
</person>
</persons>

*/
public class Demo03XML {
public static void main(String[] args) throws DocumentException, IOException {

//代码生成xml
Document document = DocumentHelper.createDocument();

document.addElement(“root”);

//创建输出流
OutputStream os = new FileOutputStream(“root.xml”);
//获取输出的指定格式
OutputFormat format = OutputFormat.createPreetyPrint();

//设置编码,确保解析的xml为utf-8格式
format.setEncoding(“utf-8”);

//XMLWriter 指定输出文件以及格式
XMLWriter writer = new XMLWriter(os,format);
//把document写入xmlFile指定的文件(可以为被解析的文件或者新创建的文件)
writer.write(document);
writer.flush();
writer.close();

//SAXReader sr = new SAXReader();

//Document document = sr.read(“persons.xml”);

//获取根元素
//Element rootElement = document.getRootElement();

//————添加属性 —————————
// //获取person元素
// Element element = rootElement.element(“person”);
// //添加属性
// element.addAttribute(“attr”, “xxx”);

//————修改元素的文本值 —————————
// Element element = rootElement.element(“person”);
// Element element2 = element.element(“name”);
// element2.setText(“lisi”);

//————-添加元素—————————–
// Element addElement = rootElement.addElement(“worker”);
// addElement.setText(“gongren”);
// //把修改后的内存中xml写入文件

//————删除元素—————————–
Element element = rootElement.element(“worker”);
rootElement.remove(element);

OutputStream os= new FileOutputStream(“persons.xml”);//创建输出流
OutputFormat format = OutputFormat.createPrettyPrint(); //获取输出的指定格式

format.setEncoding(“UTF-8”);//设置编码，确保解析的xml为UTF-8格式

XMLWriter writer = new XMLWriter(os,format);//XMLWriter 指定输出文件以及格式
writer.write(document);//把document写入xmlFile指定的文件(可以为被解析的文件或者新创建的文件)
writer.flush();
writer.close();

}
}

//扩展:在数组中查找给出的数在数组中第几索引

package pack01_kuozhan;

import java.util.Arrays;

public class Demo06BirnarySearch {
public static int birnarySearch(int[] array, int value){
int low = 0;
int high = array.length – 1;

while(low <= high){
int mid = (low + high) / 2;
if(value > array[mid]){
low = mid + 1;
}else if(value < array[mid]){
high = mid – 1;
}else{
return mid;
}
}

return -1;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};

System.out.println(birnarySearch(array, 30));

}
}

扩展:
创建文档：
Document document=DocumentHelper.createDocument();//生成xml文件
Element students=document.addElement(“students”);//创建根元素

PreparedStatement pre=con.prepareStatement(“select * from student”); //查询语句
ResultSet rs=pre.executeQuery(); //查询输出
while(rs.next()){
Element student=students.addElement(“student”);//创建学生的子元素
Element id=student.addElement(“id”); //获取确定的值
id.setText(rs.getString(1)); //添加到xml中
Element name=student.addElement(“name”);
name.setText(rs.getString(2));
Element age=student.addElement(“age”);
age.setText(rs.getString(3));

OutputFormat format=OutputFormat.createPrettyPrint(); //输出方式

XMLWriter output=new XMLWriter(new FileOutputStream(“student.xml”),format); //写到文件中
output.write(document); //写入到文档中
output.close(); //关闭

解析：

SAXReader sax=new SAXReader(); //修改文件中的值
Document doc=null;
try {
doc=sax.read(new File(“student.xml”));//生成文件作为读取文件
} catch (DocumentException e) {
e.printStackTrace();
}
List list=doc.selectNodes(“//students/student”); //查找元素存到列表中
Iterator iter=list.iterator(); //使用遍历输出
while(iter.hasNext()){
Element id=(Element)iter.next(); //存到连接中
PreparedStatement pre1 = con.prepareStatement(“insert into emplement values (?,?,?)”);
pre1.setInt(1,Integer.parseInt(id.elementText(“id”))); //转换成int类型的数据
// id.elementText(“name”); //得到列名为name的数据
pre1.setString(2,id.elementText(“name”));
pre1.setInt(3,Integer.parseInt(id.elementText(“age”)));
pre1.executeUpdate(); //更新数据

}
OutputFormat opt=OutputFormat.createPrettyPrint(); //输出数据
XMLWriter outp;
outp=new XMLWriter(new FileWriter(new File(“emplement.xml”)),opt); //写到新文件中
outp.write(doc); //写进文件
outp.close();

XML中Schema与DTD相比， Schema的优势有哪些？

Schema的优点：

①．使用与XML相同的语法；

②．支持多种数据类型；

③．支持用户自定义数据类型；

④．支持名称空间。

BeanUtils工具类

package pack01_beanutils;

import java.lang.reflect.InvocationTargetException;

import org.apache.commons.beanutils.BeanUtils;

/*
* setProperty(Object obj,String name,Object value)
* 该方法给对象的成员变量赋值
* 参1：赋值的对象
* 参2：表示变量的名字
* 参3：要赋的值
*/
public class Demo01SetProperty {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException {

//1:创建User对象
User user = new User();

//2:调用工具类给对象成员赋值
BeanUtils.setProperty(user, “id”, “it001”); //id —>setId() —>
BeanUtils.setProperty(user, “username”, “lft”);
BeanUtils.setProperty(user, “password”, “123”);

System.out.println(user);
}
}

package pack01_beanutils;

import java.lang.reflect.InvocationTargetException;

import org.apache.commons.beanutils.BeanUtils;

/*
* getProperty(Object obj,String name)
* 从对象获取某个变量的值
* 参1：获取哪个对象的值
* 参2：变量的名字
*/
public class Demo02GetProperty {

public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

User user = new User(“it002”, “zhangsan”, “12345”);

//调用工具类获取变量的值
//该方法以后的用法是：获取网页表单中的数据
String id = BeanUtils.getProperty(user, “id”); //id —>getId();
String username = BeanUtils.getProperty(user, “username”); //id —>getUsername();
String password = BeanUtils.getProperty(user, “password”); //id —>getPassword();

System.out.println(id + ” ” + username + “\t” + password);
}

}

package pack02_beanutils;

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;

import org.apache.commons.beanutils.BeanUtils;

/*
* 该方法也是给变量赋值
* populate(Object bean, Map<String,String[]> properties)
* 参1：表示对象
* 参2：键：变量的名字值：变量的值，用数组表示，如果该变量不是数组，则会把 [0]赋值给变量
*/
public class Demo01Populate {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException {
User user = new User();

//定义map集合
HashMap<String, String[]> hm = new HashMap<String,String[]>();
//给map集合添加数据
hm.put(“id”, new String[]{“it001”});
hm.put(“username”, new String[]{“lft”});
hm.put(“password”, new String[]{“123”});
hm.put(“hobbies”, new String[]{“smokeing”,”girl”,”tableball”});
BeanUtils.populate(user, hm);
//setProperty()
System.out.println(user);
}
}

package com.baidu_01;

import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;

public class MyBeanUtils {
//方法的作用是为了获得一个类的对象,并且给这个类赋好了值
public static Object myPopulate(Class<?> clazz, Map<String,String[]> properties) {
Object bean = null;

try {
//替用户创建对象
bean = clazz.newInstance();
//给对象赋值
BeanUtils.populate(bean, properties);

}catch (Exception e) {
//将捕捉的编译时异常转为运行时异常
throw new RuntimeException();
}

//赋值之后应该把赋值之后的对象返回
return bean;

}
}

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans>
<bean className=”pack1.User”>
<property name=”username” value=”rose”></property>
<property name=”password” value=”123″></property>
</bean>

package pack03_test;

import java.util.List;

import org.apache.commons.beanutils.BeanUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class TestDemo {
public static void main(String[] args) throws Exception {
//1:解析XML
//1.1 创建SAXReader对象
SAXReader sr = new SAXReader();
//1.2 将xml读取到内存,得到document对象
Document document = sr.read(“data.xml”);
//1.3 获取根元素
Element rootElement = document.getRootElement();
//1.4获取根元素的子元素 bean
List<Element> elements = rootElement.elements();
for (Element element : elements) {
//1.5 获取bean的属性
String className = element.attributeValue(“className”);
//2:反射
//2.1通过类的全名获取Class对象
Class<?> clazz = Class.forName(className);
//2.2 创建类的对象
Object obj = clazz.newInstance();
//3:获取bean的子元素
List<Element> elements2 = element.elements();
for (Element element2 : elements2) {//property
//3.1 获取property的属性：name value
String name = element2.attributeValue(“name”);
String value = element2.attributeValue(“value”);
//将obj对象的name变量赋值为value
BeanUtils.setProperty(obj,name, value);
}
System.out.println(obj);
}
}
}