Groovy的美妙

什么是Groovy?

Groovy是一种基于JVM的语言。如果说Java是基础,那么Groovy可以说是Java 2.0。

但是这里不是完全的取代,而是可以和Java共存,使程序更加的完美。它能够简化很多Java代码,甚至有的时候要比Java的效率还要快。Groovy在书写上更像Java,虽然它的语法源于Smalltalk、Ruby这类语言,但是我们完全可以把它想像成Java的变体语言。

Groovy的特点:

  • Groovy指定的内容,都是public,除非自己另行指定。
  • Groovy在Java对象上增加了一些快捷方式及方法,更利于使用
  • Groovy省略了变量的类型声明。比如String str=””; 在Groovy里,就可以不用写
  • Groovy与Java对比,是动态的,Java在定义对象类型是固定的,属于固定型语言。String str=”xxx”
  • Groovy不必像Java那样先编译再运行,因为它属于脚本语言。脚本语言的特点就是在运行时进行解析。

还有个非常流弊的概念,在Groovy里,一切皆对象!(你也是对象,我也是。。。)

举例:

用Java书写Hello world:

1
2
3
4
5
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

用Groovy书写Hello world,定义一个文件.groovy,

1
println "Hello World!"

然后命令:

1
groovy MyFirstExample.groovy

这里我们运用Groovy,也可以像Java一样,编译文件成字节码形式,运用groovyc命令,同样编译.java文件成.class文件。

——— 我们来举个例子,来说明下,Groovy就是Java,

这里我们可以用InteliJ IDEA来去做

类型的定义

在java中,一个对象得指明是什么类型,比如

1
String name = "张三";

在Groovy中,我们可以这样

1
def name = "张三"

无类型对象的好处,可以自动去识别对象的类型,减去很多的工作。并且,Groovy 缺少类型能够带来更高的灵活性 — 不需要接口或抽象类

流程控制语句

在java中

1
for(i = 0; i < 5; i++)

在Groovy中

1
2
3
4
5
def repeat(val){
for(i in 0..5){
println val
}
}

集合

可以用如下表达一个数组

1
2
3
4
def arr = 0..10
println(arr.class)
println(arr)
assert arr instanceof List

groovy不仅仅就这么简单,其实在背后,一切都是标准的Java对象。每个Groovy集合,都是java.util.Collection或者java.util.Map的实例

进行元素的添加:

1
2
3
4
coll.add("Python")
coll << "Smalltalk"
coll[5] = "Perl"
coll + "CC"

操作数据

1
2
3
def numbers = [1,2,3,4]
assert numbers + 5 == [1,2,3,4,5]
assert numbers - [2,3] == [1,4]

分布操作符:

join:替换分隔符

1
2
3
def number = [1, 2, 3, 4]
number = number.join(".")
println(number)

count:获取下标

1
assert [1,2,3,4,3].count(3) == 2

toUpperCase:全部转换为大写:

1
2
def arr = ["java", "groovy", "c"]*.toUpperCase();
println(arr)

Groovy映射

在Java里,映射是这样的

1
2
3
Map<String, String>map = new HashMap<String, String>();
map.put("name", "Andy");
map.put("VPN-#","45");

在Groovy里,是这样

1
2
3
def hash = [name: "andy", "VPN-#": 34]
println(hash)
println(hash.getClass())

Groovy闭包

我们都知道Groovy就是Java,所以在迭代上,我们可以这样做

1
2
3
4
5
6
def acoll = ["Groovy", "Java", "Ruby"]

for (Iterator iterator = acoll.iterator(); iterator.hasNext();){
println "123"
println iterator.next()
}

实际在for循环中不需要类型声明,不必获取Iterator实例并直接操纵它,可以直接在集合上进行迭代。

其实上面,可以改造成这样

1
2
3
4
5
def acoll = ["Groovy", "Java", "Ruby"]

acoll.each{
println it
}

这样each直接在acoll内进行调用。因为acoll实例实际是ArrayList,所以each是一种新语法,可以遍历出内容。这里,由{ }包围起来的代码块就是闭包

闭包中的 it 变量是一个关键字,指向被调用的外部集合的每个值 — 它是默认值,可以用传递给闭包的参数覆盖它。下面的代码执行同样的操作,但使用自己的项变量:

1
2
3
4
5
def acoll = ["Groovy", "Java", "Ruby"]

acoll.each{ value ->
println value
}

在这个示例中,用 value 代替了 Groovy 的默认 it

再说迭代

我们再说刚刚的map

用Java语言,进行迭代

1
2
3
4
5
6
7
8
9
Map<String, String>map = new HashMap<String, String>();
map.put("name", "Andy");
map.put("VPN-#","45");


for(Iterator iter = map.entrySet().iterator(); iter.hasNext();){
Map.Entry entry = (Map.Entry)iter.next();
System.out.println(entry.getKey() + " : " + entry.getValue());
}

但是我们用Groovy进行迭代:

1
2
3
4
def map = ["name": "张三", age: 12]
map.each { key, value ->
println key + " " + value
}

既然是闭包,我们可以在使用时灵活多变。比如带参函数

1
2
3
static def excite = { world ->
return "${world}!!"
}

调用时就可以

1
println excite("CC")

Groovy 中的“类”

定义一个People类

1
2
def people = new People(name: '张三', age: 12)
println people.name

而且还生成了标准的setter和getter方法

如果直接输出people,我们可以看到输出的对象People,甚至我们还可以复写toString方法

1
2
3
4
5
6
println people
···
@Override
String toString() {
return "${name}, ${age}"
}

如果这个时候,在return下再输出一行数据,该是什么结果呢?

1
2
3
4
5
@Override
String toString() {
"${name}, ${age}"
"123"
}

return没了,这是因为我们Groovy不需要return语句,并且Groovy默认返回方法的最后一行。

null的判断

比如这里我定义People类

1
2
3
4
5
6
7
8
9
10
11
12
13
class People {
def name
def age

def getName() {
name.toUpperCase()
}

@Override
String toString() {
"${name}, ${age}, ${getName()}"
}
}

定义主类:

1
2
3
4
5
6
7
8
class Hello {

static void main(args) {

def people = new People(age: 12)
println people
}
}

这样直接运行会导致null。那么为了避免这个问题,我们可以在People类里,这么写

1
2
3
4
5
6
7
8
9
10
11
12
13
class People {
def name
def age

def getName() {
name?.toUpperCase()
}

@Override
String toString() {
"${name}, ${age}, ${getName()}"
}
}

这样就不会null了。

总结

Groovy 是没有类型、没有修改符、没有 return、没有 Iterator、不需要导入集合的 Java。简而言之,Groovy 就是丢掉了许多包袱的 Java,这些包袱可能会压垮 Java 项目。

Groovy 就是 Java。