Groovy笔记1(特性，字符串处理，集合，运算符)

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