Groovy入门

作者: MinicupSimon | 来源:发表于2018-05-25 21:25 被阅读0次

Groovy入门

环境安装：

JDK环境，如果用AndroidStudio的话可以跳过该步骤，因为AndroidStudio的JDK 及 Groovy已默认配置好
官网下载：http://www.groovy-lang.org/download.html
可以直接下载压缩包，解压，手动配置环境变量
或（推荐）直接下载Windows Installer并安装，环境变量自动配好。
打开cmd -> groovy -version 验证

或者用在线运行环境 :
https://tool.lu/coderunner/
http://www.dooccn.com/groovy/

Groovy HelloWorld：

1.命令行

创建helloworld.groovy文件：

class Fuck{
    static void main(String[] args){
        println "Hello World3";
    }
}

Shift 鼠标右键-> 在此处打开命令窗口
运行命令 groovy helloworld.groovy

2.Groovy安装后在%GROOVY_HOME%/bin下找到groovyConsole.exe或groovyConsole.bat.

image.png

Ctrl Enter / Ctrl R 运行。
同时支持选中部分运行

3使用AndroidStudio：

Ctrl+Shift+A->选择Groovy Console即可

image.png

或双击Shift->选择Groovy Console

image.png

出现两个窗口：Groovy脚本输入窗口，和Run脚本输出窗口

Ctrl Enter / Ctrl R 运行。
同时支持选中部分运行

对比Java

Default imports
java.io.*
java.lang.*
java.math.BigDecimal
java.math.BigInteger
java.net.*
java.util.*
groovy.lang.*
groovy.util.*
Multi-methods 或者叫Runtime Dispatch
java基于方法声明的类型，在编译期间就确定了调用的方法，而Groovy则是在运行时来判断参数的类型，而动态的调用相应的方法。

int method(String arg) {
    return 1;
}
int method(Object arg) {
    return 2;
}
Object o = "Object";
int result = method(o);

Java运行后 result为2;
而Groovy运行后 result 为1;

Array initializers
Groovy 中的{...}被保留用作闭包,数组初始化使用[]。
Java: int[] array = {1, 2, 3}
Groovy: int[] array = [1, 2, 3]
Package scope visibility

class Person {
    String name
}

Java中，成员变量不定义访问控制符的情况下为default, 包相同的类中可以访问。即package-private

Groovy中，不定义访问控制符的成员变量被用于创建一个属性，即一个私有成员变量，一个关联的getter和一个关联的setter。如果希望达到Java包私有的效果，只需要加注释@PackageScope

class Person {
    @PackageScope String name
}

不支持ARM blocks (Automatic Resource Management)

Path file = Paths.get("/path/to/file");
Charset charset = Charset.forName("UTF-8");
try (BufferedReader reader = Files.newBufferedReader(file, charset)) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }

} catch (IOException e) {
    e.printStackTrace();
}

可以写成：
new File('/path/to/file').eachLine('UTF-8') {
   println it
}
或更接近于Java写法的：
new File('/path/to/file').withReader('UTF-8') { reader ->
   reader.eachLine {
       println it
   }
}

Lambdas
Java8支持的Lambdas

Runnable run = () -> System.out.println("Run");
list.forEach(System.out::println);

Groovy不支持，但是通过闭包实现相同效果。

Runnable run = { println 'run' }
list.each { println it } // or list.each(this.&println)

Extra keywords
Groovy比Java多出以下几个关键字：as, def, in, trait

Grammar

Groovy是基于JVM的开发语言，与Java有很多相似之处。以下只介绍与Java不同的语法：

范围运算符

class Example { 
   static void main(String[] args) { 
      //1..10 - 包含范围的示例
      //1 .. <10 - 独占范围的示例
      //'a'..'x' - 范围也可以由字符组成
      //10..1 - 范围也可以按降序排列
      //'x'..'a' - 范围也可以由字符组成并按降序排列。

      def range = 5..10; 
      println(range); 
      println(range.get(2)); 
   } 
}

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

方法

//返回类型用具体的或使用def关键字定义， 方法可以接收任意数量的参数
//定义参数时，不必显式定义类型
//修饰符public，private和protected。不写默认为public
def methodName() { 
   //Method code 
}

static def DisplayName(parameter1, parameter2 = 0, parameter3 = 0) {
  //参数设置默认值，调用DisplayName(1)时，会默认使用 parameter2,parameter3的默认值。
} 
    
static void main(String[] args) {
}

文件操作

