Groovy 基础学习1

1.基础学习

创建你的第一个 Hello World 程序

 class Example
     static void main(String[] args) {
         println('hello world');
 }

当我们运行上面的程序，我们就会得到以下结果：

 hello world

1.什么是Groovy

Groovy是用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。

Groovy是JVM的一个替代语言（替代是指可以用 Groovy在Java平台上进行Java编程），使用方式基本与使用Java代码的方式相同，设计时充分考虑了Java集成，这使Groovy 与 Java代码的互操作很容易。(注意:不是指Groovy替代java，而是指Groovy和java很好的结合编程。

2.基本语法

创建你的第一个 Hello World 程序

 class Example
     static void main(String[] args) {
         println('hello world');
 }

当我们运行上面的程序，我们就会得到以下结果：

 hello world

Groovy令牌

令牌可以是一个关键字，一个标识符，常量，字符串文字或符号

 println("hello world");

在上面的代码中，有两个令牌，首先是关键词的println 而接下来就是字符串的"hello world"。

Groovy注释

与Java类似

分号

就像Java编程语言，它需要具有分号在Groovy定义多个语句之间进行区分。

身份标识

标识符用来定义变量，函数或其他用户定义的变量。标识符以字母开头，美元或下划线。他们不能以数字开头。例：

def employeename
 def student1
 def student_name

其中，def是在Grovvy用来定义标识符的关键字

关键字

关键字作为名称建议是在Groovy编程语言中保留的特殊字。T

有：as、assert、break、case、const等等，与java类似。

3.数据类型

内置数据类型：

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”的。

类型除了基本类型，还允许以下对象类型（也叫包装类）

java.lang.Byte
java.lang.Short
java.lang.Integer
java.lang.Long
java.lang.Float
java.lang.Double

此外，以下类可用于支持高精度计算：

java.math.BigInteger 不可变的任意精度的有符号整数数字如：30克
java.math.BigDecimal 不可变的任意精度的有符号十进制数如：3.5克

 class Example
     static void main(String[] args) {
         int x = 5;
         
         long y = 100L;
         
         float a = 10.56f;
         
         double b = 10.5e40;
         
         BigInteger bi = 30g;
         
         BigDecimal bd = 3.5g;
         
         println(x);   // 5
         println(y);   // 100
         println(a);   // 10.56
         println(b);   // 1.05E41
         println(bi);  // 30
         println(bd);  // 3.5
 }

List

 def list = []
 def list = [1,2,3]
 def list = ["a","b","c"]
 list.each({
     item -> log.info(item)  //循环取出 a b c
     return                  //return是退出闭包的意思
 })

Map

 def map = [:]  //空map
 
 def map = ["a":"val1","b":"val2"]
 
 map.each({
     a,b ->
     log.info("key:" + a + "  " + "value:" + b)
 })
 
 // key:a value:val1
 // key:b value:val2

字符串

 def str = 'a'
 def str = "a"
 
 def map = ["a":"val1","b":"val2"]
 map.each({
     a,b ->
     log.info("key:$a value:$b")
 })
 // key:a value:val1
 // key:b value:val2
 
 //注意，只有使用"" 号时，才可以使用$符号取出值

4.变量

Groovy中的变量可以通过两种方式定义–使用数据类型的本地语法，或者使用def关键字。对于变量定义，必须明确提供类型名称或在替

换中使用“def”。这是Groovy解析器需要的。

Grovvy有基本类型的变量，还允许其他类型的变量，如：数组，结构和类。

声明变量

 class Example
     static void main(String[] args) {
         String x = "hello";
         
         println(x);   // hello
 
 }

变量命名

变量的名称可以由字母，数字或下划线字符组成。它必须以字母或下划线开头。大写和小写字母是不同的，因为groovy，就像Java是一种区分大小写的编程语言。

 class Example
     static void main(String[] args) {
         int x = 5;
         
         int X = 6;
         
         def _Name = "ming";
         
         println(x);   // 5
         println(X);   // 6
         println(_Name);   // ming
 }

我们可以看出x和X是两个不同的变量，因为区分大小写。

打印变量

可以通过pringln函数打印变量的当前值

5.运算符

运算符是一个符号，通知编译器执行特定的数学或逻辑操作。

Groovy中有以下类型的运算符：

算术运算符：+ - * / % ++ --
关系运算符 == != < <= > >=
逻辑运算符 && || !
位运算符 & | ~(按位取反运算符)
赋值运算符 += -= *= /= (%)=

范围运算符

Groovy支持范围的概念，并在..符号的帮助下提供范围运算符的符号。例：

 def range = 0..5

这只是定义了一个简单的整数范围，存储到一个局部变量称为范围内的下限为0和上限为5。举例：

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

在高版本的groovy中运行结果如下：

 5..10
 7

其中 5..10 等价于[5,6,7,8,9,10]，这是Groovy中的一个整数范围（Range）对象，包含从5到10的所有整数。这种写法在Groovy中是非常常见的，它用于标识一个连续的整数序列，通常用于循环或遍历操作中。

6.循环

while语句
for语句
for - in语句（Java中的增强for循环）

举例：

 class Example
     static void main(String[] args) {
         
         for(int i in 1..5) {
             println(i); 
         }
 }
 //结果：
 1
 2
 3
 4
 5

也可用于循环map

 class Example
     static void main(String[] args) {
         
         def employee = ["Ken":21,"Jhon":25,"Sally":22]
         
         for(emp in employee) {
             println(emp); 
         }
 }
 //结果：
 Ken = 21
 John = 25
 Sally = 22

循环控制语句

break语句：用于控制改变循环和switch语句内的控制流
continue语句：补充了break语句。它的使用仅限于while和for循环

以上与Java类似...

7.条件语句

if语句
if/else 语句
嵌套if语句
Switch语句
嵌套switch语句

与java类似...

8.方法

Groovy中的方法是使用返回类型或使用def关键字定义的。方法可以接收任意数量的参数。定义参数时，不必显示定义类型，可以添加修饰符，如 public，private和protected。默认情况下，如果未提供可见性修饰符，则该方法为public。

与Java都类似，但有一点不同：

groovy支持默认参数，例：

 class Example
     static void main(String[] args) {
         sum(6);     // 11
         sum(6,6)    // 12
     }
     static void sum(int a,int b = 5) {
     int c = a + b;
     println(c);
     }

并且Groovy不支持 default的方法。

9.Groovy可选

Groovy是一个“可选”类型的语言，当理解语言的基本原理时，这种区别是一个重要的语言。与Java相比，Java是一种“强”类型的语言，由此编译器知道每个变量的所有类型，并且可以在编译时理解和尊重合同。这意味着方法调用能够在编译时确定。

当在Groovy中编写代码时，开发人员可以灵活地提供类型或不是类型。这可以提供一些简单的实现，并且当正确利用时，可以以强大和动态的方式为您的应用程序提供服务。

在Groovy中，可选的键入是通过def 关键字完成的。

def关键字用于定义Groovy中的无类型变量或函数，因为它是一种可选类型的语言。
当我们不确定变量或字段的类型时，可以利用def士Groovy在运行时根据分配的值确定类型:

def a = "1"
 def b = 1
 def c = ['a','b','c']

可选的打字在开发期间可以是一个强大的实用程序，但是当代码变得太大或者太复杂的时候，可能导致在后期开发阶段的可维护性问题。

要了解如何使用Groovy中的可选输入，而不让代码库陷入无法维护的混乱，最好在应用程序中采用“鸭式输入”的理念。

如果我们使用鸭式重写上面的代码，它将看起来像是下面给出的。变量的名称的名称比它们代表的类型更多，这使得代码更容易理解。

 class Example
     static void main(String[] args) {
         def aint = 100;
         
         def bfloat = 100.10;
         
         def cDouble = 100.101;
         
         def dString = "HelloWorld";
 }

10.Groovy 数字

在Groovy中，数字实际上表示为对象，它们都是类Integer的一个实例。要使对象做某事，我们需要调用在其类中声明的一个方法。

Groovy支持整数和浮点数：

整数表示不包含分数的值
浮点数是包含小数部分的十进制值

数字方法

xxxValue() --- 此方法接受 Number 作为参数，并基于调用的方法返回基本类型
compareTo() --- compareTo 方法是使用比较一个数字与另一个数字。如果要比较数字的值，这是有用的。
valueOf() --- valueOf 方法返回保存所传递的参数的值的相关 Number 对象。
rint() --- 方法 rint 返回值最接近参数的整数。
...

11.字符串

与Java类似

索引

class Example { 
    static void main(String[] args) { 
       String sample = "Hello world"; 
       println(sample[4]); // o
         
       println(sample[-1]); //d
       println(sample[1..2]);//el
       println(sample[4..2]);//oll
       
    } 
 }

12.Groovy范围

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

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

可用于范围的各种方法

contains() -- 检查范围是否包含特定值
get() -- 返回此范围中指定位置处的元素
getFrom() -- 获得此范围的下限值
getTo() -- 获得此范围的下限值
isReverse() -- 这是一个反向的范围，反向迭代
size() -- 返回此范围的元素数
subList() -- 返回此指定的fromIndex(包括)和toIndex(排除)之间的此范围部分的视图

13.Grovvy 列表

列表是用于存储数据项集合的结构。在Groovy中，list保存了一系列对象的引用

常用的列表方法：

add() 将新值附加到此列表的末尾
contains() 如果此列表包含指定的值，则返回true
get() 返回此列表中指定位置的元素
isEmpty() 如果此列表不包含元素，则返回true
minus() 创建一个由原始元素组成的新列表，而不是集合中指定的元素
plus() 创建由原始元素和集合中指定元素组成的新列表
pop() 从此列表中删除最后一个项目
remove() 删除此列表中指定位置的元素
reverse() 创建与原始列表元素相反的新列表
size() 获取此列表中的元素数
sort() 返回原始列表的排序副本

 def list1 = [100, 101]
 def list2 = [ 99,98,1]
 println list2.plus(list1) //输出结果： [99, 98, 1, 100, 101]
 // list2.plus(list1) 也可以写成 list2 + list1
 
 def list1 = [12, 13]
 def list2 = [11, 2, 33, 12, 13, 16]
 println list2.minus(list1) //输出结果： [11, 2, 33, 16]
 //list2.minus(list1) 也可以写成 list2 - list1

14.Groovy映射

映射，是对象引用的无序集合。

一些方法：

containsKey() 此映射是否包含此键
get() 查找此Map中的键并返回相应的值。如果此映射中没有键的条目，则返回null
keySet() 获取此映射中的一组键
put() 将指定的值与此映射中的指定键相关联。如果此映射先前包含此键的映射，则旧值将替换为指定的值
size() 返回此映射中的键值映射的数量
values() 返回此映射中包含的值的集合视图

15.日期和时间

类Date表示特定的时刻，具有毫秒精度。 Date类有两个构造函数，如下所示。

Date()

 class Example { 
    static void main(String[] args) { 
       Date date = new Date(); 
       
       // display time and date using toString() 
       System.out.println(date.toString());   // Thu Dec 10 21:31:15 GST 2015
    } 
 }

Date(长毫秒)

参数：毫秒

返回值：分配一个Date对象并将其初始化以表示自标准基准时间（称为“该历元”，即1970年1月1日，00:00:00 GMT）起指定的毫秒数。

 class Example {
    static void main(String[] args) {
       Date date = new Date(100);
       
       // display time and date using toString()
       System.out.println(date.toString());    //Thu Jan 01 04:00:00 GST 1970
    } 
 }

常用方法：