2. 程式人生 > >Scala入門到精通——第二十七節 Scala操縱XML

Scala入門到精通——第二十七節 Scala操縱XML

阿新 • • 發佈：2018-12-25

本節主要內容

  1. XML 字面量
  2. XML內容提取
  3. XML物件序列化及反序列化
  4. XML檔案讀取與儲存
  5. XML模式匹配

1. XML 字面量

XML是一種非常重要的半結構化資料表示方式，目前大量的應用依賴於XML，這些應用或利用XML作為資料交換格式，或利用XML進行檔案配置等。像JAVA、C++及其它流行的程式開發語言都是依賴於第三方庫來實現XML的操作，例如JAVA經常通過JDOM，DOM4J等XML處理工具進行XML的操縱，但Scala提供了對XML的原生支援，通過scala.xml._包下的類或物件可以進行任何的XML操作。下面的程式碼演示了Scala中如何定義XML字面量。

scala> var x: scala.xml.Elem = <site
 
><name>xuetuwuyou</name><url>http://www.xuet
uwuyou.com/</url></site>
x: scala.xml.Elem = <site><name>xuetuwuyou</name><url>http://www.xuetuwuyou.com/
</url></site>

scala> <site><name>xuetuwuyou</name><url>http://www.xuetuwuyou.com/</url
 
></site>

res8: scala.xml.Elem = <site><name>xuetuwuyou</name><url>http://www.xuetuwuyou.c
om/</url></site>

通過上面的程式碼不能發現，scala會自動地對XML進行解析，並識別為scala.xml.Elem型別。scala中與XML相關的包和類很多，具體如下圖所示：
這裡寫圖片描述

在深入講解Scala操縱XML之前，先對幾個主要的術語進行介紹：
這裡寫圖片描述
圖中描述了屬性、根元素、子元素、元素及文字的概念及它們之間的關聯關係，所以的文字、元素被統稱為節點（Node）。下面給出的scala XML中的幾個重要的類：

  • Node類。它的一個抽象類，用於物件XML中的所有節點進行抽象：
    這裡寫圖片描述
  • Text類，僅包含文字的節點，例如<url>http://www.xuetuwuyou.com/</url> 中的http://www.xuetuwuyou.com/就是一種Text物件
  • NodeSeq類，它同樣是一個抽象類，指的是節點的序列，Node繼承自NodeSeq，可以看Node可作是NodeSeq只有一個元素的情況。

scala中的XML中可以執行scala表示式，例如

 val s="http://www.xuetuwuyou.com/"
 val xmlUrl= <a>{" "+s+" "}</a>
 //<a> http://www.xuetuwuyou.com/ </a>
 println(xmlUrl)

 val age=30
 val xml1= if(age<29) <age> {age} </age> else NodeSeq.Empty
 //<age> 28 </age
 println(xml1)

//<age> 79 </age>
 val xml2= <age> {29+50} </age>
 println(xml2)

2. XML內容提取

提取XML中的文字：

object ExtractXMLText extends App{
  val x= <person><name>搖擺少年夢</name><age>27</age></person>
  //搖擺少年夢27
  println(x.text)  
}

這種提取方式將XML中所有的文字內容提取出來並拼接在一起，在實際中我們可能需要精確提取，比如我只想提取name元素中的內容，此時可以採用下列方式：

val x= <person><name>搖擺少年夢</name><age>27</age></person>
//提取name子結點，型別XPATH訪問方式
//<name>搖擺少年夢</name>
  println(x \ "name")
//提取name中的文字
  println((x \ "name").text)

scala> x \ "age"
res2: scala.xml.NodeSeq = NodeSeq(<age>27</age>)

x \ “age” 這種子元素的提取方式，返回的型別是scala.xml.NodeSeq

\的方式只能提取子元素，不能提取子元素的子元素，例如：

  val x= <persons>
              <person><name>搖擺少年夢</name><age>27</age></person>
              <person><name>張三</name><age>29</age></person>
              <person><name>李四</name><age>30</age></person>
         </persons>
  //返回空NodeSeq
  println(x \ "name")
  // \\提取二級子元素
  //<name>搖擺少年夢</name><name>張三</name><name>李四</name>
  println(x \\ "name")