import java.io.File 
class Example { 
   static void main(String[] args) { 
      //读取文件
      new File("E:/Example.txt").eachLine {  
         line -> println "line : $line"; 
      } 
      //读取文件的内容
      File file = new File("E:/Example.txt") 
      println file.text 

      //写入文件
      new File('E:/','Example.txt').withWriter('utf-8') { 
         writer -> writer.writeLine 'Hello World' 
      }  

      //获取文件的大小
      File file = new File("E:/Example.txt")
      println "The file ${file.absolutePath} has ${file.length()} bytes"

      //测试文件是否是目录
      def file = new File('E:/') 
      println "File? ${file.isFile()}" 
      println "Directory? ${file.isDirectory()}" 

      //创建目录 删除文件
      def file = new File('E:/Directory')
      file.mkdir()
      file.delete()
      //复制文件
      def src = new File("E:/Example.txt")
      def dst = new File("E:/Example1.txt")
      dst << src.text

      //显示机器上的驱动器
      def rootFiles = new File("test").listRoots() 
      rootFiles.each { 
         file -> println file.absolutePath 
      }

      //列出特定目录中的文件
      new File("E:/Temp").eachFile() {  
         file->println file.getAbsolutePath()
      }

      //显示目录及其子目录中的所有文件
      new File("E:/temp").eachFileRecurse() {
         file -> println file.getAbsolutePath()
      }
   } 
}

数字

rint(): 返回值最接近参数的整数

class Example { 
   static void main(String[] args){ 
      double d = 100.675; 
      double e = 100.500; 
      double f = 100.200;
        
      System.out.println(Math.rint(d)); 
      System.out.println(Math.rint(e)); 
      System.out.println(Math.rint(f)); 
   } 
}

101.0 
100.0 
100.0

toRadians()：参数值转换为弧度

class Example {
   static void main(String[] args) {
      double x = 45.0;
      double y = 30.0;  
        
      System.out.println( Math.toRadians(x) );
      System.out.println( Math.toRadians(y) );
   } 
}

0.7853981633974483 
0.5235987755982988

字符串

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); 
      //字符串索引
      println(sample[4]); // Print the 5 character in the string
      println(sample[-1]);  //Print the 1st character in the string starting from the back 
      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 
      //字符串重复
      String a = "Hello"; 
      println("Hello"*3); 
      println(a*3); 
   } 
}
Hello Single 
Hello Double 
'Hello TripleMultiple lines'

o 
d 
el 
oll 

HelloHelloHello 
HelloHelloHello

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

class Example {
   static void main(String[] args) {
      def lst = [11, 12, 13, 14];
      println(lst);
      lst.add(15);//将新值附加到此列表的末尾。
      println(lst);
      lst.add(2,20);//将新值附加到列表中的特定位置。
      println(lst);

      println(lst.contains(12)); //true
      println(lst.contains(18));//false

      println(lst.get(0));//11
      println(lst.get(2));//13

      println(lst.isEmpty()); //false 

      //从列表中减去的值的集合。
      def newlst = [];
      newlst = lst.minus([12,13]); 
      println(newlst); //[11, 14]
      newlst = lst.plus([15,16]);
      println(newlst);  //[11, 14, 15, 16]

      //从此列表中删除最后一个项目。
      println(lst.pop()); //14 
      println(lst); //[11, 12, 13]

      //删除此列表中指定位置的元素。
      println(lst.remove(2));//13
      println(lst);//[11, 12]

      //创建与原始列表的元素相反的新列表
      def revlst = lst.reverse(); 
      println(revlst); //[12, 11]

       //排序
      def newlst = lst.sort(); 
      println(newlst);//[11, 12]

      println(lst.size);//2
   } 
}

[11, 12, 13, 14] 
[11, 12, 13, 14, 15] 
[11, 12, 20, 13, 14, 15]

正则

有两个特殊的位置字符用于表示一行的开始和结束：caret（∧）和美元符号（$）。
正则表达式也可以包括量词。加号（+）表示一次或多次，应用于表达式的前一个元素。
星号（*）用于表示零个或多个出现。问号（？）表示零或一次。
元字符{和}用于匹配前一个字符的特定数量的实例。
在正则表达式中，句点符号（。）可以表示任何字符。这被描述为通配符。
正则表达式可以包括字符类。一组字符可以作为简单的字符序列，包含在元字符[和]中，如[aeiou]中。对于字母或数字范围，可以使用[a-z]或[a-mA-M]中的短划线分隔符。字符类的补码由方括号内的前导插入符号表示，如[∧a-z]中所示，并表示除指定的字符以外的所有字符。下面给出了正则表达式的一些示例。

