Groovy入門 - 程式人生

http://www.cnblogs.com/amosli/p/3970810.html
本文適合於不熟悉 Groovy，但想快速輕鬆地瞭解其基礎知識的 Java開發人員。瞭解 Groovy 對 Java 語法的簡化變形，學習 Groovy 的核心功能，例如本地集合、內建正則表示式和閉包。編寫第一個 Groovy 類，然後學習如何使用 JUnit 輕鬆地進行測試。藉助功能完善的 Groovy 開發環境和使用技能，您將輕鬆完成本教程的學習。最重要的是，您將學會如何在日常 Java 應用程式開發中聯合使用 Groovy 和 Java 程式碼。

閱讀本文的前提條件：為了從本教程得到最大收穫，您應該熟悉 Java 語法和在 Java 平臺上進行面向物件開發的基本概念。如果熟悉C#的話，基本上也能很快上手。

本文預計時長：30分鐘

一、groovy簡介和環境搭建

本機環境：

ubuntu 14.04 64bit

JDK 1.7.67

IDE : intellij idea 13.1

1、groovy簡介

其官方介紹為,Groovy...

is an agile and dynamic language for the Java Virtual Machine
builds upon the strengths of Java but has additional power features inspired by languages like Python, Ruby and Smalltalk

makes modern programming features available to Java developers with almost-zero learning curve
provides the ability to statically type check and statically compile your code for robustness and performance
supports Domain-Specific Languages and other compact syntax so your code becomes easy to read and maintain
makes writing shell and build scripts easy with its powerful processing primitives, OO abilities and an Ant DSL
increases developer productivity by reducing scaffolding code when developing web, GUI, database or console applications
simplifies testing by supporting unit testing and mocking out-of-the-box
seamlessly integrates with all existing Java classes and libraries
compiles straight to Java bytecode so you can use it anywhere you can use Java

簡單說來：Groovy是一種執行在JVM上的動態語言，它吸取了Python,Ruby和Smalltalk等語言的優點，在Java語言的基礎之上增加了許多特色功能；對於Java開發人員來說掌握Groovy是沒有什麼太大障礙的；相比 Java 而言，語法更易懂，更易上手，更易除錯；無縫的集成了Java 的類和庫；編譯後的.groovy也是以class的形式出現的。

2、groovy下載

目前最新穩定版為Groovy 2.3 （2014-09-14）

這裡下載：

Download zip: groovy-binary-2.3.6.zip

3、groovy環境配置和Hello World!

1)首先解壓：

unzip groovy-binary-2.3.6.zip #解壓groovy
unzip groovy-docs-2.3.6.zip #解壓docs

2) 進入到Groovy Shell命令介面：

[email protected]:~/developsoft/language/groovy/groovy-2.3.6/bin$ ./groovysh
Groovy Shell (2.3.6, JVM: 1.7.0_67)
Type ':help' or ':h' for help.
-------------------------------------------------------------------------------
groovy:000> println "hello world!"
hello world!
===> null
groovy:000> :h

在Groovy Shell裡不必定義class可以直接寫程式碼，如下面進行一個for迴圈：

groovy:000> for(i=0;i<10;i++){
groovy:001> println("i:"+i);}
i:0
i:1
i:2
i:3
i:4
i:5
i:6
i:7
i:8
i:9
===> null

注意這裡，你可以發現i是沒有指定int型別的，這裡也是寫法上也是比較隨意的。

3)、將groovy加入到環境變數（可選）

將解壓後的groovy拷到/usr/local/groovy 目錄下：

[email protected]:/usr/local/groovy# cp -r   /home/amosli/developsoft/language/groovy/groovy-2.3.6 .

將groovy路徑拷到/etc/profile裡：

gedit /etc/profile  #使用gedit開啟profile,也可以使用vi等工具

將下面內容拷到profile裡最後位置：

export GROOVY_HOME=/usr/local/groovy/groovy-2.3.6
export PATH=$GROOVY_HOME/bin:$PATH:.
export GROOVY_HOME
export PATH

全部的profile內容：

View Code

更新環境變數：

source /etc/profile

驗證是否成功：

# groovy -version
Groovy Version: 2.3.6 JVM: 1.7.0_67 Vendor: Oracle Corporation OS: Linux

開啟groovyConsole:

4)、使用IDE進行開發(這裡以Intellij idea 13.1為例)

1. Enable the plugin

Before you create your first Groovy application make sure Groovy plugin is enabled in Settings → Plugins.