通過\和\可以提取任何XML的子元素及其文字內容，但如果XML元素帶有屬性，那又如何提取呢？

val x= <persons>
              <person 
                  name="搖擺少年夢" age="27" />
              <person><name>張三</name><age>29</age></person>
              <person><name>李四</name><age>30</age></person>
         </persons>
  //用@方式提取name屬性
  //搖擺少年夢
  println(x \\ "@name")

3. XML物件序列化及反序列化

下面給出的是物件的XML序列化操作：


class Person(val name:String,val age:Int){
  def toXML()={
    <person>
       <name>{name}</name>
       <age>{age}</age>
    </person>
  }
}
object XMLSerialization extends App{
  val p=new Person("搖擺少年夢",27)
  println(p.toXML())
}

反序列化操作：

class Person(val name:String,val age:Int){
  //序列化操作
  def toXML()={
    <person>
       <name>{name}</name>
       <age>{age}</age>
    </person>
  }
  //反序列化操作
  def fromXML(xml:scala.xml.Elem):Person={
    new Person((xml \ "name").text,(xml \ "age").text.toInt)
  }
  override def toString()="name="+name+", age="+age
}
object XMLSerialization extends App{
  val p=new Person("搖擺少年夢",27)
  val xmlPerson=p.toXML()
  val p2=p.fromXML(xmlPerson)
  println(p2)
}

4. XML檔案讀取與儲存

前一小節，我們的序列化與反序列化操作都在記憶體中進行的，在通常的情況下都是將序列化後的XML儲存在檔案當中，在反序列化時再從檔案中讀取，實現方式如下：

class Person(val name:String,val age:Int){
  def toXML()={
    <person>
       <name>{name}</name>
       <age>{age}</age>
    </person>
  }

  def fromXML(xml:scala.xml.Elem):Person={
    new Person((xml \ "name").text,(xml \ "age").text.toInt)
  }
  override def toString()="name="+name+", age="+age
}
object XMLSerialization extends App{
  val p=new Person("搖擺少年夢",27)
  val xmlPerson=p.toXML()
  //儲存到XML檔案當中
  scala.xml.XML.save("person.xml", xmlPerson, "UTF-8", true, null)
  //從檔案中載入XML檔案
  val loadPerson=scala.xml.XML.loadFile("person.xml")
  val p2=p.fromXML(loadPerson)
  println(p2)
}

下面給出的是save方法的標籤

/** Saves a node to a file with given filename using given encoding
   *  optionally with xmldecl and doctype declaration.
   *
   *  @param filename the filename
   *  @param node     the xml node we want to write
   *  @param enc      encoding to use
   *  @param xmlDecl  if true, write xml declaration
   *  @param doctype  if not null, write doctype declaration
   */
  final def save(
    filename: String,
    node: Node,
    enc: String = encoding,
    xmlDecl: Boolean = false,
    doctype: dtd.DocType = null
    ): Unit =

5. XML模式匹配

Scala操縱XML另外一個非常強大的地方在於，它能夠用於模式匹配，從而非常靈活、方便地對XML進行處理：

import scala.xml._

object PatternMatchingXML extends App{
  def xmlMatching(node:Node)={
     node match {
       //XML模式匹配語法，利用{}進行匹配
       case <persons>{sub_element}</persons>=> println(sub_element)
       //其它未匹配的情況
       case _ => println("no matching")
     }

  }
  //下面這條語句的執行結果：<person><name>搖擺少年夢</name></person>
  xmlMatching(<persons><person><name>搖擺少年夢</name></person></persons>)
  //下面這條語句的執行結果：
  //no matching
  xmlMatching(<persons><person><name>搖擺少年夢</name></person><person><name>搖擺少年夢</name></person></persons>)
}

