Groovy的基础

1.Groovy中的变量

1.1、变量的类型：基本类型（java中的int,float,double,byte,char,long,short）和对象类型(String等) （Groovy中最终都是对象类型）
int x = 10
println x.class //结果为：class java.lang.Integer

double y = 3.14
println y.class //结果为：class java.lang.Double

//由此可见，Groovy中的基本类型最终会被编译器包装成对象类型
1.2、变量的定义：强类型定义方式和弱类型def定义方式
def x1 = 10
def y1 = 3.14
def str = ‘groovy study’

println x1.class //class java.lang.Integer
println y1.class //class java.math.BigDecimal
println str.class //class java.lang.String

//强类型定义及定义的时候写明变量的类型，而def则由编译器自行推导变量的类型
强类型定义方式和弱类型def定义方式的选择：
变量就是应用于自己的类或者自己的模块而不会应用于其它类或者其他模块，推荐使用def类型，这样可以随时动态的转换为其它类型；
变量要用于其它类或是其它模块，强烈建议使用强类型定义方式。使用强类型定义的方式不能动态转换类型，才能使外界传入或者调用的时候不会对于数据的类型产生疑惑，这样就保证外界传入的数据一定是我们想要的正确的类型的数据。
def x1 = 10
println x1.class //class java.lang.Integer
x1 = “dynamic type conversion”
println x1.class // class java.lang.String

// def定义的类型，相当于Object类型，可以随时转换类型

2、字符串详解

2.1、String：和java中的String一样
2.2、GString
2.2.1 常用的三种定义方式
单引号定义:
//1.单引号定义的就是java中的String，内容即为’'内的字符串，并且不可更改
def str = ‘a single string’
println str.class //class java.lang.String

//有特殊字符同样的通过反斜杠转义
def str1 = ‘a single ‘special’ string’
三个单引号定义:
//2.三个单引号定义的是有格式的字符串，会直接按照我们写的格式进行输出，而不用像java中进行拼接
def trebleStr = ‘’‘line one
line two
line three ‘’’

def trebleStr2 = ‘’’
line one
line two
line three ‘’’

def trebleStr3 = ‘’’
line one
line two
line three ‘’’

println trebleStr
println trebleStr2
println trebleStr3

println trebleStr.class //class java.lang.String

/* trebleStr2比trebleStr多了一行空格，trebleStr3与trebleStr结果相同
line one
line two
line three

line one
line two
line three
line one
line two
line three
*/

//注意上面trebleStr、trebleStr2、trebleStr3的区别
双引号定义（最常用的方式）:可扩展的字符串
def name = “Groovy”
println name.class //class java.lang.String
def sayHello = “Hello $name”
println sayHello //输出：Hello Groovy
println sayHello.class //class org.codehaus.groovy.runtime.GStringImpl

//扩展内容还可以是表达式
def sum = “the sum of 2 and 3 equals ${2 + 3}”
println sum //输出：the sum of 2 and 3 equals 5

//String 和 GString之间可以相互调用和传递，不需要考虑它们之间的转换问题
2.3、String方法来源
java.lang.String原有的方法
DefaultGroovyMethods：是Groovy对所有对象的一个扩展
StringGroovyMethods：继承自DefaultGroovyMethods，重写了DefaultGroovyMethods中的许多方法，使这些方法更加适用于String使用
2.4、Groovy中常用的String方法
2.4.1.普通类型参数

字符串填充:
// center(Number numberOfChars,CharSequence padding) ,将字符串作为中心进行填充
def str = “groovy”
println str.center(5,“a”) //结果：groovy
println str.center(6,“a”) //结果：groovy
println str.center(7,“a”) //结果：groovya
println str.center(8,“a”) //结果：agroovya
println str.center(9,“a”) //结果：agroovyaa
println str.center(8) //结果： groovy ，不传padding代表以空格填充

//PS:当numberOfChars小于或等于str本身的长度时，不进行填充操作，大于则用pandding扩展至长度numberOfChars，从字符串的右边（尾）进行填充，再到左边（头）

