分类： Android技术

Groovy中的循环
可以说，Groovy把Java循环结构折腾的面目全非，似乎主流脚本语音能用到的循环方式Groovy都给加了进去，实际上不同的循环语法和功能差异很小，这类玩意儿多了意义并不明显，例如我就比较喜欢for循环而不太爱用while循环，但并不是说while循环没有用处，虽然for循环完全可以涵盖while循环的所有功能。
Groovy的开发者目标很明确，让Groovy的语法甜的腻死你们！

package plswg.edu.groovy.basic

// groovy中可以使用传统的while循环或for循环

n = 0
while (n < 10) {
print n + ” ”
n++
}
println “”

for (i = 0; i < 10; i++) {
print i + ” ”
}
println “\r\n”

// groovy引入新风格的for循环

for (i in 0 .. 9) { // (i in 0 .. 9)表示循环从i=0开始，到i<=9时结束
print i + ” ”
}
println “”

// 利用数值类型可以也可以进行循环

// 利用整数的upto方法进行循环
i = 0
i.upto(9) { // 整数的upto方法可以启动一个循环, 循环体在一个闭包内执行
print it + ” ” // 在闭包内部，it关键字表示循环过程的整数值
}
println “; at the end of loop, the var i is ” + i // 循环结束后i的值仍是0，不会增加到9

// upto方法可以用在常量上
10.upto(19) { // 10.upto(20)表示从10开始循环到19结束
print it + ” ”
}
println “”

// upto方法中的整数是循环的起始点，time方法可以将整数作为循环的终止点
10.times { // 10.times表示从0开始循环到9结束
print it + ” ”
}
println “”

// step方法可以设置循环的步长值
0.step(11, 2) { // 0.step(11, 2)表示从0循环到11，每次循环值增加2
print it + ” ”
}
println “\r\n”

// 例子，利用groovy新语法输出一个99乘法表
// 方法1
for (i in 1 .. 9) {
for (j in 1 .. 9) {
z = i * j
print ((z < 10 ? ” ” + z : z) + ” “)
}
println “”
}
// 方法2
1.upto(9) {
x = it
1.upto(9) {
z = x * it
print ((z < 10 ? ” ” + z : z) + ” “)
}
println “”
}
// 方法3
9.times {
x = it + 1
9.times {
z = x * (it + 1)
print ((z < 10 ? ” ” + z : z) + ” “)
}
println “”
}
可以看到，Groovy对Java循环结构作了如下的修整：
对于for循环：除了传统三表达式的for循环和用于迭代的for each循环外，Groovy允许for循环遍历一个范围（Range），例如 for (i in 1..10)，表示循环10次，i在1至10之间取值；
对于整数，Groovy增加了如下几个方法来进行循环：
upto：n.upto(m) 函数，表示循环 m- n 次，并且会有一个循环变量it，从n开始，每次循环增加1，直到m。循环体写在upto方法之后大括号中，表示一个闭包，在闭包中，it作为循环变量，值从a增长到n；
times：n.times 函数，表示循环n次，循环变量it从0开始到n结束。
step：n.step(x, y) 函数，表示循环变量从n开始到x结束，每次循环后循环变量增加y，所以整个循环次数为 (x – n) / y 次；
6、字符串

Groovy对字符串增加了一些新的特性，让字符串操作更加简单了：

package plswg.edu.groovy.basic

// groovy中对字符串的使用做了大量的简化

// 获取字符串中的字符
s = “Hello”
println s[0] // 输出’H’

// 遍历字符串中的所有字符
s.each {
print it + “, ” // 遍历字符串中的所有字符
}
println “”

// 截取字符串
s1 = s[1..3] // 截取s字符串标号从1到3的3个字符，组成新的字符串赋予s1
// 该语法是String类的substring方法的简化
println s1

// 模板式字符串

n = 100
s1 = “The number n is ${n}” // ${n}表示将变量n的值放在字符串该位置
println s1

// 带格式的长字符串
// “””和”””之间的所有字符都会被算做字符串内容，包括// /*以及回车，制表符等
s = “””
大家好
欢迎大家学习Groovy编程
Groovy is a better Java
“””
println s

// groovy中单引号的作用

