Groovy - 快速指南

---

Groovy - 概述

Groovy 是一种基于 Java 平台的面向对象语言。Groovy 1.0 于 2007 年 1 月 2 日发布，当前主要版本为 Groovy 2.4。Groovy 通过 Apache License v 2.0 分发。

Groovy 的特点

Groovy 具有以下功能 -

• 支持静态和动态类型。
• 支持运算符重载。
• 列表和关联数组的本机语法。
• 对正则表达式的本机支持。
• 对各种标记语言（例如 XML 和 HTML）的本机支持。
• Groovy 对于 Java 开发人员来说很简单，因为 Java 和 Groovy 的语法非常相似。
• 您可以使用现有的 Java 库。
• Groovy 扩展了 java.lang.Object。

Groovy 的官方网站是http://www.groovy-lang.org/

Groovy - 环境

有多种方法可以设置 Groovy 环境。

二进制下载和安装- 转至链接www.groovy-lang.org/download.html以获取 Windows Installer 部分。单击此选项开始下载 Groovy 安装程序。

启动安装程序后，请按照以下步骤完成安装。

步骤 1 - 选择语言安装程序。

步骤 2 - 单击下一个屏幕中的“下一步”按钮。

步骤 3 - 单击“我同意”按钮。

步骤 4 - 接受默认组件并单击“下一步”按钮。

步骤 5 - 选择适当的目标文件夹，然后单击“下一步”按钮。

步骤 6 - 单击“安装”按钮开始安装。

步骤 7 - 安装完成后，单击“下一步”按钮开始配置。

步骤 8 - 选择默认选项，然后单击“下一步”按钮。

步骤 9 - 接受默认文件关联并单击“下一步”按钮。

步骤 10 - 单击“完成”按钮完成安装。

完成上述步骤后，您就可以启动 groovy shell，它是 Groovy 安装的一部分，有助于测试 Groovy 语言的不同方面，而无需拥有成熟的 Groovy 集成开发环境。这可以通过从命令提示符运行命令 groovysh 来完成。

如果您想将 groovy 二进制文件包含在 Maven 或 gradle 构建中，您可以添加以下行

摇篮

'org.codehaus.groovy:groovy:2.4.5'

梅文

<groupId>org.codehaus.groovy</groupId> 
<artifactId>groovy</artifactId>  
<version>2.4.5</version>

Groovy - 基本语法

为了理解 Groovy 的基本语法，我们首先看一个简单的 Hello World 程序。

创建您的第一个 Hello World 程序

创建您的第一个 hello world 程序就像输入以下代码行一样简单 -

class Example {
   static void main(String[] args) {
      // Using a simple println statement to print output to the console
      println('Hello World');
   }
}

当我们运行上面的程序时，我们将得到以下结果 -

Hello World

Groovy 中的导入语句

import 语句可用于导入可在代码中使用的其他库的功能。这是通过使用import关键字来完成的。

以下示例演示如何使用 MarkupBuilder 类的简单导入，该类可能是创建 HTML 或 XML 标记最常用的类之一。

import groovy.xml.MarkupBuilder 
def xml = new MarkupBuilder() 

默认情况下，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

Groovy 中的令牌

标记可以是关键字、标识符、常量、字符串文字或符号。

println(“Hello World”);

在上面的代码行中，有两个标记，第一个是关键字 println，第二个是“Hello World”的字符串文字。

Groovy 中的评论

注释用于记录您的代码。Groovy 中的注释可以是单行或多行。

单行注释通过在行中的任意位置使用 // 来标识。下面显示了一个示例 -

class Example {
   static void main(String[] args) {
      // Using a simple println statement to print output to the console
      println('Hello World');
   }
}

多行注释在开头用 /* 标识，用 */ 标识多行注释的结尾。

class Example {
   static void main(String[] args) {
      /* This program is the first program
      This program shows how to display hello world */
      println('Hello World');
   }
}

分号

与 Java 编程语言不同，每个语句末尾后面都没有分号，它是可选的。

class Example {
   static void main(String[] args) {
      def x = 5
      println('Hello World');  
   }
}

如果执行上面的程序，main 方法中的两条语句都不会生成任何错误。

身份标识

标识符用于定义变量、函数或其他用户定义的变量。标识符以字母、美元或下划线开头。他们不能以数字开头。以下是有效标识符的一些示例 -

