groovy笔记:XML,JSON,集合操作,正则,闭包

看groovy的时候找资料的时候归纳的

代码测试过都可以执行:

 

groovy笔记:

 

XML操作: MarkupBuilder:

def s=new StringWriter()
def builder = new groovy.xml.MarkupBuilder(s)
builder.'web-app' {
    'display-name' 'My Web Application'
}
println s.toString()

 

在里面也可以嵌套写 或者写for等表达式

 

创建:

 groovy.xml.StreamingMarkupBuilder

(http://groovy.codehaus.org/Creating+XML+using+Groovy%27s+StreamingMarkupBuilder)

 

 groovy.xml.MarkupBuilder

 

 

解析可以使用XMLParser:

class XmlExample {
  static def PERSON = 
    """
    <person id='2'>
      <name>Gweneth</name>
      <age>1</age>
    </person>
    """
} //?XML作为Groovy源码

class Person {def id; def name; def age} //Groovy中的Person定义

def xmlPerson = new XmlParser().
                    parseText(XmlExample.PERSON) //?读取XML

Person p = new Person(id: xmlPerson.@id,
                    name: xmlPerson.name.text(),
                     age: xmlPerson.age.text()) //?填入GroovyBean Person中

println "${p.id}, ${p.name}, ${p.age}"

 

 

 

 

生成Json:

和XML的MarkupBuilder传入SW不同 他的输出靠builder本身就可以了

def builder = new groovy.json.JsonBuilder()
       def root = builder.people {
           person {
               firstName 'Guillame'
               lastName 'Laforge'
               // Named arguments are valid values for objects too
               address(
                       city: 'Paris',
                       country: 'France',
                       zip: 12345,
               )
               married true
               // a list of values
               conferences 'JavaOne', 'Gr8conf'
           }
       }
println builder.toString()
println builder.toPrettyString()
def s=new StringWriter()
builder.writeTo(s)
println s.toString()

 

 

或者直接传入一个结构:

import groovy.json.JsonBuilder

def tasks = [1, 2, 3]

def data = [  //data是map
  success: true,
  count: tasks.size(),
  data: tasks.collect {[id: it]}
]

def json = new JsonBuilder(data)
println json.toPrettyString()

 

 

解析直接使用:JsonSlurper

import groovy.json.JsonBuilder
import groovy.json.JsonSlurper
def builder = new groovy.json.JsonBuilder()
       def root = builder.people {
           person {
               firstName 'Guillame'
               lastName 'Laforge'
               // Named arguments are valid values for objects too
               address(
                       city: 'Paris',
                       country: 'France',
                       zip: 12345,
               )
               married true
               // a list of values
               conferences 'JavaOne', 'Gr8conf'
           }
       }
def result = new JsonSlurper().parseText(builder.toString())
println result.people.person.firstName

 

 

 

 

 

 

集合操作:

集合支持 +(两个集合) -(两个集合) * 的操作

each:遍历集合，对其中的每一项应用函数字面值 //相当于erlang的 lists:foreach操作

collect:收集在集合中每一项上应用函数字面值的返回结果（相当于其他语言map/reduce中的map函数）//相当于erlang的lists:map操作

inject:用函数字面值处理集合并构建返回值（相当于其他语言里map/reduce中的reduce函数）

//相当于erlang中lists:foldl操作

findAll:找到集合中所有与函数字面值匹配的元素 //相当于erlang lists:filter操作

max:返回集合中的最大值

min:返回集合中的最小值

 

erlang中:

1> A=[1,2,3,4,5,6].
[1,2,3,4,5,6]
2> lists:map(fun(E) -> E*2 end,A).
[2,4,6,8,10,12]
3> lists:foldl(fun(E,Sum) -> Sum+E end,0,A).
21
5> lists:filter(fun(E) -> E rem 2==0 end,A).
[2,4,6]
6> lists:foreach(fun(E) -> io:format("~p~n",[E*2]) end,A).
1
2
3
4
5
6
ok

 

 

对应的groovy中:

a=[1,2,3,4,5,6]

println a.collect {i -> i*2}

println a.inject(0, {sum, value -> sum + value })

println a.findAll {i -> i%2==0}

a.each {i -> println(i*2)}

 

 

 

 

 

正则表达式

用 def pattern = ~ "正则表达式" //注意 = ~是分开的！！！

然后要match用 def match=("验证的字符串" =~ pattern)就可以了

练习案例:

def begin=System.currentTimeMillis()
def stream=new URL("http://fc.5sing.com/10933160.html###").openStream();
def out=new ByteArrayOutputStream();
def data=new byte[1024];
while((length=stream.read(data))!=-1){
 out.write(data,0,length)
}
data=out.toString("utf-8")
def p = ~"songID: SongID, songType: \"fc\", file: \"(.*)\", singerID: UserID"
def matcher=(data =~ p)
for(m in matcher){
 result=m.get(1)
}
def end=System.currentTimeMillis()
println "time elasped:${end-begin}ms"
result

 

 

 

此外:

字符串可以直接 进行-操作

"1231"-"1" //等于"231" 这点erlang也是一样的 用--符号

 

 

 

 

 

关于闭包:

//转换
interface One{
 def drink();
} 
def one={ -> println "hello"} as One
one.drink()

//默认是Callable类型的
def closure = {
       "called"
}
assert closure instanceof java.util.concurrent.Callable
assert closure() == "called"

//将当前的方法变成一个函数
def modify(item){
 "modify_${item}"
}
def fun=this.&modify
def list=[1,2,3,4,5]
list.collect(fun)
fun(45)

//对于静态方法
def s=Math.&sqrt
s(4) 

//对于实例方法:
class Mine{
  public String sayHello(){
    return "hello";
  }
}
def m=new Mine()
def hello=m.&sayHello
hello()