Groovy 特性：
Groovy = Java - 重复的样板代码
+可选的动态类型
+闭包（closures）
+领域规范语言（DSL）
+生成器（builders）
+元编程（metaprogramming）
Groovy是没有类型/修饰符/方法返回类型/Iterator,不需要导入集合的Java.
Groovy丢掉了许多Java的包袱。不能确定变量类型时将变量类型设为Object.
DSL:domain specific languages
生成器：可以生成XML/HTML/Swing树状数据结构
元编程：运行时对类增加行为，类似于AOP，java中反射
Groovy自动导入如下包：
groovy.lang.*
groovy.util.*
java.lang.*
java.util.*
java.util.regex.*
java.net.*
java.io.*
java.math.BigDecimal
java.math.BigInteger
Groovy的一切都是对象，可以自动装箱与拆箱
1.GDK数值方法：
3.times{println'Hello'} 执行几次
store=''
1.upto(5){number->store+=number}(一个数字从多少到多少执行)
store=""
2.downto(-2){number->store+=number+""}｛结果为210-1-2｝
store=""
0.step(0.5,0.1){number->store+=number+""}｛结果为00.10.20.30.4｝
2.表达式与运算符
基于方法的运算符（groovy中运算符都是基于方法的简写）
a==b等价a.equals(b)
Groovy的“===”就是Java的“==”
Groovy支持操作符重载，重载运算符对应的方法就是操作符重载
<<操作符被重载，以支持向集合添加项
？安全引用操作符（防止NullPointException）,在方法调用前面添加一个？就相当于在调用前面放了一个条件，可以防止在null对象上调用方法。？操作符时刻都非常有用，可以极大地减少条件语句。
基于方法的运算符：
assert 4**3==64 //4.power(3) assert 4/3==1.33333333333//4.div(3) assert 4.intdiv(3)==1 //整除 assert !(4==3) //!(r.equals(3)) assert 4!=3 //!4.equals（3） asser 4<=>3==1 //4.compareTo(3)
3.字符串GString简介：
groovy中字符串可以用单引号与双引号引用。
但是如果字符串有变量，则要用双引号，否则输出原字符串
def name ='lxl800'
print "\thello ${name}"
原格式输出：
print '''
aaa
bbb
'''
三个双引号可以解释其中的GString
def name="lxooi"
print """
aaa
\tbbb
${name}
...."""
4. Groovy方法：
可以直接使用Java的方法
变量作用域与Java方法类似
可以使用动态类型或静态类型
可以省略return,默认返回最后语句的值
Groovy方法可以使用默认参数。
def welcom2(name,welcomStr="Welcomd"){
print "${welcomeStr} ${name}"
}
welcome2('1xt') //输出：Welcome 1xt
welcome2("1xt",'Good')//输出Good 1xt
优先选择精确匹配参数个数的方法。
方法参数是传值调用
在方法内部修改的参数是副本，实际上并没有修改真正的参数
5. 流程控制：判断
if的条件除了布尔值外，也可以是对象，如果对象是空则条件为false,如果不为空则为true.
switch结构二
def var=0
switch(var){
case 0: println "one"
case 11..20 println "two"
case '10' println "three"
case [1,2,3]: println "four"
case {it % 3==0}: println "six"
case ~'[0-9]{3}': println "seven"
default: println "Default"
}
switch参数可以为任意的数值
6. 控制台输入输出
读取标准输入：
def name = new BufferedReader(new InputStreamReader(System.in)).readLine()
println "your name is :${name}"
7.集合概述：
1.Groovy直接在语言内使用集合。
不需要导入专门的类，也不需要初始化对象
集合是语言本身的本地成员
2.每个Groovy集合都是java.util.Collection或java.util.Map的实例
3.List,String,StringBuffer,Range,Map,File，Matcher都使用统一的size()方法获取长度。
7.1 列表List(中括号在groovy中可以表示列表)
def toys=[['a','001'],['b','002'],['c','003']] println toys.class //输出java.util.ArrayList println toys[1] println toys.get(1) println toys[-2] //输出倒数第二个 println toys[1..<2]//输出从1开始排除第二个的所有元素 toys.putAt(2,[33,'333'])也是修改 toys<<[4,'004']//追加元素 //连接列表 toys1=[1,2,3] toys2=toys1+[4,5] toys3=toys2-[5]//列表中删除元素 def list=[1,2,3,4] list.add(5)//1,2,3,4,5 list.add(2,11)//1,2,11,3,4,5 list.addAll([6,7])//1,2,11,3,4,5,6,7 list.contains(11)//true list.containsAll([11,4])//true list.indexOf(11)//2 list.remove(2)//1,2,3,4,5,6,7 list.removeAll([5,6,7])//1,2,3,4 list.clear()//[]
特别注意有些方法会修改原列表，有些方法不修改原列表，而只是产生新的列表。其中差异不能不防！！
def fList=[1,2,3,[4,5]] fList.flatten()//[1,2,3,4,5],展开后返回新列表，原列表并没有修改 fList.intersect([3,4,5])//[3],求交集，返回新列表 fList.pop()//[4,5],删除列表最后元素 fList.reverse()//[3,2,1],反转列表返回新列表 fList.sort()//[1,2,3] def gList=[1,1,2,3,4,3] println gList.count(3) //输出：2有两个3
7.2 映射：
def bookMap=[:]//定义空map
println bookMap.getClass()//输出：class java.util.LinkedHashMap
def toyMap=[1:'toy1',2:'toy2']
assert toyMap.containsValue('toy1')//true
assert toyMap.containsKey(1)//true
println toyMap//输出整个map
println toyMap[2]//用下标输出键对应的值
println toyMap.get(1)//get(key)
toyMap.each{
toy->
println toy.key+":"+toy.value
}//each方法参数为闭包
toyMap.each{
println it.key+":"+it.value
}//使用默认闭包参数it遍历map
toyMap.put(3,'toy3')//往map中加入元素，如果键存在，则替换
toyMap.remove(3)//按键删除
toyMap.keySet()//获取Map中的key
toyMap.values()//获取map中的值
toyMap.values().asList()//转换成ArrayList
7.3 范围
def aRange =1..<5
println aRangee//输出：【1，2，3，4】
println aRangee.class//输出class groovy.lang.IntRange
assert aRange instanceof List //true
(1..<5)范围就是IntRang的对象，是特殊的List
def bRange='a'..<'e'
println bRange//输出：【'a','b','c','d'】
prinltn bRange.class//输出 groovy.lang.ObjectRange
assert bRange instanceof List //true
('a'..<'e')是ObjectRange的对象，是特殊的List
def cRange=5..1
println cRange //输出5，4，3，2，1
def dRange='e'..<'a'
println dRange//输出e,d,c,b
在groovy中范围可以使用倒序
def eRange=1..10 println eRange.size()//输出10 println eRange.contains(5)//true println eRange.get(8)//参数为索引，输出9 println eRange.getFrom()//输出1，返回第一个 println eRange.getTo()//输出10 println eRange.isReverse()//输出false prinltn eRange.subList(3,6)//输出【4，5，6】 groovy字符串处理方法： def 'Groovy&Grails&l008' println str1[1..2]//ro println str1[1..<3]//ro println str1[4..2]//voo println str1[4,1,6]//vr&
<=>符号类似于compareTo()方法，只是<=>返回的-1，0，1.而compareTo()方法返回的则是一个字符比较的值
println 'Groovy'*3//GroovyGroovyGroovy
def str2="Groovy"
println'[${str2.center(11)}]'//[ Groovy ]
println '[${str2.center(3)}]'//[Groovy]
println'[${str2.center(11,"=")}]'//[==Groovy===]
println'${str2.contains("Gr")}'//true
println "${str2.count('o')}"//2
println "${str2.count('oo')}"//1
println str2.leftShift(' world')//Groovy world
println str2<<" world"//Groovy world
printlnstr2.minus('vy')//Groo
printlnstr2-'vy'//Groo
printlnstr2.next()//Groovz ++运算符
println str2.previous()//Groovx --运算符
def str3 = "lxt008"
println '[${str3.padLeft(4)}]'//lxt008
println '[${str3.padLeft(11)}]'//[ lxt008]
println '[${str3.padLeft(11,"#")}]'//[#####lxt008]
//padRight()类似
def str4 = "Groovy&Graids&lxt008"
prinlt str4.replaceAll('[a-z]'){ch->ch.toUpperCase()}//GROOVY&GRAILS&LXT008
println str4.toCharacter()//G
println '123'.toDouble()
//toFloat()/toInteger()/toLong()类似
println str4.toList()//['G','r','o'..]
println str4.tokenize()//["Groovy&Grail&lxt008"],无空格(默认根据空格来分词)
println str4.tokenize('&')//["Groovy","Grails","lxt008"]返回一个list