def employeename 
def student1 
def student_name

其中def是 Groovy 中用于定义标识符的关键字。

以下是如何在 Hello World 程序中使用标识符的代码示例。

class Example {
   static void main(String[] args) {
      // One can see the use of a semi-colon after each statement
      def x = 5;
      println('Hello World'); 
   }
}

在上面的例子中，变量x被用作标识符。

关键词

顾名思义，关键字是 Groovy 编程语言中保留的特殊单词。下表列出了 Groovy 中定义的关键字。

空格

空白是 Java 和 Groovy 等编程语言中用来描述空白、制表符、换行符和注释的术语。空格将语句的一部分与另一部分分隔开，并使编译器能够识别语句中某个元素的位置。

例如，在以下代码示例中，关键字def和变量 x之间有一个空格。这样编译器就知道def是需要使用的关键字，x 应该是需要定义的变量名。

def x = 5;

文字

文字是 groovy 中表示固定值的符号。Groovy 语言具有整数、浮点数、字符和字符串的表示法。以下是 Groovy 编程语言中的一些文字示例 -

12 
1.45 
‘a’ 
“aa”

Groovy - 数据类型

在任何编程语言中，都需要使用各种变量来存储各种类型的信息。变量只不过是用于存储值的保留内存位置。这意味着当您创建变量时，您会在内存中保留一些空间来存储与该变量关联的值。

您可能喜欢存储各种数据类型的信息，如字符串、字符、宽字符、整数、浮点、布尔值等。操作系统根据变量的数据类型分配内存并决定保留的内容可以存储记忆。

内置数据类型

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

• byte - 用于表示字节值。一个例子是 2。

• 短- 用于表示短数字。一个例子是 10。

• int - 用于表示整数。一个例子是 1234。

• long - 用于表示长数字。例如 10000090。

• float - 用于表示 32 位浮点数。一个例子是 12.34。

• double - 用于表示 64 位浮点数，它们是有时可能需要的更长的十进制数表示形式。例如 12.3456565。

• char - 这定义了单个字符文字。一个例子是“a”。

• Boolean - 这表示一个布尔值，可以是 true 或 false。

• 字符串- 这些是以字符链的形式表示的文本文字。例如“你好世界”。

界限值

下表显示了数字和十进制文字的最大允许值。

数字类

类型 除了原始类型之外，还允许使用以下对象类型（有时称为包装类型） -

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

此外，以下类可用于支持任意精度算术 -

以下代码示例展示了如何使用不同的内置数据类型 -

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

当我们运行上面的程序时，我们将得到以下结果 -

5 
100 
10.56 
1.05E41 
30 
3.5

Groovy - 变量

Groovy 中的变量可以通过两种方式定义：使用数据类型的本机语法，或者使用 def 关键字。对于变量定义，必须显式提供类型名称或使用“def”进行替换。这是 Groovy 解析器所需要的。

如前一章所述，Groovy 中有以下基本变量类型 -

• byte - 用于表示字节值。一个例子是 2。

• 短- 用于表示短数字。一个例子是 10。

• int - 用于表示整数。一个例子是 1234。

• long - 用于表示长数字。例如 10000090。

• float - 用于表示 32 位浮点数。一个例子是 12.34。

• double - 用于表示 64 位浮点数，它们是有时可能需要的更长的十进制数表示形式。例如 12.3456565。

• char - 这定义了单个字符文字。一个例子是“a”。

• Boolean - 这表示一个布尔值，可以是 true 或 false。

• 字符串- 这些是以字符链的形式表示的文本文字。例如“你好世界”。

Groovy 还允许使用其他类型的变量，例如数组、结构和类，我们将在后续章节中看到这些。

变量声明

变量声明告诉编译器在何处以及为变量创建存储空间的量。

以下是变量声明的示例 -

class Example { 
   static void main(String[] args) { 
      // x is defined as a variable 
      String x = "Hello";
		
      // The value of the variable is printed to the console 
      println(x);
   }
}

当我们运行上面的程序时，我们将得到以下结果 -

Hello

命名变量

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

class Example { 
   static void main(String[] args) { 
      // Defining a variable in lowercase  
      int x = 5;
	  
      // Defining a variable in uppercase  
      int X = 6; 
	  
      // Defining a variable with the underscore in it's name 
      def _Name = "Joe"; 
		
      println(x); 
      println(X); 
      println(_Name); 
   } 
}