從上述程式碼可以看到，<persons>{sub_element}</persons> 只能匹配標籤<persons></persons> 中只存在單個子元素的情況，如果具有多個子元素，即子元素構成NodeSeq，則不能匹配，需要進行進一步處理，程式碼如下：

object PatternMatchingXML extends App{
  def xmlMatching(node:Node)={
     node match {
       //_*的方式表示可以匹配多個子元素的情況，如果匹配
       //則將匹配的內容賦值給sub_element 
       case <persons>{sub_element @ _*}</persons>=> println(sub_element)
       case _ => println("no matching")
     }

  }
  //下面這條語句返回的是：ArrayBuffer(<person><name>搖擺少年夢</name></person>)
  //陣列中的每個元素都是Node型別
  xmlMatching(<persons><person><name>搖擺少年夢</name></person></persons>)
  //下面這條語句返回的是：ArrayBuffer(<person><name>搖擺少年夢</name></person>, <person><name>搖擺少年夢</name></person>)
 //陣列中的每個元素都是Node型別
  xmlMatching(<persons><person><name>搖擺少年夢</name></person><person><name>搖擺少年夢</name></person></persons>)
}

因為返回的是ArrayBuffer，可以通過for迴圈遍歷對XML子元素中的內容進行提取，如：


  def xmlMatching2(node:Node)={
     node match {
       case <persons>{sub_element @ _*}</persons>=> 
          for(elm <- sub_element) println("getting "+(elm \ "name").text)
       case _ => println("no matching")
     }

  }
  //返回結果getting 搖擺少年夢
  xmlMatching2(<persons><person><name>搖擺少年夢</name></person></persons>)
  //返回結果：
  //getting 搖擺少年夢
  //getting 搖擺少年夢
  xmlMatching2(<persons><person><name>搖擺少年夢</name></person><person><name>搖擺少年夢</name></person></persons>)

新增公眾微訊號，可以瞭解更多最新Spark、Scala相關技術資訊
這裡寫圖片描述

相關推薦

Scala入門到精通——第二十七節 Scala操縱XML

本節主要內容 XML 字面量 XML內容提取 XML物件序列化及反序列化 XML檔案讀取與儲存 XML模式匹配 1. XML 字面量 XML是一種非常重要的半結構化資料表示方式，目前大量的應用依賴於XML，這些應用或利用XML作為資料交換格式，或利

Scala入門到精通——第二十九節 Scala數據庫編程

while mic hibernate using 框架 batch mes dcl ant 本節主要內容 Scala Mavenproject的創建 Scala JDBC方式訪問MySQL Slick簡單介紹 Slick數據庫編程實戰 SQL與Sl

Scala入門到精通——第二十九節 Scala資料庫程式設計

本節主要內容 Scala Maven工程的建立 Scala JDBC方式訪問MySQL Slick簡介 Slick資料庫程式設計實戰 SQL與Slick相互轉換 1. Scala Maven工程的建立 本節的工程專案採用的是Maven Proj

Scala入門到精通——第二十六節 Scala併發程式設計基礎

本節主要內容 Scala併發程式設計簡介 Scala Actor併發程式設計模型 react模型 Actor的幾種狀態 Actor深入使用解析 1. Scala併發程式設計簡介 2003 年，Herb Sutter 在他的文章 “The Fre

Scala入門到精通——第二十二節 高級類型 （一）

www 不同 out not cloneabl etag new 創建方式 技術分享 作者：搖擺少年夢 視頻地址：http://www.xuetuwuyou.com/course/12 本節主要內容 this.type使用 類型投影 結構類型

Scala入門到精通——第二十四節 高級類型 （三）

func double tor 結構體 入門到精通 strac 命令 person 字節碼 作者：擺擺少年夢 視頻地址：http://blog.csdn.net/wsscy2004/article/details/38440247 本節主要內容

Scala入門到精通——第二十一節 型別引數（三）-協變與逆變

本節主要內容 協變 逆變 型別通匹符 1. 協變 協變定義形式如：trait List[+T] {} 。當型別S是型別A的子型別時，則List[S]也可以認為是List[A}的子型別，即List[S]可以泛化為List[A]。也就是被引數化

