1. 介绍
本篇为Groovy学习第四篇，学习Groovy语法中的Number数值类型，和Boolean布尔类型的知识。
了解Groovy中的数值类型的创建，以及允许的数值类型种类。
2. Numbers 数值类型
Groovy支持不同类型的整数和十进制数，这个是继承于Java的。可以说java支持的数值类型，Groovy也一样支持。
2.1 整数类型
在Groovy中整数类型为：byte,char,short,int,long,BigInteger
可以使用以下声明创建这些类型的整数,示例如下:
// 基本数据类型
byte b = 1
char c = 2
short s = 3
int i = 4
long l = 5
//大精度数据类型
BigInteger bi = 6
如果通过使用def关键字使用可选类型，则整数值的类型将会变化:它将适应容纳该数值的类型的容量。
(ps:其中char类型 无法通过def类型创建)
// 基本数据类型
def a = 1
assert a instanceof Integer //断言，这个值是Integer类型
// Integer.MAX_VALUE， int最大值
def b = 2147483647
assert b instanceof Integer //断言，这个值是Integer类型
// Integer.MAX_VALUE + 1
def c = 2147483648 //因为这个值的长度超过了int的范围，就会自动变成long类型了。
assert c instanceof Long //断言，这个值是long类型
// Long.MAX_VALUE
def d = 9223372036854775807
assert d instanceof Long //断言，这个值是long类型
// Long.MAX_VALUE + 1
def e = 9223372036854775808 // 如果值的长度超过了long的范围，就会变成BigInteger长度类型了。
assert e instanceof BigInteger //断言，这个值是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
assert 这个关键字是断言。如果不满足该断言结果，程序就会结束。
2.1.1 非十进制数表示
数字也可以用二进制、八进制、十六进制和十进制表示。
二进制数值表示效果：
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
如果要用二进制进行表示，必须使用0b作为开头
八进制数值表示效果：八进制数的典型格式为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
2.2 浮点数类型
同java中的浮点数表示方式一样，Groovy中的浮点数为：float,double,BigDecimal。
浮点数创建方式如下：
float f = 1.234
double d = 2.345
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
我们如果想创建一个float或者double 必须通过上面的创建方法进行创建。而不能使用def进行动态创建。
groovy中，浮点数只支持BigDecimal动态创建。也就是说我们创建 def temp=12.3默认的类型是BigDecimal，而不是float类型。
但是我们可以通过在参数值添加f,或者d来告知def类型为float或者double，示例如下：
def s= 12.3 //创建的是一个BigDecimal对象
def f = 12.2f// 创建的是一个Float对象
def d =12.3d //创建的是一个Double对象
def g= 12.3g //创建的是一个BigDecimal对象
2.3 下划线数值
这个特性就和Kotlin中的数值一样，我们可以在数值中添加下划线。（PS：上面的示例中有使用了下划线的数。）
当书写较长的数字时，眼睛很难弄清楚一些数字是如何组合在一起的，例如数值大小超过几千万。甚至数值更大，全部数字混在一起。容易看不明白。
（PS：就和比较大的金额显示时超过1000就添加逗号区分一样， 我们可以通过下划线区分）。
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
上面的示例，并不影响该数值的计算和显示。不会因为添加下划线而由数值变为字符串了。
2.4 数值类型后缀
在创建浮点数时我使用了f，g，d等后缀添加在数值后面。这是为了告诉系统该参数属于什么数据类型。除了这三个以外。还有以下的后缀：
| 数据类型 | 后缀值 |
|---|---|
| BigInteger | G or g |
| Long | L or l |
| Integer | I or i |
| BigDecimal | G or g |
| Double | D or d |
| Float | F or f |
2.5 数学运算
下面简单展示一些数学计算的运算符及其结果类型。（主要是加，减运算）
- byte,char,short和int混合的计算结果是int类型。
- long，byte，char，short和int混合的计算结果将会是long类型。
- 涉及BitInteger和其他整数型参数进行计算的结果将会是BitInteger类型。
- byte、char、short、int，BigInteger的混合计算结果将会是BigDecimal类型。
- float、double和BigDecimal之间的混合计算，结果将会是double。
- 两个BigDecimal之间的运算结果将会是BigDecimal。
这些转换是普通的加减运算。对应的表格如下：
| byte | char | short | int | long | BigInteger | float | double | BigDecimal | |
|---|---|---|---|---|---|---|---|---|---|
| byte | int | int | int | int | long | BigInteger | double | double | BigDecimal |
| char | int | int | int | long | BigInteger | double | double | BigDecimal | |
| short | int | int | long | BigInteger | double | double | BigDecimal | ||
| int | int | long | BigInteger | double | double | BigDecimal | |||
| long | long | BigInteger | double | double | BigDecimal | ||||
| BigInteger | BigInteger | double | double | BigDecimal | |||||
| float | double | double | double | ||||||
| double | double | double | |||||||
| BigDecimal | BigDecimal |
多亏了Groovy的操作符重载，通常的算术操作符可以与BigInteger和BigDecimal一起工作，这与在Java中必须使用显式方法对这些数字进行操作不同。
2.5.1 除法操作
除法操作符/(和/=用于除法和赋值)如果其中一个操作数是float或double则产生double结果，否则产生BigDecimal结果(当两个操作数都是short、char、byte、int、long、BigInteger或BigDecimal的任何组合时)。
如果除法是精确的(即产生的结果可以在相同的精度和刻度范围内表示)，则使用divide()方法执行BigDecimal除法，或者使用MathContext，其精度为两个操作数的最大值加上额外的10的精度，以及最大值10和操作数刻度的最大值。
示例：
def static main(def args) {
def s = 12.3 //创建的是一个BigDecimal对象
def f = 12.2f// 创建的是一个Float对象
def d = 12.3d //创建的是一个Double对象
def aa = s / f / d
def temp1= s.divide(f) //将会返回BigDecimal类型
}
2.5.2 幂运算操作
幂运算用**运算符表示，有两个参数:基数和指数。幂运算的结果取决于它的操作数和运算的结果(特别是如果结果可以表示为整数值)。
总结如下：
- 如果指数是十进制数类型（可以是整数，可以是小数）。
- 如果结果可以用Integer表示，就返回Integer。
- 如果结果用long表示就返回long。
- 否则就会返回Double。
- 如果指数是Integeral类型。
- 如果指数为负数，根据结果值返回该类型可以为Integer，long或者Double。
- 如果指数为正或者0.
- 基数为BigDecimal，则返回BigDecimal结果值。
- 基数为BigInteger，则返回BigInteger结果。
- 基数为Intgent，结果符合就返回Intgent，否则返回BigInteger。
- 基数为Long，结果符合就返回Long，否则返回BigInteger。
这只是说明一下，执行运算之后，数据类型可能会发生的一些变化。
示例代码如下：
//基数和指数是整数，结果可以用Integer表示
assert 2 ** 3 instanceof Integer // 8
assert 10 ** 9 instanceof Integer // 1_000_000_000
// 基础是long，所以将结果放入long中
// (虽然它可以适合整数)
assert 5L ** 2 instanceof Long // 25
// 结果不能表示为Integer或Long，所以返回一个BigInteger
assert 100 ** 10 instanceof BigInteger // 10e20
assert 1234 ** 123 instanceof BigInteger // 170515806212727042875...
// 基数是一个BigDecimal，指数是一个负整数
// 但是结果可以表示为整数
assert 0.5 ** -2 instanceof Integer // 4
// 基数是整数，指数是负浮点数
// 但同样，结果可以表示为整数
assert 1 ** -0.3f instanceof Integer // 1
//基数为整型，指数为负整型
//但结果将被计算为Double
//(基数和指数实际上都转换为双精度值)
assert 10 ** -1 instanceof Double // 0.1
//基数是一个BigDecimal，指数是一个int，所以返回一个BigDecimal
assert 1.2 ** 10 instanceof BigDecimal // 6.1917364224
//基数是浮点数或双精度数，指数是整型数
//但结果只能表示为Double值
assert 3.4f ** 5 instanceof Double // 454.35430372146965
assert 5.6d ** 2 instanceof Double // 31.359999999999996
//指数为十进制数（可以为整数和小数）
//结果只能表示为Double值
assert 7.8 ** 1.9 instanceof Double // 49.542708423868476
assert 2 ** 0.1f instanceof Double // 1.0717734636432956
3. Boolean 布尔类型
布尔值是一种特殊的数据类型，用于表示true和false。
布尔值可以存储在变量中，赋值到字段中，就像任何其他数据类型一样:
def myBooleanVariable = true
boolean untypedBooleanVar = false
booleanField = true
true和false是仅有的两个原始布尔值。但是更复杂的布尔表达式可以用逻辑运算符表示。
此外，Groovy还有一些特殊的规则(通常称为Groovy Truth)，用于将非布尔对象强制转换为布尔值。
布尔型变量，本身比较简单。
4. 小结
上面的相关资料在Grooovy官网链接地址：http://docs.groovy-lang.org/docs/groovy-4.0.6/html/documentation/#_numbers
本篇介绍的基本数值类型的几种情况，以及在运算过程中的一些格式转换。
了解大概知识就可以了。后续使用过程中领悟相关的具体含义。
评论区