当我们运行上面的程序时，我们将得到以下结果 -

5 
6 
Joe 

我们可以看到，由于区分大小写，x和X是两个不同的变量，在第三种情况下，我们可以看到 _Name 以下划线开头。

打印变量

您可以使用 println 函数打印变量的当前值。以下示例展示了如何实现这一点。

class Example { 
   static void main(String[] args) { 
      //Initializing 2 variables 
      int x = 5; 
      int X = 6; 
	  
      //Printing the value of the variables to the console 
      println("The value of x is " + x + "The value of X is " + X);  
   }
}

当我们运行上面的程序时，我们将得到以下结果 -

The value of x is 5 The value of X is 6 

Groovy - 运算符

运算符是告诉编译器执行特定数学或逻辑操作的符号。

Groovy 有以下类型的运算符 -

• 算术运算符
• 关系运算符
• 逻辑运算符
• 按位运算符
• 赋值运算符

算术运算符

Groovy 语言与任何语言一样支持普通算术运算符。以下是 Groovy 中可用的算术运算符 -

显示示例

关系运算符

关系运算符允许对对象进行比较。以下是 Groovy 中可用的关系运算符 -

显示示例

逻辑运算符

逻辑运算符用于计算布尔表达式。以下是 Groovy 中可用的逻辑运算符 -

显示示例

按位运算符

Groovy 提供了四种按位运算符。以下是 Groovy 中可用的按位运算符 -

显示示例

这是展示这些运算符的真值表。

赋值运算符

Groovy 语言还提供赋值运算符。以下是 Groovy 中可用的赋值运算符 -

显示示例

范围运算符

Groovy 支持范围的概念，并借助 .. 符号提供范围运算符的符号。下面给出了范围运算符的一个简单示例。

def range = 0..5 

这只是定义了一个简单的整数范围，存储在一个名为 range 的局部变量中，下限为 0，上限为 5。

以下代码片段显示了如何使用各种运算符。

class Example { 
   static void main(String[] args) { 
      def range = 5..10; 
      println(range); 
      println(range.get(2)); 
   } 
}

当我们运行上面的程序时，我们将得到以下结果 -

从println语句中，您可以看到显示了 range 语句中定义的整个数字范围。

get 语句用于从定义的范围中获取对象，该对象以索引值作为参数。

[5, 6, 7, 8, 9, 10] 
7

运算符优先级

下表按优先级顺序列出了所有 groovy 运算符。

Groovy - 循环

到目前为止，我们已经看到了按顺序依次执行的语句。此外，Groovy 中还提供了语句来改变程序逻辑中的控制流。然后它们被分类为我们将详细看到的控制语句流。

循环控制语句

Groovy - 决策

决策结构要求程序员指定一个或多个要由程序评估或测试的条件，以及在条件确定为 true 时要执行的一条或多条语句，以及可选的在条件成立时要执行的其他语句。条件被确定为false。

Groovy - 方法

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

最简单的方法类型是没有参数的方法，如下所示 -

def methodName() { 
   //Method code 
}

下面是一个简单方法的例子

class Example {
   static def DisplayName() {
      println("This is how methods work in groovy");
      println("This is an example of a simple method");
   } 
	
   static void main(String[] args) {
      DisplayName();
   } 
}

在上面的示例中，DisplayName 是一个简单的方法，由两个 println 语句组成，用于将一些文本输出到控制台。在我们的静态 main 方法中，我们只是调用 DisplayName 方法。上述方法的输出将是 -

This is how methods work in groovy 
This is an example of a simple method

方法参数

如果一种方法的Behave由一个或多个参数的值确定，则该方法通常更有用。我们可以使用方法参数将值传递给被调用的方法。请注意，参数名称必须彼此不同。

最简单的方法类型，其参数如下所示 -

def methodName(parameter1, parameter2, parameter3) { 
   // Method code goes here 
}

以下是带参数的简单方法的示例

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

在此示例中，我们创建一个带有 2 个参数a和b的 sum 方法。两个参数都是int类型。然后，我们从 main 方法中调用 sum 方法，并将值传递给变量a和b。

上述方法的输出将为值 15。

默认参数

