其他分享
首页 > 其他分享> > 14-XML和Dom4j、正则表达式

14-XML和Dom4j、正则表达式

作者：互联网

今日内容

第一章 XML

1.1 XML介绍

1.1 什么是XML

1.2 XML 与 HTML 的主要差异

1.3 xml的作用

1.2 XML组成元素

一个标准XML文件一般由以下几部分组成:文档声明、元素、属性、注释、转义字符、字符区。

注释
<!--注释内容-->
文档声明
<?xml version="1.0" encoding="utf-8" ?>

  1. 文档声明可以不写

  2. 文档声明必须为结束

  3. 文档声明必须从文档的1行1列位置开始

  4. 文档声明中常见的两个属性：

元素\标签

  1. 元素是XML中最重要的组成部分，元素也叫标签

  2. 标签分为开始标签和结束标签，开始标签<名字> 结束标签</名字>

  3. 开始标签和结束标签中间写的是标签内容，标签的内容可以是文本，也可以是其他标签

  4. 如果标签没有任何内容，那么可以定义空标签(比如：<名字/>)

  5. 标签可以嵌套,但是不能乱嵌套

  6. 一个XML文件只有一个根标签

  7. 命名规则：
    ​ 不要使用XML xML xml 写样的单词

    ​ 不能使用空格，冒号

    ​ 命名区分大小写

    数字不能开头

属性

  1. 位置: 属性是元素的一部分，它必须出现在元素的开始标签中,不能写在结束标签中

  2. 格式: 属性的定义格式：属性名=“属性值”，其中属性值必须使用单引或双引号括起来

  3. 一个元素可以有0~N个属性，但一个元素中不能出现同名属性

  4. 属性名不能使用空格 , 不要使用冒号等特殊字符，且必须以字母开头

转义字符

​ 因为有些特殊的字符在XML中是不会被识别的，所以在元素体或属性值中想使用这些符号就必须使用转义字符（也叫实体字符），例如：">"、"<"、"'"、"""、"&"。

1575987141428

注意：严格地讲，在 XML 中仅有字符 "<"和"&" 是非法的。省略号、引号和大于号是合法的，但是把它们替换为实体引用是个好的习惯。

转义字符应用示例：

<price> 苹果的价格: price > 5 &amp;&amp;  price &lt; 10</price>
字符区(了解)
综合案例
<?xml version="1.0" encoding="utf-8" ?>
<!--
    注释:
        添加和取消注释: ctrl+/  或者  ctrl+shift+/
        注释不能嵌套
-->
<!--
    文档声明:
        1.文档声明是以<?xml开头,以?>结尾
        2.文档声明可以有也可以没有
        3.如果有文档声明必须放在第1行第1列
        4.文档声明至少有2个属性:
            version:表示xml的版本号,必须要有,值一般是1.0
            encoding:表示xml文件的编码,默认是utf-8编码
-->
<!--
    元素:
        1.元素是xml的重要组成部分,元素也叫做标签
        2.标签分为开始标签和结束标签,开始标签: <标签名>  结束标签:</标签名>
        3.开始标签和结束标签中的内容叫做标签内容(标签体),标签内容可以是文本,也可以是其他标签
        4.标签是可以嵌套的,但不能乱嵌套
        5.开始标签和结束标签中可以没有内容,这种标签叫做空标签,空标签也可以这样表示:<标签名/>
        6.一个xml只能有一个根标签
        7.标签名必须符合命名规则和规范,不能以数字开头,不能有一些空格或者其他特殊符号
-->
<!--
    属性:
        1.属性是标签的重要组成部分,必须定义在开始标签中,不能定义在结束标签中
        2.定义属性的格式: 属性名="属性值",注意属性值必须使用引号引起来(单引号或者双引号)
        3.一个标签可以定义0-N个属性,但一个标签中不能有同名的属性
        4.属性名必须符合命名规则和规范,不能以数字开头,不能有一些空格或者其他特殊符号
-->
<!--
    转义字符:
        	因为有些特殊的字符在XML中是不会被识别的，
        	所以在元素体或属性值中想使用这些符号就必须使用转义字符（也叫实体字符），例如：">"、"<"、"'"、"""、"&"。