//padLeft(Number numberOfChars,CharSequence padding) ,在字符串的左边进行填充

//c. padRight(Number numberOfChars,CharSequence padding),在字符串的右边进行填充
字符串比较
def str = “groovy”
def str2 = “Groovy”
println str.compareTo(str2) //32 结果大于0，str大于Str2
println str.compareToIgnoreCase(str2) //0 结果等于0，str等于忽略大小写的Str
println str2.compareTo(str) //-32 结果小于0，str2小于str
println str > str2 //true 可用操作符直接进行比较
println str == str2.toLowerCase() //true
获取字符串中的字符
def str = “groovy”
println str.getAt(0) //g
println str.getAt(0…1) //gr
println str[0] //g
println str[0…1] //gr
字符串中的减法（取差集）
def str = “groovy”
def str2 = “hello”
def str3 = “hello groovy”
def str4 = "groovy hello "

println str.minus(str2) //groovy, str中没有包含str2
println str.minus(str3) //groovy, str中没有包含str3
println str3.minus(str2) // groovy, str3中包含了str2 (注意结果包含了空格)
println str3.minus(str4) //hello groovy str3z中没有包含str4
println str3 - str //hello ,str3z中包含了str(注意结果包含了空格)
其它还有很多方法用到时看看即可
def str = “hello groovy”
println str.reverse() //yvoorg olleh,字符串反转
println str.capitalize()//Hello groovy,首字母大写
println str.isNumber() //false，是否全是数字

def str2 = “1234”
println str2.toInteger() //1234
println str2.toBigDecimal() // 1234
println str2.toDouble() //1234.0
//等一系列转化类型方法
2.4.2.闭包类型参数

方法中将闭包作为参数使用，可到闭包使用讲解中查看

3、逻辑控制

3.1、顺序逻辑
//单步往下执行
def name = “groovy”
println “hello $name”
3.2、条件逻辑
if/else
//与java中一致
def name = “hello groovy”

String subHello(String str) {
if (str.contains(“hello”)) {
return str - “hello”
} else {
return str
}
}

println subHello(name) // groovy(注意结果包含空格)
switch/case
//java中switch只能传入int类型、byte,char和short类型能自动提升为int类型、String类型和后来扩展的enum类型

//在groovy中，switch可以传入任性类型的数据进行匹配
String judgeType(Object x) {
def result
switch (x) {
case “string”:
result = “x is string”
break
case [4, 5, 6, 7,‘inList’]: //列表（数据结构中讲解）
result = “x is in list [4, 5, 6, 7,‘inList’]”
break
case 10…15: //范围range（数据结构中讲解）
result = “x is in range 10…15”
break
case Integer:
result = “x is Integer”
break
case BigDecimal:
result = “x is BigDecimal”
break
case List:
result = “x is List”
break
default:
result = “no match”
break
}
return result
}

def x = “string”
def x1 = 5
def x2 = 10
def x3 = 3
def x4 = 3.14
def x5 =[4,6]
def x6 =“hi groovy”
def x7 = “inList”
println judgeType(x) //x is string
println judgeType(x1) // x is in list [4, 5, 6, 7,‘inList’]
println judgeType(x2) // x is in range 10…15
println judgeType(x3) // x is Integer
println judgeType(x4) // x is BigDecimal
println judgeType(x5) // x is List
println judgeType(x6) // no match
println judgeType(x7) // x is in list [4, 5, 6, 7,‘inList’]
3.3、循环逻辑
while循环
与java中的while循环一致
def sum = 0
while(sum<10){
println sum++
}
for循环
/*
*范围中的for循环
*/
def sum = 0
for (i in 0…9) {
sum += i
}
println sum //45

sum = 0
/*
*list中的for循环
*/
for (i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) {
sum += i
}

println sum //45

/*
*map中的for循环
*/
for (i in [‘java’: 1, ’ groovy’: 2, ‘python’: 3]) {
println “key: ${i.key} value:${i.value}”
}
//key:java value:1
//key: groovy value:2
//key:python value:3