Groovy 中还提供了为方法内的参数指定默认值的规定。如果没有将参数值传递给方法，则使用默认值。如果同时使用非默认参数和默认参数，则必须注意默认参数应定义在参数列表的末尾。

以下是带有参数的简单方法的示例 -

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

让我们看一下之前看过的两个数字相加的相同示例，并创建一个具有一个默认参数和另一个非默认参数的方法 -

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

在此示例中，我们创建一个带有两个参数a和b的 sum 方法。这两个参数都是 int 类型。此示例与上一示例之间的区别在于，在本例中，我们将b的默认值指定为5。因此，当我们从 main 方法中调用 sum 方法时，我们可以选择仅传递一个值 6 和这将被分配给sum方法中的参数a。

上述方法的输出将为值 11。

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

我们还可以通过传递 2 个值来调用 sum 方法，在上面的示例中，我们传递 2 个值 6。第二个值 6 实际上将替换分配给参数b的默认值。

上述方法的输出将为值 12。

方法返回值

方法还可以将值返回给调用程序。这在现代编程语言中是必需的，其中方法执行某种计算，然后将所需的值返回给调用方法。

以下是具有返回值的简单方法的示例。

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

在上面的示例中，请注意，这次我们为方法 sum 指定了 int 类型的返回类型。在该方法中，我们使用 return 语句将总和值发送到调用主程序。由于该方法的值现在可用于 main 方法，因此我们使用println函数在控制台中显示该值。

上述方法的输出将为值 11。

实例方法

方法通常在 Groovy 的类内部实现，就像 Java 语言一样。类只不过是用于创建定义其属性和Behave的不同对象的蓝图或模板。类对象表现出其类定义的属性和Behave。因此，Behave是通过在类内部创建方法来定义的。

我们将在后面的章节中更详细地了解类，但以下是类中方法实现的示例。在前面的示例中，我们将方法定义为静态方法，这意味着我们可以直接从类访问这些方法。方法的下一个示例是实例方法，其中通过创建类的对象来访问这些方法。我们将在后面的章节中再次看到类，现在我们将演示如何使用方法。

以下是如何实现方法的示例。

class Example { 
   int x; 
	
   public int getX() { 
      return x; 
   } 
	
   public void setX(int pX) { 
      x = pX; 
   } 
	
   static void main(String[] args) { 
      Example ex = new Example(); 
      ex.setX(100); 
      println(ex.getX()); 
   } 
}

在上面的示例中，请注意，这次我们没有为类方法指定静态属性。在我们的 main 函数中，我们实际上创建了一个 Example 类的实例，然后调用“ex”对象的方法。

上述方法的输出将为值 100。

本地和外部参数名称

Groovy 提供了像 java 一样的功能来拥有本地和全局参数。在下面的示例中，lx是一个局部参数，其作用域仅在getX()函数内，而x是一个全局属性，可以在整个示例类中访问。如果我们尝试在getX()函数之外访问变量lx，我们将收到错误。

class Example { 
   static int x = 100; 
	
   public static int getX() { 
      int lx = 200; 
      println(lx); 
      return x; 
   } 
	
   static void main(String[] args) { 
      println(getX()); 
   }  
}

当我们运行上面的程序时，我们将得到以下结果。

200 
100

此方法用于属性

就像在 Java 中一样，groovy 可以使用this关键字访问其实例成员。下面的示例展示了当我们使用this.x语句时，它如何引用其实例并相应地设置x的值。

class Example { 
   int x = 100; 
	
   public int getX() { 
      this.x = 200; 
      return x; 
   } 
	
   static void main(String[] args) {
      Example ex = new Example(); 
      println(ex.getX());
   }
}

当我们运行上面的程序时，我们会在控制台上打印出200的结果。

Groovy - 文件 I/O

Groovy 在使用 I/O 时提供了许多辅助方法。Groovy 提供了更简单的类来为文件提供以下功能。

• 读取文件
• 写入文件
• 遍历文件树
• 读取数据对象并将其写入文件

除此之外，您始终可以使用下面列出的普通 Java 类进行文件 I/O 操作。

• java.io.File
• java.io.InputStream
• java.io.OutputStream
• java.io.Reader
• java.io.Writer

读取文件

以下示例将输出 Groovy 中文本文件的所有行。Groovy 的 File 类中内置了eachLine方法，目的是确保读取文本文件的每一行。

