4.6.斜杠字符串

除了通常的带引号字符串，groovy提供斜杠字符串，使用/作为分隔符。斜杠字符串对于定义正则表达式和模式是特别有用的，因为不需要转义反斜杠。
一个斜杠字符串：

def fooPattern = /.*foo.*/
assert fooPattern == '.*foo.*'

只有正斜杠需要反斜杠转义：

def escapeSlash = /The character \/ is a forward slash/
assert escapeSlash == 'The character / is a forward slash'

斜杠字符串是多行的：

def multilineSlashy = /one
two
three/

assert multilineSlashy.contains('\n')

斜杠字符串也能被插值（如，GString）:

def color = 'blue'
def interpolatedSlashy = /a ${color} car/

assert interpolatedSlashy == 'a blue car'

有几个陷阱需要注意：
一个空的斜杠字符串不能使用双正斜杠表示，因为它被Groovy解析器作为一个单行注释理解。这就是为什么以下断言实际上无法编译，因为它看起来像一个无终止的语句：

assert '' == //

4.7.美元符修饰的斜杠字符串

美元符斜杠字符串是一个有开口$/和闭口$/界定的多行GString。这转义字符是美元符，它能转义另一个美元符，或一个正斜杠。但是双美元符和双正斜杠不用被转义，除了转义像GString占位符序列开始的字符串子序列的美元符，或者你需要转义一个序列，开头看着像闭包美元符斜杠字符串分隔符。

示例：

def name = "Guillaume"
def date = "April, 1st"

def dollarSlashy = $/
  Hello $name,
  today we're ${date}.

  $ dollar sign
  $$ escaped dollar sign
  \ backslash
  / forward slash
  $/ escaped forward slash
  $/$ escaped dollar slashy string delimiter
/$

assert [
  'Guillaume',
  'April, 1st',
  '$ dollar sign',
  '$ escaped dollar sign',
  '\\ backslash',
  '/ forward slash',
  '$/ escaped forward slash',
  '/$ escaped dollar slashy string delimiter'

].each { dollarSlashy.contains(it) }

4.8.字符串总结表

String name              String syntax     Interpolated     Multiline    Escape character
Single quoted            '…​'                                              \
Triple single quoted     '''…​'''                            是            \
Double quoted            "…​"               是                             \
Triple double quoted     """…​"""           是               是            \
slashy                   /…​/               是               是            \
Dollar                   $/…​/$             是               是            \

4.9.字符

与Java不同，Groovy没有显式的字符文本，然而你可以通过三种不同方式，可以将Groovy字符串实际作为一个字符使用。

char c1 = 'A' （1）
assert c1 instanceof Character

def c2 = 'B' as char （2）
assert c2 instanceof Character

def c3 = (char)'C' （3）
assert c3 instanceof Character

（1）当定义变量时，通过指定char类型，使变量包含字符
（2）通过as操作符使用类型强制转换
（3）通过char操作符做类型转换
第一个选项是（1）有趣的当一个字符在一个变量中，而另外两个（2和3）是更令人关注时char值必须作为一个方法调用的参数。

5.数字

Groovy支持不同类型的整数和小数，通常以Java的Number类型返回。

5.1.整数

整数类型与Java相同：

• byte
• char
• short
• int
• long
• java.lang.BigInteger

你能以如下定义创建这些类型的整数：

// primitive types
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

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

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

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

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

对于负数也一样：

def na = -1
assert na instanceof Integer

// Integer.MIN_VALUE
def nb = -2147483648
assert nb instanceof Integer

// Integer.MIN_VALUE - 1
def nc = -2147483649
assert nc instanceof Long

// Long.MIN_VALUE
def nd = -9223372036854775808
assert nd instanceof Long

// Long.MIN_VALUE - 1
def ne = -9223372036854775809
assert ne instanceof BigInteger

5.1.1.可选择的非十进制表示

二进制数
在Java6及以前和Groovy一样，数字只能使用十进制，八进制和十六进制表示，使用Java7和Groovy2你能使用0b前缀作为一个二进制符号：

int xInt = 0b10101111
assert xInt == 175

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

byte xByte = 0b11
assert xByte == 3 as byte

long xLong = 0b101101101101
assert xLong == 2925l

BigInteger xBigInteger = 0b111100100001
assert xBigInteger == 3873g

int xNegativeInt = -0b10101111
assert xNegativeInt == -175

八进制数
八进制数使用0后面跟八进制数的典型格式表示。

int xInt = 077
assert xInt == 63

short xShort = 011
assert xShort == 9 as short

byte xByte = 032
assert xByte == 26 as byte

long xLong = 0246
assert xLong == 166l

BigInteger xBigInteger = 01111
assert xBigInteger == 585g

int xNegativeInt = -077
assert xNegativeInt == -63

十六进制数
十六进制数使用0x后面跟十六进制数的典型格式表示。

int xInt = 0x77
assert xInt == 119

short xShort = 0xaa
assert xShort == 170 as short

byte xByte = 0x3a
assert xByte == 58 as byte

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

5.2.小数

小数类型与Java一样：

• float
• double
• java.lang.BigDecimal

你能采用如下定义方式创建这些类型的数字：

// primitive types
float f = 1.234
double d = 2.345

// infinite precision
BigDecimal bd = 3.456

小数能使用指数，使用e或E指数字母，紧跟着一个可选符号，且有一个整数表示指数：

assert 1e3 == 1_000.0
assert 2E4 == 20_000.0
assert 3e+1 == 30.0
assert 4E-2 == 0.04
assert 5e-1 == 0.5

为了精确的进行小数计算，Groovy选择java.lang.BigDecimal作为小数类型。此外，float和double也被支持，但要求有一个显式类型定义，类型转换或后缀。即使BigDecimal是默认的小数，携带float或double作为类型参数的方法或闭包也可以接受这些数值。
小数不能使用二进制，八进制和十六进制表示。

5.3.有下划线的文本

当写一个很长的数字，使用眼睛很难弄清楚有多少数字组合在一起，例如使用千，单词等组合。通过允许你在数字中添加一些下划线，更容易发现这些组合：

long creditCardNumber = 1234_5678_9012_3456L
long socialSecurityNumbers = 999_99_9999L
double monetaryAmount = 12_345_132.12
long hexBytes = 0xFF_EC_DE_5E
long hexWords = 0xFFEC_DE5E
long maxLong = 0x7fff_ffff_ffff_ffffL
long alsoMaxLong = 9_223_372_036_854_775_807L
long bytes = 0b11010010_01101001_10010100_10010010

• 转载自 并发编程网 - ifeve.com