// 在不定义类型时，单引号也表示字符串
c1 = ‘A’
println c1.getClass().getName()

// 要明确的定义字符类型，需要给变量增加定义
char c2 = ‘A’
println c2.getClass().getName()

// 取消转义字符
s = ‘c:\\windows\\system’
println s
s = /c:\windows\system/ // 利用/字符串/定义的字符串
println s

// 字符串运算
s = “hello”
s = s + ” world” // +运算符用于连接字符串
println s

s -= “world” // -可以从字符串中去掉一部分
println s

s = s * 2 // *可以让字符串重复n次
println s

// 字符串比较
s1 = “Abc”
s2 = “abc”

println s1 == s2 ? “Same” : “Different” // 执行s1.equals(s2)
println s1 != s2 ? “Different” : “Same” // 执行!s1.equals(s2)
println s1 > s2 ? “Great” : “Less” // 执行s1.compareTo(s2) > 0
println s1 < s2 ? “Less” : “Great” // 执行s1.compareTo(s2) < 0
// s1 >= s2, s1 <= s2
println s1 <=> s2 == 1 ? “Same” : “Different” // 执行s1.compareTo(s2)
Groovy增加了对字符串的如下操作：
集合操作，Groovy将字符串看为字符的集合，可以通过 [n] 运算符直接访问字符串内的字符，也可以通过each循环遍历字符串的每一个字符；
截取子字符串的substring方法被简化为使用数值范围来进行截取，”hello”[1..3]表示截取字符串”hello”从下标为1到下标为3的部分，结果为 “ell”；
Groovy增加了一个新的字符串类型 GString，这种字符串可以进行格式化，在GString字符串中使用 ${变量}，可以将该变量的值放入字符串的相应位置；
带格式的字符串，使用 “””字符串内容”””(连续的三个引号)，这种字符串中可以包含直接输入的回车，TAB键，//或/*等字符，而这些在Java原本的字符串里，都必须通过转义字符来表示，例如只能用\n表示回车；
单引号问题，和Javascript和PHP类似，Groovy中无论是单引号还是双引号都表示是字符串类型，例如 ‘a’ 和”a”都是字符串类型，所以如果要确定存储一个 char 类型变量，就必须使用 char 类型定义强类型变量；实际上Groovy认为char类型并不是必须的，大部分时候字符串类型更方便一些；
用 / 包围的字符串，即 /字符串内容/，可以避免在字符串中使用转义字符，但 \n 字符不包含在内；
Java中对字符串的运算只有+运算，在Groovy中，字符串还可以使用 -运算 和 *运算，减法运算可以从一个字符串中删除一部分，乘法运算可以将一个字符串重复n次；
Groovy还为字符串加入了所有关系运算符，包括 ==, !=, >, <, >=, <=，这要归功于Groovy允许运算符重载，对于 == 和 !=，将调用String类的equals 方法，对于 >, >=, <, <=，将调用String类的compareTo方法；Groovy还增加了一个特殊的运算符<=>，这个运算符也会调用 compareTo 方法，返回 compareTo 方法的返回值；
Groovy对字符串增强了很多，使其更加方便使用，也更加符合主流动态语言的语法设定，当然这里面很多内容并不是简单的针对字符串的，例如Groovy的闭包，运算符重载等特性，都侧面的让Groovy字符串更加强大

静态import

我是*早在.net framework 3.5上使用类似import static这种语法的，用起来相当方便的说，但JDK一直没有引入这玩意儿，按道理说加上这么个小功能是很容易实现的。不过Groovy倒是带来来功能更强大的import static语法，用起来也很方便：

package plswg.edu.groovy.basic

// 将Integer类的MAX_VALUE静态成员变量引入
import static Integer.MAX_VALUE

// 将Double类的parseDoubl静态成员方法引入
import static Double.parseDouble

// 给静态引入赋予别名
import static Boolean.TRUE as T // 将Boolean.TRUE取名为T
import static Boolean.FALSE as F // 将Boolean.FALSE取名为F

// 给静态引入的方法赋予别名
import static Calendar.getInstance as now

// 代码中凡是用到MAX_VALUE, 指的都是Integer.MAX_VALUE
println MAX_VALUE