import java.io.File 
class Example { 
   static void main(String[] args) { 
      new File("E:/Example.txt").eachLine {  
         line -> println "line : $line"; 
      } 
   } 
}

File 类用于实例化一个新对象，该对象以文件名作为参数。然后它获取eachLine 的函数，将其放入名为line 的变量中并相应地打印它。

如果文件包含以下行，则会打印它们。

line : Example1
line : Example2

将文件内容作为整个字符串读取

如果您想以字符串形式获取文件的全部内容，可以使用文件类的 text 属性。以下示例展示了如何完成此操作。

class Example { 
   static void main(String[] args) { 
      File file = new File("E:/Example.txt") 
      println file.text 
   } 
}

如果文件包含以下行，则会打印它们。

line : Example1 
line : Example2

写入文件

如果要写入文件，则需要使用 writer 类将文本输出到文件。以下示例展示了如何完成此操作。

import java.io.File 
class Example { 
   static void main(String[] args) { 
      new File('E:/','Example.txt').withWriter('utf-8') { 
         writer -> writer.writeLine 'Hello World' 
      }  
   } 
}

如果打开文件Example.txt，您将看到文件中打印出“Hello World”字样。

获取文件的大小

如果要获取文件的大小，可以使用文件类的 length 属性来获取文件的大小。以下示例展示了如何完成此操作。

class Example {
   static void main(String[] args) {
      File file = new File("E:/Example.txt")
      println "The file ${file.absolutePath} has ${file.length()} bytes"
   } 
}

上面的代码将显示文件的大小（以字节为单位）。

测试文件是否是目录

如果要查看路径是文件还是目录，可以使用File 类的isFile和isDirectory选项。以下示例展示了如何完成此操作。

class Example { 
   static void main(String[] args) { 
      def file = new File('E:/') 
      println "File? ${file.isFile()}" 
      println "Directory? ${file.isDirectory()}" 
   } 
}

上面的代码将显示以下输出 -

File? false 
Directory? True

创建目录

如果要创建新目录，可以使用File 类的mkdir函数。以下示例展示了如何完成此操作。

class Example {
   static void main(String[] args) {
      def file = new File('E:/Directory')
      file.mkdir()
   } 
}

如果目录 E:\Directory 不存在，则会创建该目录。

删除文件

如果要删除文件，可以使用 File 类的删除函数。以下示例展示了如何完成此操作。

class Example {
   static void main(String[] args) {
      def file = new File('E:/Example.txt')
      file.delete()
   } 
}

如果该文件存在，则将其删除。

复制文件

Groovy 还提供将一个文件的内容复制到另一个文件的功能。以下示例展示了如何完成此操作。

class Example {
   static void main(String[] args) {
      def src = new File("E:/Example.txt")
      def dst = new File("E:/Example1.txt")
      dst << src.text
   } 
}

将创建文件Example1.txt，并将文件Example.txt 的所有内容复制到该文件。

获取目录内容

Groovy 还提供了列出驱动器和驱动器中的文件的功能。

以下示例显示如何使用File 类的listRoots函数显示计算机上的驱动器。

class Example { 
   static void main(String[] args) { 
      def rootFiles = new File("test").listRoots() 
      rootFiles.each { 
         file -> println file.absolutePath 
      }
   }
}

根据机器上可用的驱动器，输出可能会有所不同。在标准机器上，输出将类似于以下内容 -

C:\ 
D:\

以下示例演示如何使用File 类的eachFile函数列出特定目录中的文件。

class Example {
   static void main(String[] args) {
      new File("E:/Temp").eachFile() {  
         file->println file.getAbsolutePath()
      }
   } 
}

输出将显示目录 E:\Temp 中的所有文件

如果要递归显示目录及其子目录中的所有文件，则可以使用File 类的eachFileRecurse函数。以下示例展示了如何完成此操作。

class Example { 
   static void main(String[] args) {
      new File("E:/temp").eachFileRecurse() {
         file -> println file.getAbsolutePath()
      }
   }
} 

输出将显示目录 E:\Temp 及其子目录中的所有文件（如果存在）。

Groovy - 可选

Groovy 是一种“可选”类型的语言，在理解该语言的基础知识时，这种区别非常重要。与 Java 相比，Java 是一种“强”类型语言，编译器知道每个变量的所有类型，并且可以在编译时理解和遵守契约。这意味着可以在编译时确定方法调用。

