groovy if 判断字符串_Groovy语法

素颜马尾好姑娘i 2022-10-31 01:36 504阅读 0赞

注释

单行注释//

//这是单行注释

多行注释/\*\*/

/\*这是多行注释\*/

// GroovyDoc注释/\*\* \*/

/\*\*

\* 这是文档注释

\*/

变量名

普通变量名和Java规则一样

引用变量，变量点后面可以跟引用值，可以使用java不允许的符号比如破折号等,比如

map = \[:\]

map."name" = "james"

map."a-b-c" = "dota"

map./slashy string/

map.$/dollar slashy string/$

def firstname = "Homer"

map."Simpson-$\{firstname\}" = "Homer Simpson"

字符串

单引号字符串

'hello world'

三引号字符串表示多行

""" line 1

line 2

line 3

双引号字符串，可以使用或者\{\}在字符串中进行插值，其中$\{\}可以插入值或者表达式,但是表达式必须要以某种形式返回值否则值为null。

其中$只对a.b有效，对其他语句无效如方法调用,大括号等，如果想输入$符号可以使用""

"2 + 3 is $\{2+3\}" // output 2+3 is 5

"2 + 3 is $\{def i = 2; def j = 3; i+j\}" // output 2 + 3 is 5

def person = \[name: 'James', age: 36\]

"$person.name is 36" // output James is 36

"person is $def age = 10" // 不合法

当字符串中存在$\{->\}形式，这表示一个闭包，闭包包含0个参数或者1个参数

0个参数的闭包会调用toString()作为值,即->后面的值会toString，如果是表达式必须要有返回值，否则为null

1个参数的闭包会传入的参数类型为StringWriter，用这个参数可以追加内容, 可以使用"<

def person = "1 + 2 is $\{->3\}"

def person = "1 + 2 is $\{w -> w.append("5")\}"

def person = "1 + 2 is $\{w -> w << "5"\}"

上述两种插值方法对比，采用闭包的好处可以动态更新数据，如果变量值更新了，闭包所用参数也对应更新。

如下所示可以看出，当num值更新时，字符串闭包内的值也改变了， 普通传值没有改变是因为创建String的时候值就已经确定了。

def num = 3

def normal = "1 + 2 is $\{-> num\}"

def cls = "1 + 2 is $\{num\}"

println(normal) // output "1 + 2 is 3"

println(cls) // output "1 + 2 is 3"

num = 5

println(normal) // output "1 + 2 is 3"

println(cls) // output "1 + 2 is 5"

字符串使用插值，类型则会被转换为GString，类型，值得注意的是GString类型的hashCode和String类型的hashCode是不一样的

def key = "a"

map = \[$\{key\}:"James"\]

printfln map\["a"\] // output null

Char类型可以用以下三种来表示

def a = 'A'

def b = 'A' as char

def c = (char)'A'

Numbers

整数数据类型基本和Java一样分别是byte、short、char、int、long、BigInteger

如果类型修饰符为def，会根据范围，自动识别对应的数据类型

def i = 10

println i instance of Interger // Output ture

小数数据类型分别是float、double、BigDecimal

float a = 1.2

double b = 1.21

数字可以添加下划线，使某些大数看起来更加清楚

long i = 1223\_123\_1L

long i = 0x7fff\_8fff\_0000\_ffff

通过数字后缀来代表数据类型

Integer a = 42I或42i

Long b = 42L或42l

BigInteger c = 42G或42g

Double d = 42.2D或42.5d

Float e = 42.2F或42.1f

BigDecimal f = 42.24G或42.24g

List

Groovy使用逗号分隔值(用方括号括起来)来表示列表，默认类型为List, 一个List的值可以是不同类型

def listone = \[1,2,3,4\]

def listtwo = \[1, 1.24, "hello"\]s

List是ArrayList的实例，可以通过as进行转换成其他类型的List

def list = \[1,2,3,4\] as LinkedList

List索引可以使用以下几种形式， 可以用<

def list = \[1,2,3,4\]

list\[-1\]

list\[2\]

list\[1..3\]

list << 5

多维List

list = \[\[0,1\],\[2,3\]\]

list\[0\]\[1\]

Arrays

Arrays的形式上和List是一样的，但是如果需要Arrays类型数据，需要通过变量指定数据类型或者通过as强转

int\[\] list = \[1,2,3,4,5\]

def list = \[1,2,3,4\] as int\[\]

索引，多维数组等定义和List一样

Maps

Groovy使用逗号分隔值(用方括号括起来)，键值对冒号分隔来表示Map

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

colors\['pink'\] = '\#FF00FF'

colors.yellow = '\#FFFF00'

如果想要引用变量作为key值，则需要加上括号

def key = 'pink'

def map = \[(key) :123\]

操作符

\*\* 表示次方, 下面表示2的3次方

def num = 2 \*\* 3

双目运算符?:,是一个false 赋值

def a = 8

def b = a < 7 ?:10

// 等价于

if(a < 7) \{

b = ture

\} else \{

b = 10

\*.操作符，将cars中make元素全部收集到同一个列表

class Car \{

String make

String model

def cars = \[

new Car(make: 'Peugeot', model: '508'),

new Car(make: 'Renault', model: 'Clio')\]

def makes = cars\*.make

assert makes == \['Peugeot', 'Renault'\]

Spread操作符可以将list列表中值传入符合list数量的方法中, 也可以直接插入到另外一个list中

def list = \[1,2,3\]

int f(int i, int j, int z) \{

return i \* j + z

f(\*list)

def other = \[4,5, \*list\] // output \[4,5,1,2,3\]

def other = \[4,5, list\] // output \[4,5,\[1,2,3\]\]

map中也可以使用

def map = \[red : 0x1\]

def add = \[green : 0x2, \* : map\]

// output \[green:34, red:17\]

Range操作符.., 生成一个有序列表

def i = 0..5 // output \[0,1,2,3,4,5\]

def i = 0..<5 // output \[0,1,2,3,4\]

def i = 'a'..'d' // output \['a','b','c','d'\]

比较操作符<=>, 类似java中的compareTO方法，

(1<=>1) = 0

(2<=>1) = 1

(2<=>3) = -1

下标操作符,类似getAt()或putAt()方法

def list = \[0,1,2,3,4\]

list\[3\] = 5 // output \[0,1,2,5,4\]

list\[4\] // output 4

成员关系操作符in，判断一个数据成员是否在列表当中

def list = \[1,2,3\]

5 in list // output false

Identity操作符，==操作符在Groovy和Java中使用是不一样的， ==比较是值是否相等，equals比较的是内存地址是否一样

def list1 = \[1,2,3\]

def list2 = \[1,2,3\]

list1.is(list2) // output false

list1 == list2 // output true

Integer a = new Integer(5);

Integer b = new Integer(5);

println a.is(b) // output false

println a == b // output true

转换操作符as，as操作符如果符合转换规则，就可以转换，否则会抛异常。如果转换为另外一个类型就会创建一个新的对象

Integer x = 123 as String // output "123"

String a = "123" as Map // 抛异常

Groovy支持运算符重载

包

包支持用别名

import java.util.Date as SQLDate

SQLDate date = new SQLDate()

脚本和类，Groovy会把脚本转换成一个类，这个类继承于Script，最终调用的还是main()方法,我们在写脚本中写的方法会被加入到类中，写的语句全部在run()方法中。

println 'Hello'

int power(int n) \{ 2\*\*n \}

println "2^6==$\{power(6)\}"

// 转换之后

import org.codehaus.groovy.runtime.InvokerHelper

class Main extends Script \{

int power(int n) \{ 2\*\* n\}

def run() \{

println 'Hello'

println "2^6==$\{power(6)\}"

static void main(String\[\] args) \{

InvokerHelper.runScript(Main, args)

脚本中变量作用域。

变量如果声明类型，则无法被其他方法访问，因为这个变量相当于run方法中的局部变量

变量如果没有声明类型，则会被脚本绑定，脚本会和其他方法共享这些数据

int declared = 0

undeclared = 10

void pow() \{

println declared

println undeclared

pow()

反编译之后的代码, 可以看到run方法中会把变量值传入，pow方法中把值取出来

public class Study extends Script

public void pow()

CallSite\[\] arrayOfCallSite = $getCallSiteArray();

arrayOfCallSite\[2\].callCurrent(this, arrayOfCallSite\[3\].callGroovyObjectGetProperty(this));

arrayOfCallSite\[4\].callCurrent(this, arrayOfCallSite\[5\].callGroovyObjectGetProperty(this));

public Object run()

CallSite\[\] arrayOfCallSite = $getCallSiteArray();

int declared = 0;

int i = 10;

ScriptBytecodeAdapter.setGroovyObjectProperty(Integer.valueOf(i), Study.class, this, (String)"undeclared");

pow();

public static void main(String... args)

CallSite\[\] arrayOfCallSite = $getCallSiteArray();

arrayOfCallSite\[0\].call(InvokerHelper.class, Study.class, args);

方法和类

如果没有可见修饰符修饰，默认是public的,并且会自动转换成属性，自然省去get和set方法

public class Study \{

public String name;

class School \{

Study study = new Study();

public void driver() \{

一个文件可以包含多个类，如果没有类默认是脚本(当然最后还是会转换为一个类)

不论是构造函数还是普通函数参数都可以通过列表传入, 方法参数可以设置默认值

public class Study \{

public Study(String name, int age) \{

public void pow(int a, int b = 9) \{

Study study = \["1",2\]

study.pow(\[5,6\])

study.pow(5)

方法可变参数列表

可以传入任意个参数

T\[\]和T..是等价的，也表示可见参数，意味方法参数列表为数组的，都表示可变参数。

如果出现多个方法重载，比如一个方法参数列表是可见参数，另外一个方法参数列表是具体个数参数，以含具体个数参数方法为主

void f(int\[\] a);

void f(int a);

f(1) // 调用的是f(int a)方法

Traits(特征)

是Groovy独有的面向对象特性，有几点特性：由行为构成、可以实现接口、行为可以重载，兼容静态类型的检查和编译。可以看成具有方法实现和状态的接口，关键字trait

trait FlyingAbility \{

String fly() \{

println "I'm flying!"

class Bird implements FlyingAbility \{\}

def b = new Bird()

println b.fly()

可以含有抽象方法

trait Greetable \{

abstract String name()

String greeting() \{ "Hello, $\{name()\}!" \}

可以定义private方法

trait Greeter \{

private String greetingMessage() \{

'Hello from a private method!'

String greet() \{

def m = greetingMessage()

println m

可以使用this操作符

public trait FlyingAbility \{

String fly() \{

return this

可以定义属性

trait Named \{

String name

可以定义私有和共有字段

trait Counter \{

public int num = 1

private int count = 0

int count() \{ count += 1; count \}

和接口一样支持多重继承

trait FlyingAbility \{

String fly() \{ "I'm flying!" \}

trait SpeakingAbility \{

String speak() \{ "I'm speaking!" \}

class Duck implements FlyingAbility, SpeakingAbility \{\}

方法可以被覆盖、相互继承

trait FlyingAbility \{

String fly() \{

"I'm flying!"

trait SpeakingAbility extends FlyingAbility \{

String fly() \{

"I can speaking!"

闭包

闭包是一个匿名函数，拥有函数的特征，写法如下\{ \[closureParameters -> \] statements \}, 有以下几种写法

\{ item++ \}

\{ -> item++ \}

\{ println it \}

\{ it -> println it \}

\{ name -> println name \}

\{ String x, int y ->

println "hey $\{x\} the value is $\{y\}"

\{ reader ->

def line = reader.readLine()

line.trim()

闭包作为一个对象,是groovy.lang.Closur一个实例，可以赋值给该类的实例对象

def listener = \{ e -> e \}

println listener //output \`groovy.lang.Closure\`对象

println listener("lis") // output "lis"

Closure callback = \{ println 'Done!' \}

Closure isTextFile = \{

File it -> it.name.endsWith('.txt')

闭包可以像其他方法一样被调用，可以像其他函数一样传参进入，也可以当成一个对象调用call方法

def isOdd = \{

int i -> i%2 != 0

isOdd(2)

isOdd.call(2)

闭包跟函数一样，参数列表可以是对象，基本类型，可选列表，也可以给参数设置默认值，

不过和函数不同的地方，如果闭包没有确切定义一个参数列表，闭包就会定义一个隐式参数it

def f = \{-> printfln it\}

def f = \{it -> println it\}

闭包中的this,owner,delegate

this：在一个类中定义闭包，闭包中的this指向该类，

getThisObject()和this是等价的。

类中定义闭包使用this，则指向内部类,在该闭包中可以调用该类的成员变量和方法

闭包中嵌套使用闭包，this也是指向类

总之，无论闭包怎么嵌套，闭包中使用this就指向离他最近的类

class Enclosing \{

void run() \{

def whatIsThisObject = \{ getThisObject() \}

assert whatIsThisObject() == this

def whatIsThis = \{ this \}

assert whatIsThis() == this // 等价

class EnclosedInInnerClass \{

class Inner \{

Closure cl = \{ this \}

void run() \{

def inner = new Inner()

// 内部类定义闭包使用this，则指向内部类

assert inner.cl() == inner

class NestedClosures \{

void run() \{

def nestedClosures = \{

def cl = \{ this \}

cl()

// 闭包嵌套闭包，则this也指向类

assert nestedClosures() == this

owner: 指向一个封闭的对象，可以是一个类或者闭包

owner和getOwner()是等价的

如果闭包定义在内部类中，指向的也是这个内部类

但是如果owner在嵌套闭包内，则指向的是outer闭包，并非和this一样是类

总结：和this一样都是返回封闭对象，但是this值包含类，owner包含了闭包和类

delegate: 委托可以被赋值成定义的任何对象，默认情况下，delegate和owner的指向范围一样

但是区别是delegate可以被赋于其他对象，而owner则不行

class Person \{

String name

class Thing \{

String name

def p = new Persong(name: "Normal")

def t = new Thing(name : "Teapot")

def a = \{

delegate.name.toUpperCase()

def b = \{

owner.name.toUpperCase()

a.delegate = p

a() // output NORMAL

b.owner = t

b() //报错，因为不允许被转为t对象

groovy if 判断字符串_Groovy语法

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Groovy系列一 Groovy基础语法

相关 Groovy

相关三、Groovy语法讲解

相关 groovy if 判断字符串_Groovy语法

相关 Groovy学习-集合语法增强

相关 Groovy

相关 Groovy学习--基本语法了解

相关 Groovy语法学习(五)运算符重载

相关 Groovy语法学习(一) 基本语法

相关 groovy简单语法