Xml和正则表达式

最新推荐文章于 2023-05-18 17:57:39 发布
最新推荐文章于 2023-05-18 17:57:39 发布
阅读量1.4k 收藏 8
点赞数
分类专栏： 笔记 文章标签： 正则表达式 xml html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44794280/article/details/119967657
版权

【XML和Dom4j、正则表达式】

  • XML------->重点\掌握
    • 如何编写xml
    • 如何解析xml
  • 正则表达式 ---->理解
    • 掌握正则表达式组成元素

目标

  • 能够说出XML的作用

  • 了解XML的组成元素

  • 能够说出有哪些XML约束技术

  • 能够说出解析XML文档DOM方式原理

  • 能够使用dom4j解析XML文档

  • 能够使用xpath解析XML

  • 能够理解正则表达式的作用

  • 能够使用正则表达式的字符类

  • 能够使用正则表达式的逻辑运算符

  • 能够使用正则表达式的预定义字符类

  • 能够使用正则表达式的数量词

  • 能够使用正则表达式的分组

  • 能够在String的split方法中使用正则表达式

第一章 XML

知识点 - 1.1 XML介绍

目标

  • 了解xml的概述和作用

路径

  • 什么是XML
  • XML 与 HTML 的主要差异
  • XML的作用

讲解

1.1 什么是XML

  • XML 指可扩展标记语言（EXtensible Markup Language）

  • XML是用来传输数据的，不是用来显示数据的。之后学习另外一个HTML是用来显示数据的。

  • XML 标签没有被预定义。您需要自行定义标签。

  • XML 是 W3C 的推荐标准

    W3C在1988年2月发布1.0版本，2004年2月又发布1.1版本，但因为1.1版本不能向下兼容1.0版本，所以1.1没有人用。同时，在2004年2月W3C又发布了1.0版本的第三版。我们要学习的还是1.0版本。

1.2 XML 与 HTML 的主要差异
  • html语法松散,xml语法严格,区分大小写
  • html做页面展示,xml传输数据
  • html所有标签都是预定义的,xml所有标签都是自定义的
1.3 xml的作用

  • 作为配置文件。 javaee框架 ssm大部分都会使用xml作为配置文件

  • XML可以存储数据 , 作为数据交换的载体(使用XML格式进行数据的传输)。

小结

略

知识点 - 1.2 XML组成元素-重点

目标

  • 我们知道了XML是什么, 接下来我们来了解一下XML它是由什么组成的.

路径

  • XML的组成元素

讲解

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

文档声明
<?xml version="1.0" encoding="utf-8" ?>

  1. 文档声明可以不写

  2. 文档声明必须为<?xml开头，以？>结束

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

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

  • version：指定XML文档版本。必须属性，这里一般选择1.0；
  • enconding：指定当前文档的编码，可选属性，默认值是utf-8；
注释
<!--注释内容-->
  • XML的注释，既以<!--开始，-->结束。
  • 注释不能嵌套
  • idea上快捷键：ctrl + /
元素\标签

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

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

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

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

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

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

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

    ​ 不能使用空格，冒号

    ​ 命名区分大小写

    数字不能开头

    <?xml version="1.0" encoding="UTF-8" ?>
<person>
    <name></name>
    <age></age>
    <aaa/>
</person>
属性

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

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

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

  4. 属性名必须符合标识符命名规范和规则

转义字符

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wy6X2FzZ-1630141592573)(img\1575987141428.png)]

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

转义字符应用示例：

<price> 苹果的价格: price > 5 &amp;&amp;  price &lt; 10</price>
字符区(了解)
  • CDATA 内部的所有东西都会被解析器忽略,当做文本
<![CDATA[
	文本数据
]]>
快捷键:CD
<!--写步骤 -->
<>
<!>
<![]>
<![CDATA]>
<![CDATA[ 文本 ]]>

<!-- 案例 -->
 <price>
        <![CDATA[
            苹果的价格: price > 5 &&  price < 10
        ]]>
 </price>

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

目标

  • 能够根据DTD约束正确书写xml

路径

  • 概念
  • 根据DTD约束正确书写XML

讲解

xml约束概述
  • 在XML技术里，可以编写一个文档来约束一个XML文档的书写规范，这称之为XML约束。
  • 约束文档定义了在XML中允许出现的元素(标签)名称、属性及元素(标签)出现的顺序等等。
  • 两种约束：DTD约束(文件后缀为dtd)，Schema约束(文件后缀为xsd)
  • 注意: 约束不是我们要写的东西，我们的工作是根据约束去写XML
根据DTD约束写XML
  • DTD约束文档
<?xml version="1.0" encoding="UTF-8" ?>
<!--
    复制内容如下到XML文件中:
        <!DOCTYPE 书架 SYSTEM "bookdtd.dtd">

-->
<!--
xml文件中引入dtd约束文档:
    方式一:外部本地DTD,DTD文档在本地,dtd约束文档和xml文档在同一路径下
         <!DOCTYPE 根元素 SYSTEM "文件名">
    方式二:外部本地DTD,DTD文档在网络上
        <!DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文档的URL">\
    方式三:内部DTD，在XML文档内部嵌入DTD，只对当前XML有效。
        <?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE 根元素 [元素声明]>
-->
<!--
对标签层级关系的约束:
    格式:<!ELEMENT 标签名 (子标签,子标签,...)>