在 Groovy 中编写代码时，开发人员可以灵活地提供或不提供类型。这可以在实现上提供一些简单性，并且如果使用得当，可以以健壮和动态的方式为您的应用程序提供服务。

在 Groovy 中，可选类型是通过“def”关键字完成的。以下是def方法的用法示例-

class Example { 
   static void main(String[] args) { 
      // Example of an Integer using def 
      def a = 100; 
      println(a); 
		
      // Example of an float using def 
      def b = 100.10; 
      println(b); 
		
      // Example of an Double using def 
      def c = 100.101; 
      println(c);
		
      // Example of an String using def 
      def d = "HelloWorld"; 
      println(d); 
   } 
} 

从上面的程序中，我们可以看到，我们没有将各个变量声明为 Integer、float、double 或 string，即使它们包含这些类型的值。

当我们运行上面的程序时，我们将得到以下结果 -

100 
100.10 
100.101
HelloWorld

可选类型在开发过程中可能是一个强大的实用程序，但在开发的后期阶段，当代码变得过于庞大和复杂时，可能会导致可维护性问题。

为了掌握如何在 Groovy 中使用可选类型而不让代码库陷入难以维护的混乱，最好在应用程序中采用“鸭子类型”的理念。

如果我们使用鸭子类型重写上面的代码，它看起来会像下面给出的那样。变量名称的命名通常与其所代表的类型相似，这使得代码更易于理解。

class Example { 
   static void main(String[] args) { 
      // Example of an Integer using def 
      def aint = 100; 
      println(aint); 
		
      // Example of an float using def 
      def bfloat = 100.10; 
      println(bfloat); 
		
      // Example of an Double using def 
      def cDouble = 100.101; 
      println(cDouble);
		
      // Example of an String using def 
      def dString = "HelloWorld"; 
      println(dString); 
   } 
}

Groovy - 数字

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

Groovy 支持整数和浮点数。

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

Groovy 中的数字示例如下所示 -

Integer x = 5; 
Float y = 1.25; 

其中x是整数类型，y是浮点数。

groovy中之所以将数字定义为对象，一般是因为有对数字进行操作的需求。在原始类型上提供类的概念称为包装类。

默认情况下，Groovy 中提供了以下包装类。

包装类的对象包含或包装其各自的原始数据类型。将原始数据类型转换为对象的过程称为装箱，这是由编译器负责的。将对象转换回其相应原始类型的过程称为拆箱。

例子

以下是装箱和拆箱的示例 -

class Example { 
   static void main(String[] args) {
      Integer x = 5,y = 10,z = 0; 
		
      // The the values of 5,10 and 0 are boxed into Integer types 
      // The values of x and y are unboxed and the addition is performed 
      z = x+y; 
      println(z);
   }
}

上述程序的输出为 15。在上述示例中，值 5、10 和 0 首先相应地装箱到整数变量 x、y 和 z 中。然后，当执行 x 和 y 的加法时，这些值将从其 Integer 类型中拆箱。

数字方法

由于 Groovy 中的数字表示为类，因此以下是可用方法的列表。

Groovy - 字符串

在 Groovy 中，字符串文字是通过将字符串文本括在引号中来构造的。

Groovy 提供了多种表示字符串文字的方法。Groovy 中的字符串可以用单引号 (')、双引号 (“) 或三引号 (“””) 括起来。此外，用三引号括起来的 Groovy 字符串可以跨越多行。

以下是 Groovy 中字符串的使用示例 -

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

当我们运行上面的程序时，我们将得到以下结果 -

Hello Single 
Hello Double 
'Hello TripleMultiple lines'

字符串索引

Groovy 中的字符串是有序的字符序列。字符串中的单个字符可以通过其位置来访问。这是由索引位置给出的。

字符串索引从零开始，以比字符串长度小一结束。Groovy 还允许负索引从字符串末尾开始倒数。

以下是在 Groovy 中使用字符串索引的示例 -

class Example { 
   static void main(String[] args) { 
      String sample = "Hello world"; 
      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 
      
   } 
}

当我们运行上面的程序时，我们将得到以下结果 -

o 
d 
el 
oll 

基本字符串操作

首先我们来学习groovy中的基本字符串操作。下面给出了它们。

字符串方法

以下是 String 类支持的方法列表。

Groovy - 朗