侧边栏壁纸
  • 累计撰写 372 篇文章
  • 累计创建 60 个标签
  • 累计收到 109 条评论

目 录CONTENT

文章目录

4. Groovy语法-Number和Boolean数据类型学习

Z同学
2022-11-06 / 0 评论 / 2 点赞 / 48 阅读 / 2,784 字
温馨提示:
本文最后更新于 2022-11-07,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

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

小数可以使用指数,指数字母eE,后面跟着一个可选的符号,示例效果如下:

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 布尔类型

布尔值是一种特殊的数据类型,用于表示truefalse

布尔值可以存储在变量中,赋值到字段中,就像任何其他数据类型一样:

def myBooleanVariable = true
boolean untypedBooleanVar = false
booleanField = true

truefalse是仅有的两个原始布尔值。但是更复杂的布尔表达式可以用逻辑运算符表示。

此外,Groovy还有一些特殊的规则(通常称为Groovy Truth),用于将非布尔对象强制转换为布尔值。

布尔型变量,本身比较简单。

4. 小结

上面的相关资料在Grooovy官网链接地址:http://docs.groovy-lang.org/docs/groovy-4.0.6/html/documentation/#_numbers

本篇介绍的基本数值类型的几种情况,以及在运算过程中的一些格式转换。

了解大概知识就可以了。后续使用过程中领悟相关的具体含义。

2

评论区