Groovy 基本类型

官方文档：http://www.groovy-lang.org/syntax.html

字符Characters

不像Java，Groovy没有明确的Characters。但是我们可以有如下三种不同的方式来将字符串作为字符处理

char c1 = 'A'  // 指定char类型
assert c1 instanceof Character

def c2 = 'A' as char  // 使用as操作符进行类型强制转换
assert c2 instanceof Character

def c3 = (char) 'A'  //类型转换
assert c3 instanceof Character

第一种方式通常用于字符被保存在变量中，另外两种通常用于方法调用时一个char值作为参数传递

Numbers

整数

和Java中一样，支持 byte、 char、 short、 int、 long、 java.lang.BigInteger

// 基本类型
byte  b = 1
char  c = 2 
short s = 3 
int   i = 4
long  l = 5

// infinite precision
BigInteger bi =  6

如果使用def关键字定义变量，那么整数的类型将会变化，将使用其容量能够容纳这个数字的类型

def a = 1
assert a instanceof Integer

def b = 2147483647  // Integer.MAX_VALUE
assert b instanceof Integer

def c = 2147483648  // Integer.MAX_VALUE + 1
assert c instanceof Long

def d = 9223372036854775807  // Long.MAX_VALUE
assert d instanceof Long

def e = 9223372036854775808  // Long.MAX_VALUE + 1
assert e instanceof BigInteger

二进制、八进制、十六进制表示

二进制0b

short xShort = 0b11001001
assert xShort == 201 as short

八进制 0

int xInt = 077
assert xInt == 63

byte xByte = 032
assert xByte == 26 as byte

十六进制 0x

long xLong = 0xffff
assert xLong == 65535L

BigInteger xBigInteger = 0xaaaa
assert xBigInteger == 43690g

Double xDouble = new Double('0x1.0p0')
assert xDouble == 1.0d

int xNegativeInt = -0x77
assert xNegativeInt == -119

小数

小数类型和Java一样：float、 double、 java.lang.BigDecimal

// 基本类型
float  f = 1.234
double d = 2.345
assert f instanceof Float

// infinite precision
BigDecimal bd =  3.456

可以使用指数字母e或E，后跟可选的+或-，和一个整数

assert 1e3  == 1_000.0
assert 2E7  == 20_000_000.0  // 可用_分隔
assert 3e+1 ==     30.0
assert 4E-2 ==      0.04

小数的默认类型是BigDecimal，但给参数类型为float或double的方法传入没有明确类型的数字也是可以的

小数不能用二进制、八进制或十六进制表示

可以使用下划线分隔数字，更容易阅读：

long creditCardNumber = 1234_5678_9012_3456L
double monetaryAmount = 12_345_132.122_345
long hexWords = 0xFFEC_DE5E
long bytes = 0b11010010_01101001_10010100_10010010

类型后缀

assert 123L == new Long("123")
assert 1.23E23D == new Double('1.23E23')

assert 034G.class == BigInteger // octal

数学运算

数学运算的行为以及它们的结果类型

Boolean

def bool = true
boolean bool = true
bool = false

此外，Groovy有特殊的规则(通常称为Groovy真理)，用于将非布尔对象强转为布尔值

Lists

Groovy支持java.util.List类型，List变量默认实现是ArrayList，元素可以是不同类型

List list = [1,2,3] 
def list2 = [1,"a",list,true] //元素可以是不同类型
assert list2 instanceof ArrayList //List变量默认类型是ArrayList

定义不同类型的List，有两种方式

def linkedList = [2,3,4] as LinkedList //使用as定义
LinkedList linkedList2 = [2,4]
linkedList[0] = 5

可以使用get(index)方法，索引范围 0 ~ list.size() - 1
或使用角标[]访问或修改元素，[]内部的索引可以是整数或负数，负数表示从右向左访问

assert linkedList[1] == 3
assert linkedList[-1] == linkedList.get(2)

使用 << 左移给列表追加元素

list2 << new Date()
assert list2.size() == 5
println(list2[4])  // Fri Aug 18 12:04:39 CST 2017

获取List子集

assert list2[1,3] == ["a",true]
assert list2[0..2] == [1,list]

多维List

List multiList = [[0,1],[2,3]]
assert multiList[1][0] == 2

Arrays

数组的定义：声明类型或强制转换

//定义数组
int[] intArr1 = [1,3] 
def intArr2 = [1,3] as int[]

//定义数组，指明长度
def intArr3 = new int[3][2]

//不指明长度
int[][] intArr4;
intArr4 = [[1,2],[3,4]]

assert intArr1 instanceof int[] 
assert !(intArr1 instanceof List)

assert intArr1.size() == 3
assert intArr1.length == 3

//赋值
intArr2[1] = 5
assert intArr2[1] == 5

Maps

定义Map

def colors = [red: '#FF0000',green: '#00FF00',blue: '#0000FF']

使用键检查：当使用键的名称时，我们实际上在Map中定义了字符串键

//使用下标检查
assert colors['red'] == '#FF0000'
//使用属性检查
assert colors.green == '#00FF00'

可以使用数字作为键，因为数字可以清楚地识别为数字，所以Groovy不会像前面的例子那样创建字符串键

def map2 = [1:'one',2:'tow']  // key的类型为数字
assert map2[1] == 'one'

修改值

colors.green = '#00F0F0'
assert colors.green == '#00F0F0'

使用下标符号或属性添加新的键值对

colors.pink == '#FF00FF'
colors['yellow'] == '#FFFF00'

Map实际类型为java.util.LinkedHashMap

assert colors instanceof java.util.LinkedHashMap

访问不存在的key时返回null

assert colors.unknown == null

使用变量作为键

def key = 'name'
def map3 = [key:'Guillaume'] 
assert !map3.containsKey('name')
assert map3.containsKey('key')

与“Guillaume”名称关联的键实际上是字符串"key"，而不是与key变量关联的值

正确写法

def map4 = [(key):'Guillaume']  // key用括号括起来
assert map4.containsKey('name')
assert map4.containsKey(key)

Map的键不能修改

key = 'othername'
assert !map4.containsKey('othername') 
assert !map4.containsKey(key)  // 不再包含key