// 代码中凡是用到parseDouble, 指的都是Double.parseDouble
s = “123.123”
println parseDouble(s);

// 代码中凡是使用T的地方表示true，使用F的地方表示false
println T
println !T
println F

// 代码中凡是使用now的地方表示Calendar.getInstance
println now().get(Calendar.HOUR)
这玩意儿的主要作用就是避免重复书写哪些又臭又长的类名，随着JDK类库的不断增加，类名字是越来越长，像造句一样，import static恰好解决了这一问题，还是很贴心的。
5、分支结构语句

Groovy的结构化语句仍旧是三种：顺序结构、分支结构和循环结构，其中分支结构和循环结构增加了很多意想不到的功能，先看分支结构：
package plswg.edu.groovy.basic

// groovy中if条件分支的新规定

// groovy中，非0的数值可以表示true
int num = 0
if (num) {
println “True”
} else {
println “False”
}

println (++num ? “True” : “False”)

if (!!num) { // !!运算符可以将num转化为boolean类型
println “num=${num}为${!!num}”
}
println “”

// 引用为null时，表示false
Object o = null
if (o) {
println “True”
} else {
println “False”
}
o = new Date()
if (o) {
println “True”
} else {
println “False”
}
println “”

// 字符串为””时，表示false
String s = “”
if (s) {
println “True”
} else {
println “False”
}
s += “hello”
if (s) {
println “True”
} else {
println “False”
}
println “”

// 集合为空时，表示False
ArrayList array = new ArrayList()
if (array) {
println “True”
} else {
println “False”
}
array.add(100)
if (array) {
println “True”
} else {
println “False”
}
println “”

// groovy中switch选择分支的新规定

// switch对字符串类型的支持

print “Please input your words: ”
s = new BufferedReader(new InputStreamReader(System.in)).readLine()

switch (s) {
case “how are you”:
println “fine, thank you”
break;
case “how do you do”:
println “how do you do too”
break;
default:
println “nice to meet you”
}

// switch对集合和范围的支持
n = new Random().nextInt(101)
print “you got ${n} point, ”
switch (n) {
case [98, 99, 100]: // n为98, 99, 100这三个数字时
println “very good!!”
break;
case 90 .. 97: // n为90-97之间时
println “nice job!!”
break;
case 70 .. 89: // n为70-89之间时
println “good”
break;
case 60 .. 79: // n为60-79之间时
println “can be better”
break;
case {it > 0 && it < 60}: // n比0大且比60小时
println “too bad”
break;
case 0: // n为0时
println “nothing to say”
break;
}
首先，Groovy对boolean类型放宽了限制：
常量true和false分别表示“真”和“假”；
null表示false，非null表示true；
空字符串””表示false，非空字符串表示true；
0表示false，非0表示true；
空集合表示false，非空集合表示true；
好了，从这一角度上，Groovy确实和Javascript或者PHP非常相似了，用起来非常方便。
Groovy中对于switch语句的修改也是非常夸张的，这让我甚至有些怀疑Groovy中的switch是否还能达到O1的执行效率，因为Groovy的swtich表现的太像嵌套的if…else if了，在例子中，switch的case后面可以跟随如下几种玩意儿：

常量，在Groovy中，case后的常量包括数值型常量或字符串类型常量，方便很多了，JDK7中新增加了使用字符串常量的case语句，而在.net framework 1.1中早就有了，诸如Basic，PHP，Python，Javascript等脚本，更是一开始就支持字符串常量的case语句；
Range：即范围，语法 n1 .. n2 表示n1和n2之间的所有数值n（n1 <= n <= n2）；
Collection：集合，语法 [a1, a2, a3, … , an]，表示由中括号中的n个元素构成的集合，其中各个元素类型不必统一；
闭包：由 { 语句 } 构成的匿名函数体，这个后面会重点讲述，这里只要知道，一旦case之后的闭包返回true，则冒号之后的代码将会执行；
总之Groovy对分支语句的改造，让其更符合主流动态语言的特点，目前大家都在玩动态语言，就算强类型语言例如C#也在向动态语言方向靠拢，C++有泛型可以一直淡定，Java也有泛型，但那就不是个玩意儿。Groovy这下改的彻底，该有的全都有了！