2. Create a new project

Open Project Wizard and select Scala template. Since Groovy requires Java you have to specify the Project SDK.

If you create a Groovy project for the first time IntelliJ IDEA will offer you to create Groovy SDK library. Press Create button and choose directory with a Groovy SDK.

The IDE will create an empty project.

3. Create a new class

The easiest way to create Groovy class or script is to use Ctrl + N shortcut from Project View or Navigation Bar.

Choose between class, interface, enum and annotation with Up and Down arrows.

Let's create a class with a method returning "Hello, world!" string.

4. Create a new script

Now we can create a script file via Ctrl + N shortcut.

Choose between script and GroovyDSL script with Up and Down arrows.

Now we can create an instance of our class and invoke hello method.

5. Run the project

In order to run the application you can manually create a Run configuration via Run → Edit configurations or run the active script automatically by pressing Ctrl + Shift + F10 shortcut.

使用Groovy Shell :

開啟Tools-->Groovy Shell...

使用Groovy Console :

開啟Tools-->Groovy Console...

二、Groovy初探

1、Groovy和Java對比

Groovy 的鬆散的 Java 語法允許省略分號和修改符。
除非另行指定，Groovy 的所有內容都為 public。
Groovy 允許定義簡單指令碼，同時無需定義正規的 class 物件。
Groovy 在普通的常用 Java 物件上增加了一些獨特的方法和快捷方式，使得它們更容易使用。
Groovy 語法還允許省略變數型別。
關於閉包:可以將閉包想像為一個程式碼塊，可以現在定義，以後再執行。可以使用這些強大的構造做許多漂亮的事，不過最著名的是簡化迭代。使用 Groovy 之後，就有可能再也不需要編寫 Iterator 例項了。
動態的 Groovy: 從技術上講，Groovy 可能是您最近聽說過的型別最鬆散的動態語言之一。從這個角度講，Groovy 與 Java 語言的區別很大，Java 語言是一種固定型別語言。在 Groovy 中，型別是可選的，所以您不必輸入 String myStr = "Hello"; 來宣告 String 變數。可以直接使用def進行不指定型別定義，類似於js中的var。
與Java互用：用 Groovy 編寫的任何內容都可以編譯成標準的 Java 類檔案並在 Java 程式碼中重用。類似地，用標準 Java 程式碼編寫的內容也可以在 Groovy 中重用。

2、例項演示Java和Groovy的區別

用 Java 編寫的 Hello World

用 Java 編寫的典型的 Hello World 示例如下所示：

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

編譯和執行 Java 示例

在這個簡單的 HelloWorld 類中，我省略了包，而且向控制檯輸出的時候沒有使用任何多餘的編碼約定。下一步是用 javac 編譯這個類，如下所示：

c:>javac HelloWorld.java

最後，執行經過編譯的類：

c:>java HelloWorld

迄今為止還不錯 — 很久以前就會編這麼基礎的程式碼了，所以這裡只是回顧一下。下面，請看用 Groovy 編碼的相同過程。

用 Groovy 編寫的 Hello World

就像前面提到過的，Groovy 支援鬆散的 Java 語法 — 例如，不需要為列印 “Hello World!” 這樣的簡單操作定義類。

而且，Groovy 使日常的編碼活動變得更容易，例如，Groovy 允許輸入 println，而無需輸入 System.out.println。當您輸入 println時，Groovy 會非常聰明地知道您指的是 System.out。

所以，用 Groovy 編寫 Hello World 程式就如下面這樣簡單：

println "Hello World!"

請注意，在這段程式碼周圍沒有類結構，而且也沒有方法結構！我還使用 println 代替了 System.out.println。

執行 Groovy 示例

假設我將程式碼儲存在檔案/home/amosli/developsoft/language/groovy/test/Hello.groovy 內，只要輸入以下程式碼就能執行這個示例：

[email protected]:~/developsoft/language/groovy/groovy-2.3.6/bin$ ./groovy  ../../test/Hello.groovy
Hello World!

如果已經配置了groovy的環境變數，那麼只需要輸入以下命令即可：

[email protected]:/home/amosli/developsoft/language/groovy/test# groovy Hello.groovy 
Hello World!

在控制檯上輸出 “Hello World!” 所需的工作就這麼多。

更快捷的方式

[email protected]:~/developsoft/language/groovy/groovy-2.3.6/bin$ ./groovy -e "println 'helloworld '"
helloworld

如果已經配置了groovy的環境變數，那麼只需要輸入以下命令即可：

