scala对xml的支持很强大，这是大家都知道的

下面通过网络搜索，以及自身实践，来体验它到底有多么强大！

 
  
  1. object XmlTest { 
  2.   def main(args: Array[String]) { 
  3.     val xmlTag = 
  4.       <div> 
  5.         <span id="12">Hi,How are you!</span> 
  6.         <div> 
  7.           <span>I am Good!</span> 
  8.           <span></span> 
  9.         </div> 
  10.       </div> 
  11.  
  12.     println(xmlTag \ "span" \ "@id") //12 
  13.     println(xmlTag \ "span") //得到root标签下的span   <span id="12">Hi,How are you!</span> 
  14.     println(xmlTag \\ "span") //  <span id="12">Hi,How are you!</span><span>I am Good!</span>...  得到所有span 
  15.  
  16.     println(xmlTag getClass)     //scala.xml.Elem 
  17.     println(xmlTag \ "span" getClass)      //scala.xml.NodeSeq$$anon$1 
  18.     println(<dd>{ xmlTag \\ "span" }</dd>)         //<dd><span id="12">Hi,How are you!</span><span>I am Good!</span><span></span></dd> 
  19.   } 
  20. } 
 
  
 
 
  
利用xml进行match case的网页：http://haolloyin.blog.51cto.com/1177454/395748
 
  
若果想自己串联出一个xml则可以用下面这样的方式：
 
  
 
 
  
 
  
  1. var nodes=new Queue[NodeSeq] 
  2. val xmlElement= xmlTag \ "span" 
  3. nodes += xmlElement 
  4. nodes += <a> </a>             //通过一个Queue，将xml的NodeSql连接起来 
  5. println(<di> {nodes}</di>)      //<di> <span id="12">Hi,How are you!</span><a> </a></di> 
 
  
 如果想在root标签里做些手脚：
 
  
 
 
  
 
  
  1. xmlTag \ "_"   //可以去除root标签下面的所有内容 
  2. var nodes=new Queue[NodeSeq] 
  3. nodes += xmlTag \ "_" 
  4. nodes += <a> Why </a>             //通过一个Queue，将xml的NodeSql连接起来 
  5. println(<div> {nodes}</div>)      //完成了在root标签的直接子标签尾巴添加一个tag 
 
  
按照上面的方法，就可以利用层次结构，利用多个 \ ".."来修改xml的内容，当然随着层数的增加，就不只需要一个Queue了！
 
  
由于我还没有发现scala有类似toElem这样的方法，可以将string转换成Elem，不能利用string的replace方法来替换找到的Node，所以除了使用类似java解析xml的方式，处理变更xml内的小标签的有效方法还没有找到，希望知道的同学告诉下。
 
  
下面使用遍历Elem的每个node的方法来改变xml，具体解决请看下面这个完整的Object
 
  
 
 
  
 
  
  1. import collection.mutable.Queue 
  2. import xml.{NodeSeq, Elem} 
  3.  
  4. object XmlTest { 
  5.   def main(args: Array[String]) { 
  6.     val xmlTag = 
  7.       <div> 
  8.         <span id="12">Hi,How are you!</span> 
  9.         <div> 
  10.           <span>I am Good!</span> 
  11.           <span></span> 
  12.         </div> 
  13.       </div> 
  14.  
  15.     //    println(xmlTag \ "span" \ "@id") //12 
  16.     //   println(xmlTag \ "_"  \"div")  //可以去除root标签下面的所有内容 
  17.     var nodes = new Queue[NodeSeq] 
  18.     val its = xmlTag.child 
  19.     for (it <- its) { 
  20.       if (it.toString != "\n        ") {    //为什么是 "\n        "呢，因为声明的xmlTag使用工具格式化了一下，分布在多行 
  21.         nodes += it.asInstanceOf[NodeSeq] 
  22.         if (it.attribute("id") != None && it.attribute("id").get.apply(0).text == "12") 
  23.           nodes += <span>Sorry,Something is wrong</span> 
  24.       } 
  25.     } 
  26.     println(<div> 
  27.       {nodes} 
  28.     </div>) 
  29.      
  30.     //结果： 
  31.     <div> 
  32.       <span id="12">Hi,How are you!</span><span>Sorry,Something is wrong</span><div> 
  33.           <span>I am Good!</span> 
  34.           <span></span> 
  35.         </div> 
  36.        
  37.     </div> 
  38.  
  39.   } 
  40. } 
 
  
至于还有一个遍历NodeSeq的方式，就不具体附代码了，应该是大同小异，参见scala的xml包了。