以下都为true
'Groovy' =~ 'Groovy' //true
'Groovy' =~ 'oo' //true
'Groovy' ==~ 'Groovy' //true
'Groovy' ==~ 'oo' //false
'Groovy' =~ '∧G' //true
‘Groovy' =~ 'y$' //true
‘Groovy' =~ 'Gro*vy' //true
'Groovy' =~ 'Gro{2}vy'//true

特征

可以被看作是承载默认实现和状态的接口。使用trait关键字定义

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;   
      println(st.DisplayMarks());
      println(st.DisplayTotal());
   } 
} 
interface Total {
   void DisplayTotal() 
} 
trait Marks implements Total { //实现接口
   void DisplayMarks() {
      println("Display Marks");
   }
   void DisplayTotal() {
      println("Display Total"); 
   } 
} 
class Student implements Marks { 
   int StudentID
   int Marks1;  
} 
Display Marks 
Display Total

闭包

class Example {
   static void main(String[] args) {
      def clos = {println "Hello World"}; //{println "Hello World"}即为闭包
      clos.call();//代码块可以使用call语句执行
   } 
}
class Example {
   static void main(String[] args) {
      def clos = {param->println "Hello ${param}"};//包含形式参数
      clos.call("World");
   } 
}
class Example {
   static void main(String[] args) {
      def clos = {println "Hello ${it}"};//这里的'it'是Groovy中的关键字
      clos.call("World"); //Hello World
   } 
}


class Example { 
   def static Display(clo) {
      clo.call("Inner");
   } 
   static void main(String[] args) {
      def str1 = "Hello";
      def clos = { param -> println "${str1} ${param}" }//闭包内引用变量
      clos.call("World");//Hello World
        
      str1 = "Welcome";
      clos.call("World");// Welcome World
        
      Example.Display(clos);// Welcome Inner
   } 
}

class Example {
   static void main(String[] args) {
      def lst = [11, 12, 13, 14];
      lst.each {println it}//each接收一个Closure参数, 应用在数组的每一项.
      lst.each{num -> if(num % 2 == 0) println num} // 12 14
   } 
}

class Example {
   static void main(String[] args) {
      def mp = ["TopicName" : "Maps", "TopicDescription" : "Methods in Maps"]             
      mp.each {println it}
      //TopicName = Maps 
      //TopicDescription = Methods in Maps 

      mp.each {println "${it.key} maps to: ${it.value}"}
      //TopicName maps to: Maps 
      //TopicDescription maps to: Methods in Maps
   } 
}

class Example {
   static void main(String[] args) {
      def lst = [1,2,3,4];
      def value;
      value = lst.find {element -> element > 2} // 查找集合中与某个条件匹配的第一个值
      println(value);//3

      value = lst.findAll{element -> element > 2}//找到接收对象中与闭合条件匹配的所有值。
      value.each {println it}//3, 4

      // Is there any value above 2
      value = lst.any{element -> element > 2}
      println(value);//true
        
      // Is there any value above 4
      value = lst.any{element -> element > 4}
      println(value); //false

      // Are all value above 2
      value = lst.every{element -> element > 2}
      println(value);//false
        
      // Are all value above 4 
      value = lst.every{element -> element > 4}
      println(value);  //false

      def largelst = [4,5,6];
        
      // Are all value above 2
      value = largelst.every{element -> element > 2}
      println(value);//true

      def lst = [1,2,3,4];
      def newlst = [];
      newlst = lst.collect {element -> return element * element}//通过集合收集迭代，使用闭包作为变换器将每个元素转换为新值。
      println(newlst);//[1, 4, 9, 16] 
   } 
}

XML

Groovy中的XML支持
Groovy语言还提供了对XML语言的丰富支持。使用的两个最基本的XML类是 -

XML标记构建器 - Groovy支持基于树的标记生成器BuilderSupport，它可以被子类化以生成各种树结构对象表示。通常，这些构建器用于表示XML标记，HTML标记。 Groovy的标记生成器捕获对伪方法的调用，并将它们转换为树结构的元素或节点。这些伪方法的参数被视为节点的属性。作为方法调用一部分的闭包被视为生成的树节点的嵌套子内容。

import groovy.xml.MarkupBuilder 