数量词:
    * 表示元素可以出现0到多个
    + 表示元素可以出现至少1个
    ? 表示元素可以是0或1个
    , 表示元素需要按照顺序显示
    | 表示元素需要选择其中的某一个
-->
<!--
对标签的约束:
    格式:<!ELEMENT 标签名  标签类型>
    标签类型: EMPTY(即空元素，例如<hr/>) ANY(任意类型) (#PCDATA)  字符串数据
-->
<!--
对属性的约束:
   格式:
        <!ATTLIST 标签名
            属性名 属性类型 属性约束
            属性名 属性类型 属性约束
            ...
         >
   解释:
        属性类型:
            CDATA :表示文本字符串
            ID:表示属性值唯一,不能以数字开头
            ENUMERATED (DTD没有此关键字)：表示枚举，只能从枚举列表中任选其一，如(鸡肉|牛肉|猪肉|鱼肉)

        属性约束:
            REQUIRED：表示该属性必须出现
            IMPLIED：表示该属性可有可无
            FIXED:表示属性的取值为一个固定值。语法：#FIXED "固定值"

-->

<!--根标签名为书架,书架标签下至少有一个书标签  +表示至少出现一次-->
<!ELEMENT 书架 (书+)>
<!--书标签下,包含书名,做做,售价三个子标签,并且必须按照这个顺序出现-->
<!ELEMENT 书 (书名,作者,售价)>
<!--书名标签中的内容是文本数据-->
<!ELEMENT 书名 (#PCDATA)>
<!--作者标签中的内容是文本数据-->
<!ELEMENT 作者 (#PCDATA)>
<!--售价标签中的内容是文本数据-->
<!ELEMENT 售价 (#PCDATA)>
<!--
    对书标签中的属性进行约束:
    书标签中有一个id属性,类型为ID类型,也就是说该属性值要唯一,不能以数字开头,约束是必须出现
    书标签中有一个编号属性,类型是CDATA类型,也就是字符串类型,约束是可有可无
    书标签中有一个出版社属性,类型是枚举类型,也就是说该属性值只能在枚举值中任选一个,默认值为传智播客
    书标签中有一个type属性,类型为CDATA类型,也就是字符串类型,固定值为IT
-->
<!ATTLIST 书
        id ID #REQUIRED
        编号 CDATA #IMPLIED
        出版社 (清华|北大|传智播客) "传智播客"
        type CDATA #FIXED "IT"
        >

  • XML

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE 书架 SYSTEM "bookdtd.dtd">
<书架>
    <书 id="a1" 编号="001" 出版社="清华" type="IT">
        <书名>斗罗大陆</书名>
        <作者>唐家三少</作者>
        <售价>99.8</售价>
    </书>
    <书 id="a2">
        <书名>java从入门到放弃</书名>
        <作者>无名氏</作者>
        <售价>9.8</售价>
    </书>
</书架>
语法(了解)
文档声明(了解)

  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 父标签 （子标签1，子标签2，…）>
例如:
<!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>

属性类型

  • CDATA :表示文本字符串
  • ID:表示属性值唯一,不能以数字开头
  • ENUMERATED (DTD没有此关键字)：表示枚举，只能从枚举列表中任选其一，如(鸡肉|牛肉|猪肉|鱼肉)

属性说明:

  • REQUIRED：表示该属性必须出现
  • IMPLIED：表示该属性可有可无
  • FIXED:表示属性的取值为一个固定值。语法：#FIXED “固定值”

属性说明

代码

<!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约束写出xml文档

路径

  • 概念
  • 根据schema约束写出xml文档

讲解

概念

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

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

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

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

根据schema约束写出xml文档

  • Schema约束文档:

    <?xml version="1.0" encoding="UTF-8" ?>
<!--    传智播客教学实例文档.将注释中的以下内容复制到要编写的xml的声明下面
复制内容如下到XML文件中:
<书架 xmlns="http://www.itcast.cn"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.itcast.cn bookSchema.xsd" >
-->
<xs:schema
        xmlns:xs="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.itcast.cn"
        elementFormDefault="qualified">

    <!--element表示元素,也就是对元素进行约束-->
    <!--根标签的名称为书架-->
    <xs:element name='书架'>
        <!--complexType:表示标签是一个复杂标签-->
        <!--书架是一个复杂标签-->
        <xs:complexType>
            <!--sequence表示要按照顺序出现,maxOccurs最多出现多少次,unbounded无数次,minOccurs:最少出现多少次-->
            <!--书架标签的子标签必须按照顺序出现,最多出现2次,最少出现1次-->
            <xs:sequence maxOccurs="2" minOccurs="1">
                <!--书架的子标签的名称为书-->
                <xs:element name='书'>
                    <!--书标签是一个复杂标签-->
                    <xs:complexType>
                        <!--书标签的子标签必须按照顺序出现-->
                        <xs:sequence>
                           <!--书标签的子标签名为书名,类型为string-->
                           <!--书标签的子标签名为作者,类型为string-->
                           <!--书标签的子标签名为售价,类型为double-->
                            <xs:element name='书名' type='xs:string'/>
                            <xs:element name='作者' type='xs:string'/>
                            <xs:element name='售价' type='xs:double'/>
                        </xs:sequence>
                        <!--attribute表示属性,也就是对属性的元约束,optional:表示可选的,required:表示必须的-->
                        <!--书标签有一个bid属性,类型为int类型,是可选-->
                        <xs:attribute name="bid" type="xs:int" use="optional"/>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

  • 根据上面的Schema约束编写XML

    • 声明方式

      <书架 xmlns="http://www.itcast.cn"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.itcast.cn bookSchema.xsd" >

    • 案例1

      <?xml version="1.0" encoding="UTF-8" ?>
<书架 xmlns="http://www.itcast.cn"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.itcast.cn bookSchema.xsd" >
    <书 bid="1">
        <书名>斗罗大陆</书名>
        <作者>唐家三少</作者>
        <售价>99.8</售价>
    </书>
</书架>

    • 案例2

      <?xml version="1.0" encoding="UTF-8" ?>
<a:书架 xmlns:a="http://www.itcast.cn"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.itcast.cn bookSchema.xsd" >
    <a:书 bid="1">
        <a:书名>斗罗大陆</a:书名>
        <a:作者>唐家三少</a:作者>
        <a:售价>99.8</a:售价>
    </a:书>
</a:书架>

小结

第二章 Dom4j

知识点 - 2.1 XML解析

目标

  • 了解XML的解析方式和解析包

路径

  • 解析方式
  • 解析包

讲解

解析方式

  • 开发中比较常见的解析方式有三种，如下：

    1. DOM：要求解析器把整个XML文档装载到内存，并解析成一个Document对象

      a）优点：元素与元素之间保留结构关系，故可以进行增删改查操作。

      b）缺点：XML文档过大，可能出现内存溢出

    2. SAX：是一种速度更快，更有效的方法。她逐行扫描文档，一边扫描一边解析。并以事件驱动的方式进行具体解析，每执行一行，都触发对应的事件。（了解）

      a）优点：不会出现内存问题，可以处理大文件

      b）缺点：只能读，不能回写。

    3. PULL：Android内置的XML解析方式，类似SAX。（了解）

  • 解析器，就是根据不同的解析方式提供具体实现。有的解析器操作过于繁琐，为了方便开发人员，有提供易于操作的解析开发包

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-foJuDgiC-1630141592580)(img/13.png)]

解析包
  • JAXP：sun公司提供支持DOM和SAX开发包
  • Dom4j: 比较简单的的解析开发包(常用),
  • JDom：与Dom4j类似
  • Jsoup：功能强大DOM方式的XML解析开发包，尤其对HTML解析更加方便(项目中讲解)

小结

  • 略

知识点 - 2.2 Dom4j的基本使用

目标

  • 知道了什么是XML的解析, 那么接下来我们来学习一个最为简单常见的解析开发包 - Dom4j

路径

  • DOM解析原理及结构模型
  • 使用步骤
  • 常用的方法
  • 方法演示

讲解

2.2.1 DOM解析原理及结构模型

  • 解析原理

    XML DOM 和 HTML DOM一样，XML DOM 将整个XML文档加载到内存，生成一个DOM树，并获得一个Document对象，通过Document对象就可以对DOM进行操作。以下面books.xml文档为例。

    <?xml version="1.0" encoding="UTF-8"?>
<books>
    <book id="0001">
        <name>JavaWeb开发教程</name>
        <author>张孝祥</author>
        <sale>100.00元</sale>
    </book>
    <book id="0002">
        <name>三国演义</name>
        <author>罗贯中</author>
        <sale>100.00元</sale>
    </book>
</books>

  • 结构模型

2.2.2 使用步骤
  1. 导入jar包 dom4j-1.6.1j.jar
  2. 创建解析器
  3. 读取xml 获得document对象
  4. 得到根元素
  5. 根据根元素获取对于的子元素或者属性
2.2.3 常用的方法
创建解析器对象：
	SAXReader sr = new SAXReader();
解析器读取文件方法：
	Document doc = sr.read(String fileName);
Document的方法：
	getRootElement()			: 获取根元素	
	
节点中的方法：	
	elements()     				: 获取当前元素的子元素
	element(String name)		: 根据元素名获取指定子元素(如果有多个就获取到第一个)
	getName()					: 获取元素的元素名
    elementText(String name)	: 获取指定子元素的文本值,参数是子元素名称
	attributeValue(String name)	: 获取当前元素下某个属性的值
	getText()					: 获取当前元素的文本值
2.2.4 方法演示

  • xml

    <?xml version="1.0" encoding="UTF-8"?>
<books>
    <book id="0001">
        <name>JavaWeb开发教程</name>
        <author>张孝祥</author>
        <sale>100.00元</sale>
    </book>
    <book id="0002">
        <name>三国演义</name>
        <author>罗贯中</author>
        <sale>100.00元</sale>
    </book>
</books>

  • 解析

package com.itheima.demo1_Dom4j的基本使用;

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

import java.util.List;


public class Test1 {
    public static void main(String[] args) throws Exception {
        /*
            Dom4j的基本使用:
                使用步骤:
                    1.下载Dom4j的jar包
                    2.把jar包导入到模块的lib文件夹中,并添加到classpath路径下
                    3.创建解析器对象
                    4.使用解析器读取xml文档,生成Document对象
                    5.根据Document对象获取根元素
                    6.根据根元素获取下面的子元素\属性...
                常用的方法:
                   创建解析器对象：
                        SAXReader sr = new SAXReader();
                    解析器读取文件方法：
                        Document doc = sr.read(String fileName);
                    Document的方法：
                        Element getRootElement()			: 获取根元素

                    Element的方法：
                        elements()     				: 获取当前元素的子元素
                        getName()					: 获取元素的元素名
                        attributeValue(String name)	: 获取当前元素下某个属性的值
                        getText()					: 获取当前元素的文本值

                        element(String name)		: 根据元素名获取指定子元素(如果有多个就获取到第一个)
                        elementText(String name)	: 获取指定子元素的文本值,参数是子元素名称
         */
        // 1.创建解析器对象
        SAXReader sr = new SAXReader();
        // 2.使用解析器读取xml文档,生成Document对象
        Document document = sr.read("day16\\src\\book.xml");
        // 3.根据Document对象获取根元素
        Element rootE = document.getRootElement();
        System.out.println("根元素的名称:" + rootE.getName());// books

        // 4.获取根元素下的所有子元素
        List<Element> list1 = rootE.elements();
        // 5.循环遍历根元素的所有的子元素
        for (Element e1 : list1) {
            System.out.println("根元素的子元素的名称:" + e1.getName());// book book
            System.out.println("根元素的子元素的id属性值:" + e1.attributeValue("id"));// 0001 0002
            // 获取e1元素下的所有子元素
            List<Element> list2 = e1.elements();
            // 循环遍历list2
            for (Element e2 : list2) {
                System.out.println("book下的子元素名:" + e2.getName());// name  author sale
                System.out.println("book下的子元素中的文本:" + e2.getText());// name  author sale

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

        }

        // 5.获取根元素下的book子元素(就获取第一个)
        Element bookE = rootE.element("book");
        System.out.println(bookE.getName());// book
        System.out.println(bookE.attributeValue("id"));// 0001

        // 6.获取bookE元素下的author子元素的文本
        String text = bookE.elementText("author");
        System.out.println(text);// 张孝祥

    }
}

小结

知识点 - 2.3 Dom4J结合XPath解析XML

目标

我们来使用Dom4J和XPath结合的方式来解析XML

路径

  • 介绍
  • XPath使用步骤
  • XPath语法(了解)
  • 演示

讲解

2.3.1 介绍

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

2.3.2 XPath使用步骤

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

步骤2：通过dom4j的SaxReader解析器对象,获取Document对象

步骤3： 利用Xpath提供的api,结合xpaht的语法完成选取XML文档元素节点进行解析操作。

document常用的api

  • document.selectSingleNode(“xpath语法”); 获得一个节点(标签,元素)
  • document.selectNodes(“xpath语法”); 获得多个节点(标签,元素)
2.3.3 XPath语法(了解)

  • XPath表达式，就是用于选取HTML文档中节点的表达式字符串。

    获取XML文档节点元素一共有如下4种XPath语法方式：

    1. 绝对路径表达式方式 例如: /元素/子元素/子子元素…
    2. 相对路径表达式方式 例如: 子元素/子子元素… 或者 ./子元素/子子元素…
    3. 全文搜索路径表达式方式 例如: //子元素//子子元素
    4. 谓语（条件筛选）方式 例如: //元素[@attr1=value]

  • 获取不同节点语法

    获取类型语法代码
    获取元素节点元素名称
    获取属性节点@属性名称
2.3.3.1 绝对路径表达式(了解)

  • 绝对路径介绍

  • 以/开头的路径叫做是绝对路径，绝对路径要从根元素开始写、

public class Test {
public static void main(String[] args)throws Exception {
/*
- document.selectSingleNode(“xpath语法”); 获得一个节点(标签,元素)
- document.selectNodes(“xpath语法”); 获得多个节点(标签,元素)
*/
// 创建解析器
SAXReader sr = new SAXReader();
// 读取xml 获得document对象
Document document = sr.read(“day22/src/tianqi.xml”);
// 得到根元素
Element rootE = document.getRootElement();
System.out.println(rootE);

      // 绝对路径: 获取深圳 湿度
      Node node = rootE.selectSingleNode("/天气预报/深圳/湿度");
      System.out.println(node.getName());// 湿度
      System.out.println(node.getText());// 50%

  }

}

##### 2.3.3.2 相对路径表达式(了解)

- 相对路径介绍

- 相对路径就是相对当前节点元素位置继续查找节点，不以/开头, ../ 表示上一个元素, ./表示当前元素

  ```java
public class Test {
      public static void main(String[] args)throws Exception {
        /*
              - document.selectSingleNode("xpath语法");   获得一个节点(标签,元素)
              - document.selectNodes("xpath语法");      获得多个节点(标签,元素)
           */
          // 创建解析器
          SAXReader sr = new SAXReader();
          // 读取xml 获得document对象
          Document document = sr.read("day22/src/tianqi.xml");
          // 得到根元素
          Element rootE = document.getRootElement();
          System.out.println(rootE);
  
          // 相对路径: 获取深圳 湿度
          Node node = rootE.selectSingleNode("./深圳/湿度");
          System.out.println(node.getName());// 湿度
          System.out.println(node.getText());// 50%
  
  
          //用绝对路径的方式获取“温度”
          Node node2 = document.selectSingleNode("/天气预报/北京/温度");
          // 相对路径: 获取北京 湿度
          Node node3 = node2.selectSingleNode("../湿度");
          System.out.println(node3.getName());// 湿度
          System.out.println(node3.getText());// 20%
  
      }
  }
  ```

  

##### 2.3.3.3 全文搜索路径表达式(了解)

- 全文搜索路径介绍

- 代表不论中间有多少层,直接获取所有子元素中满足条件的元素

  ```java
public class Test {
      public static void main(String[] args)throws Exception {
          /*
              - document.selectSingleNode("xpath语法");   获得一个节点(标签,元素)
              - document.selectNodes("xpath语法");      获得多个节点(标签,元素)
           */
          // 创建解析器
          SAXReader sr = new SAXReader();
          // 读取xml 获得document对象
          Document document = sr.read("day22/src/tianqi.xml");
          // 得到根元素
          Element rootE = document.getRootElement();
          System.out.println(rootE);
  
          // 获取天气预报里的所有湿度，不论有多少层
          List<Element> list = rootE.selectNodes("//湿度");
          for (Element e : list) {
              System.out.println(e.getName()+","+e.getText());
          }
      }
  }
  ```

##### 2.3.3.4 谓语（条件筛选 了解）

- 介绍

谓语，又称为条件筛选方式，就是根据条件过滤判断进行选取节点

格式：	
​	String xpath1="//元素[@attr1=value]";//获取元素属性attr1=value的元素

​	String xpath2="//元素[@attr1>value]/@attr1"//获取元素属性attr1>value的d的所有attr1的值

​	String xpath3="//元素[@attr1=value]/text()";//获取符合条件元素体的自有文本数据

 	String xpath4="//元素[@attr1=value]/html()";//获取符合条件元素体的自有html代码数据。

​	 String xpath3="//元素[@attr1=value]/allText()";//获取符合条件元素体的所有文本数据（包含子元素里面的文本）

#### 2.3.4 演示

```java
public class Test {
  public static void main(String[] args)throws Exception {
      /*
          - document.selectSingleNode("xpath语法");   获得一个节点(标签,元素)
          - document.selectNodes("xpath语法");      获得多个节点(标签,元素)
       */
      // 创建解析器
      SAXReader sr = new SAXReader();
      // 读取xml 获得document对象
      Document document = sr.read("day22/src/tianqi.xml");
      // 得到根元素
      Element rootE = document.getRootElement();
      System.out.println(rootE);

      // 获取最高温度中属性名是level 属性值是A的元素
      List<Element> list = rootE.selectNodes("//最高温度[@level='C']");
      for (Element e : list) {
          System.out.println(e.getName()+","+e.getText());
      }

  }
}

小结

略

第三章 正则表达式

知识点-- 正则表达式的概念及演示

目标

  • 理解正则表达式的概念

路径

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

讲解

  • 概述: 正则表达式其实就是一个匹配规则,用来替换之前复杂的if结构判断

  • 在Java中，我们经常需要验证一些字符串，是否符合规则, 例如：校验qq号码是否正确,手机号码是否正确,邮箱是否正确等等。那么如果使用if就会很麻烦, 而正则表达式就是用来验证各种字符串的规则。它内部描述了一些规则，我们可以验证用户输入的字符串是否匹配这个规则。

  • 先看一个不使用正则表达式验证的例子：下面的程序让用户输入一个QQ号码，我们要验证：

    • QQ号码必须是5–15位长度
    • 而且必须全部是数字
    • 而且首位不能为0
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入你的QQ号码：");
		String qq = sc.next();
		
		System.out.println(checkQQ(qq));
	}
	//我们自己编写代码，验证QQ号码
	private static boolean checkQQ(String qq) {
		//1.验证5--15位
		if(qq.length() < 5 || qq.length() > 15){
			return false;
		}
		//2.必须都是数字；
		for(int i = 0;i < qq.length() ; i++){
			char c = qq.charAt(i);
			if(c < '0' || c > '9'){
				return false;
			}
		}
		//3.首位不能是0；
		char c = qq.charAt(0);
		if(c == '0'){
			return false;
		}
		return true;//验证通过
	}
	
}
  • 使用正则表达式验证：
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入你的QQ号码：");
		String qq = sc.next();
		
		System.out.println(checkQQ2(qq));
	}
	//使用正则表达式验证
	private static boolean checkQQ2(String qq){
		String regex = "[1-9]\\d{4,14}";//正则表达式
		return qq.matches(regex);
	}
}

上面程序checkQQ2()方法中String类型的变量regex就存储了一个"正则表达式 "，而这个正则表达式就描述了我们需要的三个规则。matches()方法是String类的一个方法，用于接收一个正则表达式，并将"本对象"与参数"正则表达式"进行匹配，如果本对象符合正则表达式的规则，则返回true，否则返回false。

小结

  • 正则表达式其实就是一个匹配规则,用来替换之前复杂的if结构判断

知识点-- 正则表达式的基本使用

目标

  • 掌握如何书写正则表达式

路径

  • 正则表达式-字符类
  • 正则表达式-逻辑运算符
  • 正则表达式-预定义字符
  • 正则表达式-数量词
  • 正则表达式-分组括号

讲解

3.2.1 正则表达式-字符类

  • 语法示例：[] 表示匹配单个字符 ^ 取反 - 范围

    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之间的任意一个字符。

  • 代码示例：

public class Test1 {
    public static void main(String[] args) {
        String str = "ead";
        //1.验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
        System.out.println(str.matches("h[aeiou]d"));// false
        System.out.println("hed".matches("h[aeiou]d"));// true
        System.out.println("heod".matches("h[aeiou]d"));// false
        System.out.println("==========================================");

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

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

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

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

  • 语法示例：

    1. &&：并且
    2. | ：或者

  • 代码示例：

public class Test2 {
    public static void main(String[] args) {
        /*
            正则表达式-逻辑运算符
                - 语法示例：
                  1. &&：并且
                  2. |    ：或者
         */
        String str = "had";
        //1.要求字符串是小写辅音字符开头，后跟ad  除了a,e,i,o,u之外,其他的都是辅音字母
        System.out.println(str.matches("[a-z&&[^aeiou]]ad"));// true
        System.out.println("aad".matches("[a-z&&[^aeiou]]ad"));// false
        System.out.println("Aad".matches("[a-z&&[^aeiou]]ad"));// false
        System.out.println("========================");

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

        System.out.println("aad".matches("[aeiou]ad"));// true
        System.out.println("aad".matches("[a|e|i|o|u]ad"));// true
    }
}
3.2.3 正则表达式-预定义字符

  • 语法示例：

    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]

  • 代码示例：

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]
         */
        String str = "258";
        //1.验证str是否3位数字
        System.out.println(str.matches("\\d\\d\\d"));// true
        System.out.println("25".matches("\\d\\d\\d"));// false
        System.out.println("+===================================");

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

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

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

        System.out.println("h.d".matches("h\\.d"));// true
        System.out.println("had".matches("h\\.d"));// false

    }
}
3.2.4 正则表达式-数量词

  • 语法示例：

    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都是包含的)

  • 代码示例：

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次  包含n
                  6. X{n,m}: n到m次(n和m都是包含的)

         */
        //1.验证str是否是三位数字
        System.out.println("123".matches("\\d{3}"));// true
        System.out.println("12".matches("\\d{3}"));// false
        System.out.println("1234".matches("\\d{3}"));// false
        System.out.println("===================================");

        //2.验证str是否是多位数字
        System.out.println("12".matches("\\d{2,3}"));// true
        System.out.println("123".matches("\\d{2,3}"));// true
        System.out.println("1223".matches("\\d{2,3}"));// false

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

        //3.验证str是否是手机号：1).第一位为1 2).第二位是3,5,8 3).后面9位都是数字
        System.out.println("13838381234".matches("1[358]\\d{9}"));// true
        System.out.println("14838381234".matches("1[358]\\d{9}"));// false
        System.out.println("===================================");

        //4.验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
        System.out.println("123456".matches("[1-9]\\d{4,14}"));// true
        System.out.println("023456".matches("[1-9]\\d{4,14}"));// false
        System.out.println("123".matches("[1-9]\\d{4,14}"));// false
    }
}
3.2.5 正则表达式-分组括号( )
public class Test5 {
    public static void main(String[] args) {
        /*
            正则表达式-分组括号( )
         */
        String str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";
        // 分成5组: 前面4组的规则是一样的 后面一组单独规则
        System.out.println(str.matches("([A-Z0-9]{5}-){4}[A-Z0-9]{5}"));
        // xxyy
        // 扩展:正则表达式匹配叠词
        // 哈哈,呵呵,嘿嘿,XX  (.)表示第一组,\\1表示第一组
        System.out.println("哈哈".matches("(.)\\1"));//true
        System.out.println("呵呵".matches("(.)\\1"));//true
        System.out.println("嘿嘿".matches("(.)\\1"));//true
        System.out.println("嘿哈".matches("(.)\\1"));// false
        // (.)表示第一组,\\1表示第一组,{3}表示\\1出现3次
        System.out.println("哈哈哈哈".matches("(.)\\1{3}"));//true
        System.out.println("呵呵呵呵".matches("(.)\\1{3}"));//true
        System.out.println("嘿嘿嘿嘿".matches("(.)\\1{3}"));//true
        System.out.println("===================================");

        // 高高兴兴,逼逼赖赖,XXYY
        // \\1表示第一组,\\2表示第二组,\\3表示第三组....
        System.out.println("高高兴兴".matches("(.)\\1(.)\\2"));//true
        System.out.println("逼逼赖赖".matches("(.)\\1(.)\\2"));//true
        System.out.println("===================================");

        // 快乐快乐,哔哩哔哩,XYXY
        System.out.println("快乐快乐".matches("(..)\\1"));//true
        System.out.println("哔哩哔哩".matches("(..)\\1"));//true
    }
}

小结

知识点-- String中正则表达式的使用

目标

在String中也有几个方法是可以使用正则表达式来操作的, 下面我们来学习一下

路径

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

讲解

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

  • String类的split()方法原型：

    public String[] split(String regex)//参数regex就是一个正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。

  • 代码示例：

public class Demo {
	public static void main(String[] args) {
		String str = "18  4 567       99     56";
		String[] strArray = str.split(" +");
		for (int i = 0; i < strArray.length; i++) {
			System.out.println(strArray[i]);
		}
	}
}
3.3.2 String类的replaceAll方法中使用正则表达式
  • String类的replaceAll()方法原型：
public String replaceAll(String regex,String newStr)//参数regex就是一个正则表达式。可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。
  • 代码示例：
public class Demo {
    public static void main(String[] args) {
        //将下面字符串中的"数字"替换为"*"
        String str = "jfdk432jfdk2jk24354j47jk5l31324";
        System.out.println(str.replaceAll("\\d+", "*"));
    }
}

小结

略

总结

必须练习:
	1.编写xml文档------元素\属性的书写
    2.使用Dom4j结合xpath路径解析xml文件中的数据
    3.要求能看懂正则表达式
        
- 能够说出XML的作用
    1.作为配置文件
    2.存储数据
    
- 了解XML的组成元素
    文档声明
    元素
    属性
    注释
    转义字符
    字符区
    
- 能够说出有哪些XML约束技术
    dtd\xsd
    
- 能够说出解析XML文档DOM方式原理
    使用解析器读取xml文档到内存中,加载成Dom树,生成Document对象
    
- 能够使用dom4j解析XML文档
    1.导入jar包
    2.创建解析器对象
    3.读取xml文档,生成Document对象
    4.使用Document对象获取根元素
    5.根据根元素获取子元素\属性
    ...
    
- 能够使用xpath解析XML
    1.导入jar包(2个)
    2.创建解析器对象
    3.读取xml文档,生成Document对象
    4.使用Document对象调用方法
    5.使用元素调用方法
    ...
      - document.selectSingleNode("xpath语法");   获得一个节点(标签,元素)
      - document.selectNodes("xpath语法");      获得多个节点(标签,元素)
   xpath路径语法:
	 1. 绝对路径表达式方式	     例如: /元素/子元素/子子元素...
           以/开头的路径叫做是绝对路径，绝对路径要从根元素开始写

     2. 相对路径表达式方式          例如: 子元素/子子元素..  或者 ./子元素/子子元素..
          相对路径就是相对当前节点元素位置继续查找节点，不以/开头, ../ 表示上一个元素, ./表示当前元素

     3. 全文搜索路径表达式方式  例如: //子元素, //子元素/子子元素,//子元素//子子元素
          代表不论中间有多少层,直接获取所有子元素中满足条件的元素

      4. 谓语（条件筛选）方式      例如: //元素[@attr1=value]
    
- 能够理解正则表达式的作用
    替换复杂的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方法中使用正则表达式
  略
做最幸福的
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
正则表达式+xml
05-19
可以作为验证正则表达式小工具，也可以作为操作XML的参考。
XML&正则表达式
chenguoao1999的博客
08-10 2984
学习目标 1、了解XML的发展跟历史 2、了解XML跟HTML的区别 3、熟练XML的语法规则 3、了解XML的约束 4、熟练XML的解析 5、熟练正则的解析 第1章 XML 1.1 概述 XML（EXtensible Markup Language）可扩展的标记语言。主要用于数据交换。在HTML发展过程中，由于游览器厂商的恶性竞争，都在兼容不规范的写法，以用来吸引开发者。这与W3C的初衷相违背。于是W3C制定了XML标准，想以此替代HTML进行数据展示。但此并不能吸引开发者，XML最终以失败告终。XML
XML和正则表达式
zhoutao719的博客
08-10 2208
XML和正则表达式 XML&JSON XML XML（EXtensible Markup Language）,可扩展标记语言 特点： 1、XML与操作系统、编程语言的开发平台无关 2、实现不同系统之间的数据交换 作用： 数据交互 配置应用程序和网站 Ajax基石 XML结构如下： <?xml version="1.0" encoding="UTF-8"?> <books> <!--图书信息 --> <book id="bk101">
正则表达式与XML
weixin_61399281的博客
03-29 1261
正则表达式: 了解 用正则的语法来描述具有特殊规则字符串 是一个门语言,具有自己的语法 作用: 查找,匹配,校验,分隔... java中使用正则 1.String类中一些支持正则表达式语法的方法 String[] split(String regex) 将此字符串拆分为给定 regular expression的匹配 项 。 String ...
Android 正则表达式的用法
yanhuomatou2015的博客
09-04 2456
正则表达式及应用 一、 正则表达式 （一）、概念： 正则表达式(regular expression)就是由普通字符（例如a到z）以及特殊字符（称为元字符）组成的一种字符串匹配的模式，可以用来检查一个串是否含有某种子串、将匹配的子串做替换或者从某个串中取出符合某个条件的子串等。 （二）、正则表达式中主要元字符：【其中常用的元字符用红色标出，红色的元字符必须掌握。难点用蓝色标出，难点在一般的应用中并不常用】 \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，‘n’
一种基于XML和正则表达式的简单验证框架.pdf
最新发布
01-03
"一种基于XML和正则表达式的简单验证框架" 本文介绍了一种基于XML和正则表达式的简单验证框架，该框架可以用于Web开发中的表单验证。该框架的主要思想是使用XML和正则表达式来定义验证规则，然后使用JavaScript来...
基于XML和正则表达式的气象数据处理系统.pdf
08-15
【基于XML和正则表达式的气象数据处理系统】 在当今的气象信息领域，随着气象综合观测网的不断发展，实时数据信息传输的种类和数量正在急剧增加。为了应对这一挑战，提高数据处理的效率、可靠性和及时性，研究人员...
Java使用正则表达式提取XML节点内容的方法示例
08-29
Java使用正则表达式提取XML节点内容的方法示例 Java使用正则表达式提取XML节点内容的方法示例主要介绍了Java使用正则表达式提取XML节点内容的方法，结合具体实例形式分析了java针对xml格式字符串的正则匹配相关操作...
SQL 正则表达式及mybatis中使用正则表达式
12-13
mysql 提供的模式匹配的其他类型是使用扩展正则表达式。 当你对这类模式进行匹配测试时，使用REGEXP和NOT REGEXP操作符(或RLIKE和NOT RLIKE，它们是同义词)。 扩展正则表达式的一些字符是： “.”匹配任何单个的...
学习笔记四（XML、正则表达式）
ssnszds的博客
04-19 412
正则表达式简述： 正则表达式都写在一对//里； ^ 表示开头 $ 表示结尾 []里面是内容 {}里面是个数 如： 用户名： / ^ [a-z0-9_-]{3,16}$/ 密码： / ^ [a-z0-9_-]{6,18} $ / 邮箱：/ ^([a-z0-9_\ .-]+)@([\da-z \ .-]+)\ .([a-z.]{2,6})$/ 一些特殊含义的字符： . 有特殊含义，使用时需要进行转义...
XML正则表达式 工具
07-31
正则表达式30分钟入门教程<br>and<br>工具
xml需求文档及正则表达式介绍
05-20
正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式正则表达式
XML正则表达式工具
04-23
收藏的非常好用的XML正则表达式分析工具，工作中的检测工具。
使用正则表达式进行xml数据验证
zgqtxwd的专栏
04-24 426
<!--google_ad_client = "pub-2947489232296736";/* 728x15, 创建于 08-4-23MSDN */google_ad_slot = "3624277373";google_ad_width = 728;google_ad_height = 15;//--><script type="text/javascript"
在Android使用正则表达式
似水流年
05-13 2407
在c#中上一次已经使用了正则表达式，掌握了一些基本要领，那么在android里面也是相似的处理方法，在这里我是为了处理android读取service的解析所用到，读取“string=....;”省略号之间的内容，这里可以用正则表达是定位（我做的例子是一个天气预报的service信息的读取），整个方法如下： 在代码里面，我已经做了注释，这里是因为我在读取天气信息的时候，发现有一行总是获取
采用正则表达式处理XML标签
fengzhongpiaoxing的专栏
06-08 5582
1、采用正则表达式先匹配带的标签， 2、通过正则表达式匹配context。 3、后面可以处理context的内容。 注意：目前：context 只能为 英文字符 、数字 、_ 三种字符，如果需要支持不同的字符，可以通过修改正则表达式达到目标。 #include "stdafx.h" #include&lt;iostream&gt; #include&lt;regex&gt; #inclu...
学习正则表达式 - 提取和替换 XML 标签
wzy0623的专栏
05-18 1293
如何从文件中提取XML元素列表并将其转换为XSLT样式表
XML 技术-反射技术-正则表达式
qq_45564691的博客
10-30 301
用自己的语言说出，为什么需要 XML? XML 是一种元标注语言，该语言提供一种描述结构数据的格式。这有助于更精确地声明内容，方便跨越多种平台的更有意义的搜索结果。此外，XML 将起用新一代的基于 Web 的数据查看和处理应用程序。 XML 提供可以广泛执行并易于配置的数据的结构表示。XML 是 万维网协会(W3C) 定义的用于优化 Web 上的传输的 SGML 的子集，XML 确保结构数据是一致...
正则与XML
qq_44358876的博客
03-29 934
第一章 正则表达式 1 理解 1.1 正则表达式 正则表达式是用来描述具有一定特征的字符串的特殊字符串。Regular Expression。 a+b*c : a+ c 个的 b (d+e)*f：()->组,改变了优先级 ，f 个的 d+e a+b*c+(d+e)*f : 组合成复杂的表达式 1.2 目标 简单可以手写，复杂的拷贝，略作修改。Java中使用正则会用即可. 1.3 入门示例 ab*: a 若干个 b ->* 零个及以上 ，匹配: a ab abbbbb abbbbbb
python xml 正则表达式 替换
10-01
在Python中，我们可以使用正则表达式来处理XML文件，并进行替换操作。 首先，我们需要导入`re`模块，这是Python中用于操作正则表达式的标准模块。 接下来，我们需要读取XML文件并将其保存到一个字符串中，我们可以使用`open()`函数打开文件，然后使用`.read()`方法将文件内容保存到一个字符串中。 然后，我们可以使用正则表达式的`sub()`函数来进行替换操作。`sub()`函数接受三个参数：要替换的字符串模式、替换后的字符串和要进行替换操作的字符串。 例如，如果我们想要将XML文件中的所有`<name>`标签替换为`<username>`，可以使用以下代码： ```python import re # 读取XML文件并保存到字符串中 with open('example.xml', 'r') as file: xml_content = file.read() # 使用正则表达式替换操作 new_xml_content = re.sub(r'<name>', '<username>', xml_content) # 输出替换后的结果 print(new_xml_content) ``` 上述代码中，我们首先使用`open()`函数将名为`example.xml`的XML文件打开并读取其内容保存到`xml_content`字符串中。 然后，我们使用正则表达式的`sub()`函数，将`<name>`替换为`<username>`，替换操作应用于`xml_content`字符串，并将结果保存到`new_xml_content`中。 最后，我们使用`print()`函数输出替换后的结果。 以上就是使用Python的正则表达式对XML进行替换的简单示例。当然，实际应用中可能会有更多复杂的替换操作，我们可以根据具体的需求来编写相应的正则表达式来完成相应的替换任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值