[email protected]:/home/amosli/developsoft/language/groovy/test# groovy -e "println 'helloworld '"
helloworld

這會生成相同的結果，而且甚至無需定義任何檔案！

3、Groovy 是沒有型別的 Java 程式碼

很可能將 Groovy 當成是沒有規則的 Java 程式碼。但實際上，Groovy 只是規則少一些。這一節的重點是使用 Groovy 編寫 Java 應用程式時可以不用考慮的一個 Java 程式設計的具體方面：型別定義。

為什麼要有型別定義？

在 Java 中，如果要宣告一個 String 變數，則必須輸入：

String value = "Hello World";

但是，如果仔細想想，就會看出，等號右側的字元已經表明 value 的型別是 String。所以，Groovy 允許省略 value 前面的 String 型別變數，並用 def 代替。

def value = "Hello World"

實際上，Groovy 會根據物件的值來判斷它的型別。

執行程式！

將 HelloWorld.groovy 檔案中的程式碼編輯成下面這樣：

String message = "Hello World"
println message.class  //class java.lang.String

4、通過 Groovy 進行迴圈

方式1：

這裡可以定義i為int 或者 def ，或者不定義其型別

for(i = 0; i < 5; i++){
  println i
 }

方式2：

使用in進行迴圈，其中..表示“到”，0..5表示0到5，類似於0<=5;這裡迴圈6次；

for(i in 0..5){
  println i
 }

可以使用0..<5進行限定，類似於0<5,迴圈5次;

5、Groovy中的集合

1)、Groovy 中的List

def range = 0..4
println range.class
assert range instanceof List

請注意，assert 命令用來證明範圍是 java.util.List 的例項。接著執行這個程式碼，證實該範圍現在是型別 List 的集合。

Groovy 的語法:

def coll = ["Groovy", "Java", "Ruby"]
assert  coll instanceof Collection
assert coll instanceof ArrayList

你將會注意到，coll 物件看起來很像 Java 語言中的陣列。實際上，它是一個 Collection。要在普通的 Java 程式碼中得到集合的相同例項，必須執行以下操作：

Collection<String> coll = new ArrayList<String>();
coll.add("Groovy");
coll.add("Java");
coll.add("Ruby");

在 Java 程式碼中，必須使用 add() 方法向 ArrayList 例項新增項。

而Groovy中則提供了3種方法：

coll.add("Python")
coll << "Smalltalk"
coll[5] = "Perl"

查詢元素:

如果需要從集合中得到某個特定項，可以通過像上面那樣的位置引數獲取項。例如，如果想得到第二個項 “Java”，可以編寫下面這樣的程式碼（請記住集合和陣列都是從 0 開始）：
assert coll[1] == "Java"
Groovy 還允許在集合中增加或去掉集合，如下所示：
def numbers = [1,2,3,4]
assert numbers + 5 == [1,2,3,4,5]
assert numbers - [2,3] == [1,4]

Groovy中的特殊方法：

def numbers = [1,2,3,4]
assert numbers.join(",") == "1,2,3,4" 
assert [1,2,3,4,3].count(3) == 2

join() 和 count() 只是在任何項List上都可以呼叫的眾多方便方法中的兩個。分佈操作符（spread operator）是個特別方便的工具，使用這個工具不用在集合上迭代，就能夠呼叫集合的每個項上的方法。

假設有一個 String 列表，現在想將列表中的專案全部變成大寫，可以編寫以下程式碼：
assert ["JAVA", "GROOVY"] ==
["Java", "Groovy"]*.toUpperCase()
請注意 *. 標記。對於以上列表中的每個值，都會呼叫 toUpperCase()，生成的集合中每個 String 例項都是大寫的。

2）Groovy中的Map

Java 語言中的對映是名稱-值對的集合。所以，要用 Java 程式碼建立典型的對映，必須像下面這樣操作：

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

Groovy 使得處理對映的操作像處理列表一樣簡單 — 例如，可以用 Groovy 將上面的 Java 對映寫成

def hash = [name:"Andy", "VPN-#":45]

請注意，Groovy 對映中的鍵不必是 String。在這個示例中，name 看起來像一個變數，但是在幕後，Groovy 會將它變成 String。

驗證hash格式：

assert hash.getClass() == java.util.LinkedHashMap

Groovy 中Hash的Set/Get

//方法1
hash.put("id", 23)
assert hash.get("name") == "Andy"