-->
<!--
    字符区:
        CDATA 内部的所有东西都会被解析器忽略,当做文本
        快捷键CD
        格式: <![CDATA[ ]]>
-->
<persons>
    <person>
        <name>itheima</name>
        <age>100</age>
    </person>
    <!--空标签-->
    <person name="传智播客" age='18'></person>
    <person/>
    <!--转义字符-->
    <price>价格 > 50  &amp;&amp; 价格 &lt; 100</price>
    <!--字符区-->
    <![CDATA[
            <price>价格 > 50  && 价格 < 100</price>
    ]]>
</persons>

1.3 XML文件的约束-DTD约束(了解)

xml约束概述

根据DTD约束写XML

语法(了解)

文档声明(了解)

  1. 内部DTD，在XML文档内部嵌入DTD，只对当前XML有效。

    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE 根元素 [元素声明]>><!--内部DTD-->

  2. 外部DTD—本地DTD，DTD文档在本地系统上，企业内部自己项目使用。

    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE 根元素 SYSTEM "文件名"><!--外部本地DTD-->

  3. 外部DTD—公共DTD，DTD文档在网络上，一般都有框架提供 , 也是我们使用最多的.

    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文档的URL">

例如: <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
元素声明(了解)

  1. 约束元素的嵌套层级

    语法

    <!ELEMENT 父标签 （子标签…）>
例如:
<!ELEMENT books (book+)> <!--约束根元素是"books"，"books"子元素为"book"，“+”为数量词-->
<!ELEMENT book (name,author,price)><!--约束"book"子元素依次为“name”、“author”、“price”，-->

  2. 约束元素体里面的数据

    语法

    <!ELEMENT 标签名字 标签类型>