class Example {
   static void main(String[] args) {
      def mB = new MarkupBuilder()
        
      // Compose the builder
      mB.collection(shelf : 'New Arrivals') {
         movie(title : 'Enemy Behind')
         type('War, Thriller')
         format('DVD')
         year('2003')
         rating('PG')
         stars(10)
         description('Talk about a US-Japan war') 
      }
   } 
}

<collection shelf = 'New Arrivals'> 
   <movie title = 'Enemy Behind' /> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
</collection>

XML解析器 - Groovy XmlParser类使用一个简单的模型来将XML文档解析为Node实例的树。每个节点都有XML元素的名称，元素的属性和对任何子节点的引用。这个模型足够用于大多数简单的XML处理。

class Example {

   static void main(String[] args) { 
    
      def parser = new XmlParser()
      def doc = parser.parse("D:Movies.xml");
        
      doc.movie.each{
         bk->
         print("Movie Name:")
         println "${bk['@title']}"
            
         print("Movie Type:")
         println "${bk.type[0].text()}"
            
         print("Movie Format:")
         println "${bk.format[0].text()}"
            
         print("Movie year:")
         println "${bk.year[0].text()}"
            
         print("Movie rating:")
         println "${bk.rating[0].text()}"
            
         print("Movie stars:")
         println "${bk.stars[0].text()}"
            
         print("Movie description:")
         println "${bk.description[0].text()}"
         println("*******************************")
      }
   }
}

监视JVM

import java.lang.management.*

def os = ManagementFactory.operatingSystemMXBean 
println """OPERATING SYSTEM: 
    OS architecture = $os.arch 
    OS name = $os.name 
    OS version = $os.version 
    OS processors = $os.availableProcessors 
""" 
 
def rt = ManagementFactory.runtimeMXBean 
println """RUNTIME: 
    Runtime name = $rt.name 
    Runtime spec name = $rt.specName 
    Runtime vendor = $rt.specVendor 
    Runtime spec version = $rt.specVersion 
    Runtime management spec version = $rt.managementSpecVersion 
   """ 

def mem = ManagementFactory.memoryMXBean 
def heapUsage = mem.heapMemoryUsage 
def nonHeapUsage = mem.nonHeapMemoryUsage 

println """MEMORY: 
   HEAP STORAGE: 
        Memory committed = $heapUsage.committed 
        Memory init = $heapUsage.init 
        Memory max = $heapUsage.max 
        Memory used = $heapUsage.used NON-HEAP STORAGE: 
        Non-heap memory committed = $nonHeapUsage.committed 
        Non-heap memory init = $nonHeapUsage.init 
        Non-heap memory max = $nonHeapUsage.max 
        Non-heap memory used = $nonHeapUsage.used 
   """
  
println "GARBAGE COLLECTION:" 
ManagementFactory.garbageCollectorMXBeans.each { gc ->
   println "    name = $gc.name"
   println "        collection count = $gc.collectionCount"
   println "        collection time = $gc.collectionTime"
   String[] mpoolNames =   gc.memoryPoolNames
    
   mpoolNames.each { 
      mpoolName -> println "        mpool name = $mpoolName"
   } 
}

结果:

OPERATING SYSTEM:
    OS architecture = amd64
    OS name = Windows 10
    OS version = 10.0
    OS processors = 8

RUNTIME:
    Runtime name = 6164@DESKTOP-UBF4S8B
    Runtime spec name = Java Virtual Machine Specification
    Runtime vendor = Oracle Corporation
    Runtime spec version = 1.8
    Runtime management spec version = 1.2
   
MEMORY:
   HEAP STORAGE:
        Memory committed = 257425408
        Memory init = 268435456
        Memory max = 3790077952
        Memory used = 46437528 NON-HEAP STORAGE:
        Non-heap memory committed = 21168128
        Non-heap memory init = 2555904
        Non-heap memory max = -1
        Non-heap memory used = 20688832
   
GARBAGE COLLECTION:
    name = PS Scavenge
        collection count = 1
        collection time = 3
        mpool name = PS Eden Space
        mpool name = PS Survivor Space
    name = PS MarkSweep
        collection count = 0
        collection time = 0
        mpool name = PS Eden Space
        mpool name = PS Survivor Space
        mpool name = PS Old Gen
Result: [sun.management.GarbageCollectorImpl@2bfc268b, sun.management.GarbageCollectorImpl@2f8dad04]

Groovy入门

环境安装：

Groovy HelloWorld：

1.命令行

2.Groovy安装后在%GROOVY_HOME%/bin下找到groovyConsole.exe或groovyConsole.bat.

3使用AndroidStudio：

对比Java

Grammar

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

我爱编程