java基础第十九篇之Xml

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>

<student id="i002">

<name>lisi</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文档结构所使用，所以在元素体或属性值中想使用这些符号就必须使用转义字符，例如：“<”、“>”、“’”、“””、“&”。

< --> &lt;

> --> &gt;

" --> &quot;

' --> &apos;

& --> &amp

2.5 CDATA区

<![CDATA[

任意内容

]]>

当你的标签内容有大量的转义字符时，则可以使用CDATA区，一次性全部转义

例题:

<?xml version="1.0" encoding="UTF-8"?>

<hello>a &lt; b  c &gt; d

<![CDATA[

<student stuid="it002">

<name>lisi</name>

<age>20</age>

</student>

]]>

</hello>

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"?>

<student xmlns="http://www.baidu.cn/bean"

    xmlns:bz="http://www.bz.cn/bz"

xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"

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

  http://www.bz.cn/bz bz.xsd

  "

></student>

"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;

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();

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>


    <bean className="pack2.Person">

      <property name="name" value="jack"></property>

      <property name="age" value="22"></property>

    </bean>

</beans>

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);

}

}

}

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 211,948评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,371评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,490评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,521评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,627评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,842评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,997评论 3赞 408
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,741评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,203评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,534评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,673评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,339评论 4赞 330
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,955评论 3赞 313
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,770评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,000评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,394评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,562评论 2赞 349

推荐阅读更多精彩内容

  • Java面试
    一. Java基础部分.................................................
    wy_sure阅读 3,805评论 0赞 11
  • 2018-06-11
    mean to add the formatted="false" attribute?.[ 46% 47325/...
    ProZoom阅读 2,694评论 0赞 3
  • 无标题文章
    JAVA面试题 1、作用域public,private,protected,以及不写时的区别答：区别如下：作用域 ...
    JA尐白阅读 1,146评论 1赞 0
  • JAVA面试题集收藏大放送
    小编费力收集：给你想要的面试集合 1.C++或Java中的异常处理机制的简单原理和应用。 当JAVA程序违反了JA...
    八爷君阅读 4,578评论 1赞 114
  • spring源码解析记录1
    org.springframework.beans： org.springframework.beans.fact...
    过河卒sc阅读 584评论 1赞 1