//方法2
hash.dob = "01/29/76"
//. 符號還可以用來獲取項。例如，使用以下方法可以獲取 dob 的值：
assert hash.dob == "01/29/76" 

//方法3
assert hash["name"] == "Andy"
hash["gender"] = "male"
assert hash.gender == "male"
assert hash["gender"] == "male"

請注意，在使用 [] 語法從對映獲取項時，必須將項作為 String 引用。

6、Groovy 中的閉包

Java 的 Iterator 例項，用它在集合上迭代，就像下面這樣：

def acoll = ["Groovy", "Java", "Ruby"]
        
for(Iterator iter = acoll.iterator(); iter.hasNext();){
 println iter.next()
}

請注意，each 直接在 acoll 例項內呼叫，而 acoll 例項的型別是 ArrayList。在 each 呼叫之後，引入了一種新的語法 —{，然後是一些程式碼，然後是 }。由 {} 包圍起來的程式碼塊就是閉包。

def acoll = ["Groovy", "Java", "Ruby"]
        
acoll.each{
 println it
}

閉包中的 it 變數是一個關鍵字，指向被呼叫的外部集合的每個值 — 它是預設值，可以用傳遞給閉包的引數覆蓋它。下面的程式碼執行同樣的操作，但使用自己的項變數：

def acoll = ["Groovy", "Java", "Ruby"]
        
acoll.each{ value ->
 println value
}

在這個示例中，用 value 代替了 Groovy 的預設 it。

def hash = [name:"Andy", "VPN-#":45]
hash.each{ key, value ->
 println "${key} : ${value}"
}

請注意，閉包還允許使用多個引數 — 在這個示例中，上面的程式碼包含兩個引數（key 和 value）。

請記住，凡是集合或一系列的內容，都可以使用下面這樣的程式碼進行迭代。

> "amosli".each{
println it.toUpperCase();
}

A
M
O
S
L
I

