Groovy基本语法(3)

5、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 "rn"


// 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 "rn"



// 例子，利用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循环结构作了如下的修整：

1. 对于for循环：除了传统三表达式的for循环和用于迭代的for each循环外，Groovy允许for循环遍历一个范围（Range），例如?for (i in 1..10)，表示循环10次，i在1至10之间取值；
2. 对于整数，Groovy增加了如下几个方法来进行循环：
   1. upto：n.upto(m)?函数，表示循环 m- n 次，并且会有一个循环变量it，从n开始，每次循环增加1，直到m。循环体写在upto方法之后大括号中，表示一个闭包，在闭包中，it作为循环变量，值从a增长到n；
   2. times：n.times 函数，表示循环n次，循环变量it从0开始到n结束。
   3. 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:windowssystem'
println s
s = /c:windowssystem/		// 利用/字符串/定义的字符串
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增加了对字符串的如下操作：

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

? ? ? Groovy对字符串增强了很多，使其更加方便使用，也更加符合主流动态语言的语法设定，当然这里面很多内容并不是简单的针对字符串的，例如Groovy的闭包，运算符重载等特性，都侧面的让Groovy字符串更加强大；