例如 <!ELEMENT name (#PCDATA)>

    标签类型: EMPTY(即空元素，例如<hr/>) ANY(任意类型) (#PCDATA) 字符串数据

    代码

    <!ELEMENT name (#PCDATA)>
<!ELEMENT author (#PCDATA)>
<!ELEMENT price (#PCDATA)>

  3. 数量词(掌握)

    数量词符号 含义
    * 表示元素可以出现0到多个
    + 表示元素可以出现至少1个
    ? 表示元素可以是0或1个
    , 表示元素需要按照顺序显示
    | 表示元素需要选择其中的某一个
属性声明(了解)

语法

<!ATTLIST 标签名称 
		属性名称1 属性类型1 属性说明1
		属性名称2 属性类型2 属性说明2
		…
>
例如
<!ATTLIST book bid ID #REQUIRED>

属性类型

属性说明:

属性说明

代码

<!ATTLIST 书									<!--设置"书"元素的的属性列表-->
		id ID #REQUIRED						 <!--"id"属性值为必须有-->
		编号 CDATA #IMPLIED				    <!--"编号"属性可有可无-->
		出版社 (清华|北大|传智播客) "传智播客"   <!--"出版社"属性值是枚举值，默认为“传智播客”-->
		type CDATA #FIXED "IT"                <!--"type"属性为文本字符串并且固定值为"IT"-->
>
案例
<?xml version = "1.0" encoding="GB2312" standalone="yes"?>
<!DOCTYPE 购物篮 [
        <!ELEMENT 购物篮 (肉+)>
        <!ELEMENT 肉 EMPTY>
        <!ATTLIST 肉 品种 ( 鸡肉 | 牛肉 | 猪肉 | 鱼肉 ) "鸡肉">
        ]>
<购物篮>
    <肉 品种="牛肉"></肉>
    <肉/>
</购物篮>

1.4 schema约束(了解)

概念

schema和DTD一样, 也是一种XML文件的约束.

Schema 语言也可作为 XSD（XML Schema Definition）。

Schema约束的文件的后缀名.xsd

Schema 功能更强大，数据类型约束更完善。

根据schema约束写出xml文档

第二章 Dom4j

2.1 XML解析

解析方式

解析包

2.2 Dom4j的基本使用 重点掌握

2.2.1 DOM解析原理及结构模型

2.2.2 使用步骤

  1. 导入jar包 dom4j-1.6.1j.jar
  2. 创建解析器对象
  3. 使用解析器对象读取xml文件,生成Document对象
  4. 根据Document对象获得根元素
  5. 根据根元素获取对于的子元素或者属性
  6. .....

2.2.3 常用的方法

1.创建解析器对象: SAXReader sr = new SAXReader();
2.读取xml文件进行解析,生成Document对象---使用SAXReader方法
    Document read(String fileName);
3.使用Document对象获取根元素
    Element getRootElement();
4.使用元素获取子元素--->使用Element方法
    public List elements()     				: 获取当前元素的所有子元素
    public String getName()					: 获取元素的元素名
    public String getText()					: 获取当前元素的文本值
    public String attributeValue(String name)	: 获取当前元素下某个属性的值,传入属性名
    public Element element(String name)		: 根据元素名获取指定子元素(如果有多个就获取到第一个)
    public String elementText(String name)	: 获取指定子元素的文本值,参数是子元素名称

2.2.4 方法演示


/**
 * Created by PengZhiLin on 2021/8/16 11:40
 */
public class Test {
    public static void main(String[] args) throws Exception{
        // 1.创建解析器对象
        SAXReader sr = new SAXReader();

        // 2.使用解析器对象读xml文件,生成Document对象
        Document document = sr.read("day14\\book.xml");

        // 3.使用Document对象获得根标签
        Element rootE = document.getRootElement();

        // 4.使用根标签获取子标签
        List<Element> list = rootE.elements();

        // 5.循环遍历list集合
        for (Element e : list) {
            System.out.println("books根标签的子标签名:"+e.getName());
            System.out.println("books根标签的子标签的id属性值:"+e.attributeValue("id"));
            // 获取book标签下的所有子标签
            List<Element> list2 = e.elements();
            // 循环遍历book标签下的所有子标签
            for (Element e2 : list2) {
                System.out.println("book标签下的子标签名:"+e2.getName());
                System.out.println("book标签下的子标签的文本:"+e2.getText());
            }
            // 获取book标签下的author标签的文本
            Element authorE = e.element("author");
            System.out.println(authorE.getName()+","+authorE.getText());

            // 获取book标签下的author标签的文本
            String authorText = e.elementText("author");
            System.out.println("作者的文本:"+authorText);

            System.out.println("--------------");
        }
    }
}

2.3 Dom4J结合XPath解析XML

2.3.1 介绍

​ XPath 使用路径表达式来选取HTML\XML 文档中的元素节点或属性节点。节点是通过沿着路径 (path) 来选取的。XPath在解析HTML\XML文档方面提供了独树一帜的路径思想。

说白了就是用来表示xml文件中标签或者属性的路径

2.3.2 XPath使用步骤

步骤1：导入jar包(dom4j和jaxen-1.1-beta-6.jar)

步骤2：通过dom4j的SaxReader解析器对象,读xml文件,生成Document对象

步骤3： 利用Xpath提供的api,对XML文档中的标签或者属性进行解析操作。

document常用的api

2.3.3 XPath语法(了解)

2.3.3.1 绝对路径表达式(了解)
2.3.3.2 相对路径表达式(了解)
2.3.3.3 全文搜索路径表达式(了解)
2.3.3.4 谓语（条件筛选 了解）

第三章 正则表达式

3.1 正则表达式的概念及演示

3.2 正则表达式的基本使用

3.2.1 正则表达式-字符类

public class Test1_字符类 {
    public static void main(String[] args) {
          /*
            正则表达式-字符类
                - 语法示例：[] 表示匹配单个字符   ^ 取反    - 范围
                  1. [abc]：代表a或者b，或者c字符中的一个。
                  2. [^abc]：代表除a,b,c以外的任何字符。
                  3. [a-z]：代表a-z的所有小写字符中的一个。 左右包含
                  4. [A-Z]：代表A-Z的所有大写字符中的一个。
                  5. [0-9]：代表0-9之间的某一个数字字符。
                  6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
                  7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。
         */
        // 需求:
        // 1.验证字符串是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
        System.out.println("had".matches("h[aeiou]d"));// true
        System.out.println("hmd".matches("h[aeiou]d"));// false
        System.out.println("ham".matches("h[aeiou]d"));// false
        System.out.println("haed".matches("h[aeiou]d"));// false
        System.out.println("---------------");

        // 2.验证字符串是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
        System.out.println("had".matches("h[^aeiou]d"));// false
        System.out.println("hmd".matches("h[^aeiou]d"));// true
        System.out.println("ham".matches("h[^aeiou]d"));// false
        System.out.println("haed".matches("h[^aeiou]d"));// false
        System.out.println("---------------");

        // 3.验证字符串是否a-z的任何一个小写字符开头，后跟ad
        System.out.println("aad".matches("[a-z]ad"));// true
        System.out.println("1ad".matches("[a-z]ad"));// false
        System.out.println("abad".matches("[a-z]ad"));// false
        System.out.println("---------------");

        // 4.验证字符串是否以a-d或者m-p之间某个字符开头，后跟ad
        System.out.println("aad".matches("[a-dm-p]ad"));// true
        System.out.println("had".matches("[a-dm-p]ad"));// false
        System.out.println("mad".matches("[a-dm-p]ad"));// true
    }
}

3.2.2 正则表达式-逻辑运算符

/**
 * Created by PengZhiLin on 2021/8/16 14:49
 */
public class Test2_逻辑运算符 {
    public static void main(String[] args) {
        /*
            1. &&：并且
            2. | ：或者
         */
        // 需求:
        //1.要求字符串是小写辅音字符开头，后跟ad  除了a,e,i,o,u之外,其他的都是辅音字母
        System.out.println("bad".matches("[a-z&&[^aeiou]]ad"));// true
        System.out.println("aad".matches("[a-z&&[^aeiou]]ad"));// false
        System.out.println("%ad".matches("[a-z&&[^aeiou]]ad"));// false
        System.out.println("-----------");

        //2.要求字符串是aeiou中的某个字符开头，后跟ad
        System.out.println("bad".matches("[a|e|i|o|u]ad"));// false
        System.out.println("aad".matches("[a|e|i|o|u]ad"));// true
        System.out.println("%ad".matches("[a|e|i|o|u]ad"));// false
    }
}

3.2.3 正则表达式-预定义字符

public class Test3_预定义字符 {
    public static void main(String[] args) {
        /*
            正则表达式-预定义字符
                - 语法示例：
                  1. "." ： 匹配任何字符。如果要表示一个字符点,那么就得使用\.
                  2. "\d"：任何数字[0-9]的简写；
                  3. "\D"：任何非数字[^0-9]的简写；
                  4. "\s"： 空白字符：[ \t\n\x0B\f\r] 的简写
                  5. "\S"： 非空白字符：[^\s] 的简写
                  6. "\w"：单词字符：[a-zA-Z_0-9]的简写
                  7. "\W"：非单词字符：[^\w]
         */
        // 需求:
        // 1.验证字符串是否是3位数字
        System.out.println("023".matches("\\d\\d\\d"));// true
        System.out.println("123".matches("\\d\\d\\d"));// true
        System.out.println("1a3".matches("\\d\\d\\d"));// false
        System.out.println("1234".matches("\\d\\d\\d"));// false
        System.out.println("-----------");

        // 2.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
        System.out.println("13866668888".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// true
        System.out.println("1386666888".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// false
        System.out.println("138666688889".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// false
        System.out.println("17866668888".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// false
        System.out.println("27866668888".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// false
        System.out.println("-----------");

        // 3.验证字符串是否以h开头，以d结尾，中间是任何字符
        System.out.println("had".matches("h.d"));// true
        System.out.println("h%d".matches("h.d"));// true
        System.out.println("h.d".matches("h.d"));// true
        System.out.println("haad".matches("h.d"));// false
        System.out.println("----------");

        // 4.验证str是否是：h.d
        System.out.println("had".matches("h\\.d"));// false
        System.out.println("h%d".matches("h\\.d"));// false
        System.out.println("h.d".matches("h\\.d"));// true
        System.out.println("haad".matches("h\\.d"));// false
        System.out.println("----------");

    }
}

3.2.4 正则表达式-数量词

public class Test4_数量词 {
    public static void main(String[] args) {
         /*
            正则表达式-数量词
            - 语法示例：
              1. X? : 0次或1次
              2. X* : 0次到多次
              3. X+ : 1次或多次
              4. X{n} : 恰好n次
              5. X{n,} : 至少n次
              6. X{n,m}: n到m次(n和m都是包含的)
         */
          // 需求:
        // 1.验证字符串是否是3位数字
        System.out.println("023".matches("\\d{3}"));// true
        System.out.println("123".matches("\\d{3}"));// true
        System.out.println("1a3".matches("\\d{3}"));// false
        System.out.println("1234".matches("\\d{3}"));// false
        System.out.println("-----------");


        // 2.验证str是否是多位数字
        System.out.println("1".matches("\\d+"));// true
        System.out.println("12".matches("\\d+"));// true
        System.out.println("123".matches("\\d+"));// true
        System.out.println("1234".matches("\\d+"));// true
        System.out.println("1234a".matches("\\d+"));// false
        System.out.println("-----------");

        // 3.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
        System.out.println("13866668888".matches("1[358]\\d{9}"));// true
        System.out.println("1386666888".matches("1[358]\\d{9}"));// false
        System.out.println("138666688889".matches("1[358]\\d{9}"));// false
        System.out.println("17866668888".matches("1[358]\\d{9}"));// false
        System.out.println("27866668888".matches("1[358]\\d{9}"));// false
        System.out.println("-----------");

        // 4.验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
        System.out.println("12345678".matches("[1-9]\\d{4,14}"));// true
        System.out.println("123a5678".matches("[1-9]\\d{4,14}"));//false
        System.out.println("1234".matches("[1-9]\\d{4,14}"));// false
        System.out.println("0234567".matches("[1-9]\\d{4,14}"));// false


    }
}

3.2.5 正则表达式-分组括号( )


/**
 * Created by PengZhiLin on 2021/8/16 15:07
 */
public class Test5_分组括号 {
    public static void main(String[] args) {
        /*
            分组括号: ()
            使用:格式相同的就分为一组
         */
        String str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";
        System.out.println(str.matches("([A-Z0-9]{5}-){4}[A-Z0-9]{5}"));// true
        System.out.println("---------------");

        // 叠词aabb格式: 高高兴兴,快快乐乐,开开心心...
        // (.)\\1{1}(.)\\2{1}   \\1表示第一组   \\2表示第二组
        // (.)\\1(.)\\2   \\1表示第一组   \\2表示第二组
        System.out.println("高高兴兴".matches("(.)\\1(.)\\2"));// true
        System.out.println("快快乐乐".matches("(.)\\1(.)\\2"));// true
        System.out.println("开开心心".matches("(.)\\1(.)\\2"));// true
        System.out.println("abcd".matches("(.)\\1(.)\\2"));// false
        System.out.println("---------------");

        // 叠词aabbcc格式: 呵呵哈哈嘿嘿,...
        System.out.println("呵呵哈哈嘿嘿".matches("(.)\\1(.)\\2(.)\\3"));// true
        System.out.println("abcdef".matches("(.)\\1(.)\\2(.)\\3"));// false
        System.out.println("---------------");


        // 叠词aaabbb格式: 呵呵呵嘿嘿嘿,...
        System.out.println("呵呵呵嘿嘿嘿".matches("(.)\\1{2}(.)\\2{2}"));// true
        System.out.println("abcdef".matches("(.)\\1(.)\\2"));// false
        System.out.println("---------------");

        // 叠词abab格式: 开心开心,高兴高兴,哟西哟西,...
        System.out.println("开心开心".matches("(..)\\1"));// true
        System.out.println("高兴高兴".matches("(..)\\1"));// true
        System.out.println("哟西哟西".matches("(..)\\1"));// true
        System.out.println("abcd".matches("(..)\\1"));// false
    }
}

3.3 String中正则表达式的使用

3.3.1 String的split方法中使用正则表达式

3.3.2 String类的replaceAll方法中使用正则表达式

public String replaceAll(String regex,String newStr)//参数regex就是一个正则表达式。可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。

总结

必须练习:
	1.定义XML文件----XML的组成元素(文档声明,标签,属性,注释,转义字符,字符区)
    2.使用Dom4j解析XML文件---结合XPATH路径
    3.有时间的话分析分析正则表达式,写点简单的正则表达---目的是为了能看懂正则表达式
      String类中使用正则表达式--->matches,split,replaceAll
        
- 能够说出XML的作用
   1.作为配置文件=----框架阶段
   2.存储数据,传输数据
        
- 了解XML的组成元素
   文档声明,标签,属性,注释,转义字符,字符区 
        
- 能够说出有哪些XML约束技术
   dtd,schema
        
- 能够说出解析XML文档DOM方式原理
   解析器-->读取xml文档--->Document对象
        
- 能够使用dom4j解析XML文档
   1.导入dom4j的jar包
   2.把jar包添加到classpath路径中
   3.创建解析器对象
   4.使用解析器对象读取xml文件,生成Document对象
   5.使用Document对象获取根标签
   6.使用根标签获取子标签,....
        
- 能够使用xpath解析XML
   1.导入dom4j和xpath的jar包
   2.把jar包添加到classpath路径中
   3.创建解析器对象
   4.使用解析器对象读取xml文件,生成Document对象
   5.使用Document对象结合xpath路径获取指定标签
        
- 能够理解正则表达式的作用
    作为匹配规则,替换复杂的if判断操作
        
- 能够使用正则表达式的字符类
   [] 表示匹配单个字符,^表示取反,-表示范围
    	1. [abc]：代表a或者b，或者c字符中的一个。
        2. [^abc]：代表除a,b,c以外的任何字符。
        3. [a-z]：代表a-z的所有小写字符中的一个。 左右包含
        4. [A-Z]：代表A-Z的所有大写字符中的一个。
        5. [0-9]：代表0-9之间的某一个数字字符。
        6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
        7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。   
       
- 能够使用正则表达式的逻辑运算符
   && 并且
   |  或者
        
- 能够使用正则表达式的预定义字符类
   		1. "." ： 匹配任何字符。如果要表示一个字符点,那么就得使用\.
        2. "\d"：任何数字[0-9]的简写；
        3. "\D"：任何非数字[^0-9]的简写；
        4. "\s"： 空白字符：[ \t\n\x0B\f\r] 的简写
        5. "\S"： 非空白字符：[^\s] 的简写
        6. "\w"：单词字符：[a-zA-Z_0-9]的简写
        7. "\W"：非单词字符：[^\w]
        
- 能够使用正则表达式的数量词
   		1. X? : 0次或1次
        2. X* : 0次到多次
        3. X+ : 1次或多次
        4. X{n} : 恰好n次
        5. X{n,} : 至少n次
        6. X{n,m}: n到m次(n和m都是包含的)  
        
- 能够使用正则表达式的分组
     ()
- 能够在String的split方法中使用正则表达式
   String[] split(String regex);
   boolean matches(String regex);
   String replaceAll(String regex,String newStr)

标签：XML,14,Dom4j,matches,System,String,println,out
来源： https://www.cnblogs.com/ofanimon/p/16188331.html