groovy基础_groovy-bom

groovy

基本语法

groovy默认会导入以下库

import java.lang.* 
import java.util.* 
import java.io.* 
import java.net.* 

import groovy.lang.* 
import groovy.util.* 

import java.math.BigInteger 
import java.math.BigDecimal
1
2
3
4
5
6
7
8
9
10

groovy语句可以不加分号；

数据类型

Groovy提供多种内置数据类型。以下是在Groovy中定义的数据类型的列表

• byte -这是用来表示字节值。例如2。
• short -这是用来表示一个短整型。例如10。
• int -这是用来表示整数。例如1234。
• long -这是用来表示一个长整型。例如10000090。
• float -这是用来表示32位浮点数。例如12.34。
• double -这是用来表示64位浮点数，这些数字是有时可能需要的更长的十进制数表示。例如12.3456565。
• char -这定义了单个字符文字。例如“A”。
• Boolean -这表示一个布尔值，可以是true或false。
• String -这些是以字符串的形式表示的文本。例如，“Hello World”的。

Groovy还允许其他类型的变量，如数组，结构和类，我们将在后续章节中看到。
其中对于数字类的还支持java中的包装类型：数字类
类型除了基本类型，还允许以下对象类型（有时称为包装器类型）-
java.lang.Byte
java.lang.Short
java.lang.Integer
java.lang.Long
java.lang.Float
java.lang.Double

定义变量有两种方式：普通java语法和def关键字
println可以打印字符串和变量的值。是groovy自身实现的。

运算符

感觉groovy支持java所有的运算符，优先级也是类似的。
但是有个范围运算符比较特殊：可以把一个范围存储在一个对象中

class Example { 
   static void main(String[] args) { 
      def range = 5..10; 
      println(range); 
      println(range.get(2)); 
   } 
}
[5, 6, 7, 8, 9, 10] 
7
1
2
3
4
5
6
7
8
9

控制流程

while和for语句的用法跟java一样。break和continue也支持。
多了个for in的用法，可以遍历范围，也可以遍历map。

class Example { 
   static void main(String[] args) { 
      int[] array = [0,1,2,3]; 

      for(int i in array) { 
         println(i); 
      } 
   } 
}
1
2
3
4
5
6
7
8
9

方法

• 支持原生的java方法定义和通过def关键字定义。可以添加修饰符，如public，private和protected。默认情况下，如果未提供可见性修饰符，则该方法为public。
• 静态方法可以通过类直接调用，静态方法只能调用静态方法。实例方法需要由对象来调用。

- 通过def定义方法时，可不指定参数类型，可指定参数默认值。默认参数只能放在之后。

def someMethod(parameter1, parameter2 = 0, parameter3 = 0) { 
   // Method code goes here 
}
1
2
3
4

def

通过def关键字定义的变量是动态类型的，跟脚本语言一样，只有在运行时才能确定。

字符串

Groovy提供了多种表示String字面量的方法。 Groovy中的字符串可以用单引号（’），双引号（“）或三引号（”“”）括起来。此外，由三重引号括起来的Groovy字符串可以跨越多行。
groovy对字符串的方法进行了扩展：多支持了center，padLeft等

class Example { 
   static void main(String[] args) { 
      String a = 'Hello Single'; 
      String b = "Hello Double"; 
       String c = '''Hello Triple" aa
                "Multiple lines''';

      println(a); 
      println(b); 
      println(c); 

      println(sample[4]); // Print the 5 character in the string

      //Print the 1st character in the string starting from the back 
      println(sample[-1]); 
      println(sample[1..2]);//Prints a string starting from Index 1 to 2 
      println(sample[4..2]);//Prints a string starting from Index 4 back to 2 
   } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

范围

范围是指定值序列的速记。范围由序列中的第一个和最后一个值表示，Range可以是包含或排除。包含范围包括从第一个到最后一个的所有值，而独占范围包括除最后一个之外的所有值。这里有一些范例文字的例子 -

1..10 - 包含范围的示例
1 .. <10 - 独占范围的示例
‘a’..’x’ - 范围也可以由字符组成
10..1 - 范围也可以按降序排列
‘x’..’a’ - 范围也可以由字符组成并按降序排列。

序号 方法和描述
1 contains() 检查范围是否包含特定值
2 get()返回此范围中指定位置处的元素。
3 getFrom()获得此范围的下限值。
4 getTo()获得此范围的上限值。
5 isReverse()这是一个反向的范围，反向迭代
6 size()返回此范围的元素数。
7 subList()返回此指定的fromIndex（包括）和toIndex（排除）之间的此范围部分的视图

列表

列表是用于存储数据项集合的结构。在Groovy中，List保存了一系列对象引用。List中的对象引用占据序列中的位置，并通过整数索引来区分。列表文字表示为一系列用逗号分隔并用方括号括起来的对象。

要处理列表中的数据，我们必须能够访问各个元素。 Groovy列表使用索引操作符[]索引。列表索引从零开始，这指的是第一个元素。

以下是一些列表的示例 -
[11，12，13，14] - 整数值列表
[‘Angular’，’Groovy’，’Java’] - 字符串列表
[1，2，[3，4]，5] - 嵌套列表
[‘Groovy’，21，2.11] - 异构的对象引用列表
[] - 一个空列表

面向对象

groovy支持对象，继承，接口，内部类、抽象类的功能，用法跟java一样。
类中的属性会自动关联getter和setter方法。

闭包

闭包是一段代码。能够被执行，被传递，被存储。

class Example {
   static void main(String[] args) {
      def clos = {println "Hello World"};
      clos.call();

      def clos = {param->println "Hello ${param}"};
      clos.call("World");

      def clos = {println "Hello ${it}"};
      clos.call("World");

      def str1 = "Hello";
      def clos = {param -> println "${str1} ${param}"}
      clos.call("World");

      def lst = [11, 12, 13, 14];
      lst.each {println it}  // 闭包传递给each函数

      def mp = ["TopicName" : "Maps", "TopicDescription" : "Methods in Maps"]             
      mp.each {println it} // 定义闭包函数
      mp.each {println "${it.key} maps to: ${it.value}"}

      def lst = [1,2,3,4];
      lst.each {println it}
      println("The list will only display those numbers which are divisible by 2")
      lst.each{num -> if(num % 2 == 0) println num} // 闭包中使用条件
   } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

闭包本身也提供了一些方法：比如find，any等
find 方法查找集合中与某个条件匹配的第一个值。
句法
Object find(Closure closure)

class Example {
   static void main(String[] args) {
      def lst = [1,2,3,4];
      def value;

      value = lst.find {element -> element > 2}
      println(value);
   } 
}
1
2
3
4
5
6
7
8
9