版权声明：转载请申明出处，谢谢 https://blog.csdn.net/qq_35495763/article/details/85722207
总问题
如何实现cuI界的实现
附：找到groovy console 实现一些小片段。在里面可以实现一些小的代码
groovyConsole的位置
groovy 会自动到各种工具包
lang.*/util.*/lang.*/.........
数值的理解
groovy 中的一切都是对象，可以自动装箱与拆箱。
整数是Integer类的对象。
def price =100;
解释；price是动态对象，有groovy决定对象类型。
浮点数是BIgDecimal 类的对象。
方法数值的方法
10.times{store +=‘x’} times 执行次数
2.upto（num）方法从1到5
3.downto()从2到-2
4.step(num,num):0到0.5每次0.1步
二。运算符（本质是一个方法）
groovy 中
a==b等价于a.equals(b)
groovy 的 "==="等价于java中'=='
java不支持操作符重载，但是groovy 支持重载
注：？安全引用操作符（目的：防止空指针异常（NullPointerExcetiion))
再方法调用的前面添加？，可以防止null对象调用方法的错误即如果对象为空，无法调用调用方法。不会再次抛出异常了。
基于方法运算符：
4/3=1.33333由于所有数都是对象
4**3==64 (4的3次幂）
4.intdiv(3)== 1 整除
4<=>3 == 1(左边大1）
3<=>4 ==-1(右边大-1）
4<=> ==0 (相等为0）
字符串Gstring
def str=‘hello\n’；(单引号不输出转义字符）
def str1=“hello\n”（输出转义字符）
原格式输出的方式 print ‘’’
adb
cdd
"’
(三个引号，原格式输出）
groovy 方法
一：可以直接使用javafangfa，
作用域与java类似
静态类型，动态都可以使用
可以省略return语句，默认返回最后语句的值（最后语句的值是，决定了函数的返回值；
可以使用默认参数
def welcome2（name ,welcomestr="welcome"){
println "${welcomestr}${name}"
}
调用方式
//优先调用精确匹配参数个数的方法
welcome('lxt007') Welcome lxt007
welcome2('xlt008','Good') 输出Good lxt008
流程控制语句：
def count=1;def Limit=5;
while(count<=Limit){
println "count:${count}"
}
for(i=1;i<5;i++)
for (i in [1,2])
break ;continue 与java中相同
判断
if 的条件除了是bool值，可以是对象（对象为空打印false 否则打印true)
switch(var){
case 0: println "one"
case 11..20: println "two"
case '10':println "three"
case [1,2,3](列表）:
case Float :
case {it %3==0}:
case ~'[0~9]':
default: println “default"
}//注不要轻易添加java中的结束 ；符
可控制台输入：
System.in.readLine();//也已经删除了
def name=new BufferedReader(new InputStreamReader(System.in)).readLine()
课程第二章
学习集合List ，MAP的使用
list的特性
1.Groovy 不需要导包。
2.每个集合都是java.util.Collection java.util.Map的实例。
实例：
def toys=[['a',001],['2','002'],['3'],[003]] //定义列表
print toys.class //输出class
java.util.ArrayList //得到的结果
输出列表项
println tyos[1] //索引从0开始
println toys[-2]//输出倒数第二个
println toys.get(1)//获取值
println toys[1..<2]//输出
//符合赋值
toys[0]=['1','001']//修改第一个元素
toys.putAt(2,['3',003])//将第三个数据修改成
//添加元素
toys << ['4',004]//在集合的最后添加一个元素，leftshift()的重载运算符<<。
toys1=[1,2,3]
使用+号
toys=toys1+[4,5]//输出[1,2,3,4,5]
toys3=toys-[5]//输出[1,2,3,4]
//list的方法
def list=[1,2,3,4]
list.add(5)
list.add(位置2，元素11)//位置为索引位置
list.addAll([6,7])//将列表的元素所有追加进入，注意与add的区别
//判断
list.contains(11)//返回true
list.containsAll([11,4])
list.indexOf(11)//返回索引值
list.remove(2)//移除所以索引为2 的元素值
list.removeAll([5,6,7])
list.clear()//移除所有元素
//其他方法
def Flist=[1,2,,3,[4,5]]
Flist.flatten()//返回一个新的列表[1,2,3,4,5],没有修改原来的列表
Flist.intersect([3,4,5])//放回一个新的交集列表
Flist.pop()//删除最后一个元素
Flist.reverse()//返会一个新的倒转列表
Flist.sort()//排序
Flist.count(2)//某个元素出现的次数
映射Map的使用
//定义Map
def bookMap=[:]//定义一个新的列表
println bookMap.getClass()//返回linkedHashMap(Map的类型)
def toyMap=[1:'toys',2:'toys']
toyMap.containsKey();//查看是否包含某key
topMap.containsValue()//判断是否包含某值
关于Map的操作
println toyMap[2]//输出Key为2的值
同上含义：println toyMap.get(1)//key为1的值
使用闭包
toyMap.each{toy->
println toy.key+':'+toy.value
}//1:toys 2:toys()换行输出
toyMap.each{
println it.key+':'+it.vlaue
}//使用默认闭包参数it遍历map,1:toy1 2:toys
toyMap.put(3,'toy3')//添加元素，如果key 3已将存在，则替代他
toyMap.keySet()//以list的形式输出key
toyMap.values()//以list形式输出值
toyMap.values.asList()//转换成ArrayList
关于范围的使用
def aRange=1..<5
println aRange//[1,2,3,4]
pirntln aRange.class//输出class.groovy.lang.IntRange(类型)
asset aRange instanceof List//无错误
结论：（1..<5）是一个intRange的对象，是一个特殊的List。
def bRange='a'..<'e'
println bRange //输出['a','b','c','d']
def cRange=5..1
def dRange='d'..>'a'//[e,d,c,b]
//可以倒序输出
范围的方法的使用
size()大小，contains()包含某值，get()获取某值，getFrom()获取初始值，getTO()获取终值，isReverse()是否是倒序，subList(3,5)输出第四道到第六之间的值。但是不包含第六个元素
字符串的处理
//一：多行字符串 ''' 可以处理多行字符串
//字符串内部包含字符串内外部的引用不同 println 'Ixt008 and "groovy"'
//字符串的 比较<=> 。。。。返回-1,0，1
println 'lxt008' <=> 'Lxt008' =====1
println 'lxt008'.compareTo('Lxt008') ======32
print 'groovy'*3 ======groovygroovygroovy
println str1.length()
println str1-'$lxt008'======减去当前的字符与 minus()相同作用
groovy.compareToIgnoreCase('groovy')//忽略大小写进行比较
groovy.concat('')//连接字符串
endswith("")是否是结尾
indexOf("")位置索引
indexOf("G",6)从索引为6开始找，找的G
groovy.substring(2)//取子字符串索引二开始
groovy.substring(2,4)//从索引2到索引4（不包含4） 00两位
例子：
def str2="groovy"
println "[${str2.center(11)}]"占据11位居中显示,如果字符大于11位，则全部显式。
printLn "[${str3.padLeft(4)}]"//小于四位不变，大于四位时，补空，padLeft(11,#)->[######lxt008]11位左边补#
padright//具有类似的效果
println str2.leftShift("world")//groovy world 连接字符串,返回。原来 的字符串不变
println str2<< 'world' //这里原来的字符串不变
str2.next() //Groovy++向后移一个字符 groovy ->groovz
str2.previous()//groovy ->groovx
def str4="Groovy&Grails&lxt008"
println str4.replaceAll('[a-z]'){
ch->ch.toUpperCase()}全部转换成大写
toCharacter()//转换成字符G(只需要转换一个)
'123'.toDouble()转换类型toFloat()/toInteger()/toLong()
str.toList()转换成列表
=====
println str4.tokenize()//默认空格进行分词
str4.tokenize("&")//根据谷歌tokenize代表着tokenize 令牌化的含义(也就是分词)
正则表达式
~开头的字符串是模式Pattern对象
模式匹配
def aRegex=~'lxt'
println aRegex.class //输出class.java.util.regex.Pattern
println mat='lxt'=~'lxt'
print mat.class//class java.util.regex.Matcher的类
//模式匹配
//一部分匹配
assert 'lxt008'=~'lxt'
//精确匹配
assert !('lxt008'==~'lxt')//精确匹配
正则表达式的补充
在java中正则表达式\需要全部转化为两个\
用流程控制语句与方法实现闭包
1.闭包简介
形式上看：用{}包围的代码块就是闭包
println {}
输出￥——rn_closure1@10a2d64
结论一：闭包是一个匿名内部类的对象
def 可以给闭包取名字
//闭包的定义
def aClosure={
println 'Hello Closure'
}
//闭包的调用
aClosure.call()
aClosure()
结论二：闭包是一个可执行的代码块
参数化闭包
def bClosure={
println "hello ${it}"//it 是 一个默认的参数
}
调用时使用方法
bClosure.call('lxt008')
bClosure('lxt008')
bClosure "lxt008"
//指定显示参数
def cClosure={name,address->
println "${name},${address}"
}
调用：cClosure('lxt008','shenzhen')
//支持默认参数
def dClosure={name,address='shenzhen'->
......
}
关于作用域
闭包的返回值：与方法类似直接放回 最后一行的值，可以省略return 的语句。
用处:可以间接的方式对集合进行迭代。
//对list进行遍历
def citylist=['shenzhen','shanghai','beijing']
citylist.each{city->
println city+''
}
//对Map 的遍历
def citysMap=[1:'shenzhen',2:'beijing',3,'shanghai']
citysMap.each{city->//city 为一个cityMap中的一个值，不是Key，不是value
print city.key+''+city.value+''
}
//可以对字符串进行遍历，对范围进行遍历
闭包为参数的，迭代集合的方法
举例
//find
def value=[1,3,5,7,9].find{element-> element>6}
//collect
def list=[1,2,3,4].collect{elemen-> return element*element}
//不改变原来的值，返回修改后的一个新值
//any 判断任何一个元素成立，true，every每一个成立，true
//inject 的使用，实现迭代。
闭包的实质是一个匿名内部类
扩展：什么是匿名内部类
匿名内部类
关键字：是一个类，但是没有名字（他的建立过程由接口或者抽象类建立成（抽象类建立一个子类，同时创建一个实例））