def excite = {
word-> 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    Groovy入門 | 基礎語法
      object   字符串   閉包   temp   oci   fff   imp   some   bool   Java的東西Groovy都能用，包括語法和類庫

public static void main(String[] args) {
        // 重要的事情說3遍
        f 

  
 

    

    
    Groovy入門-閉包
       
 
  
  
 由{}包圍起來的程式碼塊就是閉包  println {}//執行改行，結果:類名.ClosureDemo
   
    runclosure1@10a2d64符合格式：類
   _run_closure1@10a2d64  
      符合格式：類匿名內部類@hash_code  結 

  
 

    

    
    Groovy入門-字串處理與正則表示式
       
 
  
  
 字串處理-1 
 println ‘lxt008 said "Groovy"'
println "lxt008 said 'Grails'"

def str1 = 'Groovy&Grails&lxt008'
println str1[4]                

  
 

    

    
    Groovy入門--集合
       
 
  
  
 集合概述  Groovy直接在語言內使用集合。  1.不需要匯入專門的類，也不需要初始化物件。  2.集合是語言本身的本地成員  每個Groovy集合都是java.util.Collection 或 java.util.Map 的事例。  List,String,StringBuffer 

  
 

    

    
    Groovy入門-語法規範
       
 
  
  
 直接來源於Java語法的特性  1.關鍵字於語法  2.類，介面，屬性，方法的定義  3.使用new建立物件  4.包匯入機制  5.try/catch/finally異常處理機制  6.運算子，表示式，複製  7.控制結構  8.程式碼註釋 
 groovy自動匯入如下包  groov 

  
 

    

    
    Groovy入門-1
       
 
  
  
 Groovy 是 Java平臺上指令碼語言，抽象程度更高（可以更簡單的快速開發，可以編寫更少的程式碼）  與Java語言無縫整合，可稱為“超級Java”  1.使用“類Java”語法，Java程式設計師可以快速過渡。  2.Groovy與Java二進位制相容，都可以生成位元組碼，所以可以 

  
 

    

    
    Groovy 教程系列（一）-- Groovy 入門
      
                概述

Groovy 是一種基於Java平臺的面嚮物件語言。Groovy 的語法和 Java 非常的相似，可以使用現有的 Java 庫來進行 Groovy 開發。可以將它想像成 Java 語言的一種更加簡單、表達能力更強的變體。
用 Groovy 編寫的任何內容都可以編譯成標 

  
 

    

    
    groovy入門 環境搭建以及HelloWorld實現
      
                
一 環境搭建
1.1Groovy環境搭建
WIndows

groovy下載地址如下：http://groovy.codehaus.org/Download
環境變數：PATH後追加 %GROOVY_HOME%/bin;

開啟cmd，輸入groovysh 檢視配置結果
1 

  
 

    

    
    Gradle for Android 第七篇( Groovy入門 )
      
                

迄今為止，我們已經學些了眾多gradle構建的概念以及如何執行tasks。在這一章，我們將對這些概念有一個更深的理解，然後開始構建我們自己的tasks。一旦我們掌握瞭如何編寫自定義tasks,那麼我們就可以試著編寫自己的外掛，以達到在多個專案中複用的目的。

在我們建立傳 

  
 

    

    
    Groovy入門（四）——集合Map
      
							
							
							Map

map宣告方式



def myMap =['a':1,'b':2,'c':3]
assert myMap instance HashMap
assert myMap.size() == 3
assert myMap['a'] == 1
def em 

  
 

    

    
    Groovy入門筆記
      
                
mac如何安裝groovy

命令安裝


SDKMAN! (The Software Development Kit Manager)


This tool makes installing Groovy on any Bash platform (Mac OSX, L 

  
 

    

    
    Groovy入門教程
      
                

HELLO！大家好！我是咕嚕大大，專注程式設計和單身30年！
尊重原創，請大家轉載時註明該文章來自：http://blog.csdn.net/ymh198816/article/details/43817435
最近我的BOSS要開始一個新的電商專案，並初步定下開發語言為 

  
 

    

    
    groovy入門 第02章 數值和表示式
      
                
數值和表示式
2.1數值
支援整數和浮點數。
整數是Integer的例項，浮點數是BigDecimal的例項。
2.2表示式
支援加、減、乘、除、求模運算，並且運算子可以被方法代替。
5+3 可以表示為5.plus(3)  ,另外還有minus，multiply，devid 

  
 

    

    
    Groovy入門
      
                


http://www.cnblogs.com/amosli/p/3970810.html
本文適合於不熟悉 Groovy，但想快速輕鬆地瞭解其基礎知識的 Java開發人員。瞭解 Groovy 對 Java 語法的簡化變形，學習 Groovy 的核心功能，例如本地 

  
 

    

    
    Gradle 入門-Groovy 程式碼之談
      
                本文作者：黃少存，叩丁狼高階講師。原創文章，轉載請註明出處。 

上一篇咱們用文字介紹了 Groovy 和 Java 的不同和特有的特性,這一篇咱們就用程式碼來闡述 Groovy 和 Java 的不同以及特有的特性.寫程式碼之前需要來做一些準備工作,準備工作如下.

1 準備 

  
 

    

    
    groovy快速入門(ubuntu 14.04+IntelliJ)
      
                本文適合於不熟悉 Groovy，但想快速輕鬆地瞭解其基礎知識的 Java開發人員。瞭解 Groovy 對 Java 語法的簡化變形，學習 Groovy 的核心功能，例如本地集合、內建正則表示式和閉包。編寫第一個 Groovy 類，然後學習如何使用 JUnit 輕鬆地進行測試。 

  
 

    

    
    ElasticSearch最佳入門實踐（二十三）基於groovy指令碼進行partial update
      
								
								            
							
							
							
es，其實是有個內建的指令碼支援的，可以基於groovy指令碼實現各種各樣的複雜操作

1、初始化一條資料

2、內建指令碼


3、外部指令碼

4、用指令碼刪除文件


5、update操作

6 

  
 

    

    
    Android Gradle，Groovy自動化構建入門篇
      
							
							
							

Gradle是一個基於Apache Ant和Apache Maven概念的專案自動化構建工具。它使用一種基於Groovy的特定領域語言(DSL)來宣告專案設定，拋棄了基於XML的各種繁瑣配置。



為什麼要學習它

我們知道主流的的構建工具有Ant，Mav 

  
 

    

    
    基於java jdk的Groovy環境配置及基礎入門
      
							
							
							一、  前言


  Groovy是一門依賴JVM的動態解釋性語言，是Java語言的補充與升級。gradle工具就是用groovy語言編寫。工作中看到同事做中小型應用系統的時候，用過groovy語言，開發效率確實要比用純java編寫快很多。




二、  JD 

  
 

    

    
    Gradle入門系列(一)——groovy基礎語法
      groovy基礎語法 
一、變數 
1、型別 
 
 物件型別、基本型別(本質是物件型別) 
 
int x = 0
println x.class
double y = 3.14
println y.class
複製程式碼
輸出： 
class java.lang.Integer
class java.la