Scala入門到精通——第二十二節 高階型別 （一）

本節主要內容 this.type使用 型別投影 結構型別 複合型別 1. this.type使用 class Person{ private var name:String=null private var age:Int=0

Scala入門到精通——第二十五節 提取器（Extractor）

本節主要內容 apply與unapply方法 零變數或變數的模式匹配 提取器與序列模式 scala中的佔位符使用總結 1. apply與unapply方法 apply方法我們已經非常熟悉了，它幫助我們無需new操作就可以建立物件，而unap

Scala入門到精通——第二十四節 高階型別 （三）

本節主要內容 Type Specialization Manifest、TypeTag、ClassTag Scala型別系統總結 在scala中，類(class)與型別(type)是兩個不一樣的概念。我們知道類是對同一型別資料的抽象，而型別則更具

Scala入門到精通——第十七節 型別引數（一）

本節主要內容 型別變數界定(Type Variable Bound) 檢視界定（View Bound) 上界（Upper Bound）與下界（Lower Bound） 1. 型別變數界定(Type Variable Bound) 型別變數界定是指在

學習筆記第二十七節課

作業awk awk支持分段，比如passwd的文件很有規律，可以分開匹配。 awk 最簡單的功能，-F （加了-F 就是表示要分割，後面就添加分割的符號，比如：）分段 顯示 passwd 的第一段內容，以：分割。 想打印多個分割的內容，就加， 打印所有的內容 不用-F 直接打印就行了。 就相當於c

第二十七節，IOU和非極大值抑制

變暗 ont 應該 wid 這也 發生 orb idt 簡單 你如何判斷對象檢測算法運作良好呢？在這一節中，你將了解到並交比函數，可以用來評價對象檢測算法。 一 並交比(Intersection over union ) 在對象檢測任務中，你希望能夠同時定位對象，所以如果

學習筆記第二十七節：AC自動機

正題       聽說NOIP要考，所以臨時補了一下，多了一種思考方式。       AC自動機是基於KMP和字典樹的，要想透徹瞭解AC自動機，最好先學KMP和字典樹。       那麼，AC自

Scala入門到精通——第二十節 類型參數（二）

ger 直觀 implicit 有時 com 方法調用 錯誤 println there 本節主要內容 Ordering與Ordered特質 上下文界定（Context Bound） 多重界定 類型約束 1. Ordering與Ordered

Scala入門到精通——第二十節 型別引數（二）

本節主要內容 Ordering與Ordered特質 上下文界定（Context Bound） 多重界定 型別約束 1. Ordering與Ordered特質 在介紹上下文界定之前，我們對scala中的Ordering與Ordered之間的關聯與區別

Scala入門到精通——第十五節 Case Class與模式匹配（二）

本節主要內容 模式匹配的型別 for控制結構中的模式匹配 option型別模式匹配 1. 模式的型別 1 常量模式 object ConstantPattern{ def main(args: Array[String]): Unit =

Scala入門到精通——第二十八節 Scala與JAVA互操作

本節主要內容 JAVA中呼叫Scala類 Scala中呼叫JAVA類 Scala型別引數與JAVA泛型互操作 Scala與Java間的異常處理互操作 1. JAVA中呼叫Scala類 Java可以直接操作縱Scala類，如同Scala直接使用Java中

Scala入門到精通——第十二節 I/O與正則表示式

本節主要內容 Scala I/O操作簡介 Scala 寫檔案 Scala 讀檔案 Scala 網路I/O 正則表示式簡介 Scala正則表示式實戰 1. Scala I/O操作簡介 I/O操作是一門程式語言中的重要內容，在Scala中，它更多的是呼

Scala入門到精通——第十六節 泛型與註解

本節主要內容 泛型(Generic Type）簡介 註解（Annotation）簡介 註解常用場景 1. 泛型(Generic Type）簡介 泛型用於指定方法或類可以接受任意型別引數，引數在實際使用時才被確定，泛型可以有效地增強程式的適用性，使用