Hello Groovy
def str = "Hello Groovy"
println "${str}"
字符串操作
单引号表示静态的字符串
双引号表示动态的字符串
连续三个双引号表示字符串段落
例
def str = "Hello Groovy";
def str2 = """
hello!
my name is zhangsan!
my email is [email protected]
"""
println "${str}";
println '${str}';
println str2;
输出:
Hello Groovy
${str}
hello!
my name is zhangsan!
my email is zhangsan@qq.com
/*************************/
println str.size() // java.length()
println str[0..4] // java.substring()
println str.reverse() // 字符串反转
/*************************/
数字操作
def x = 1;
def y = 2;
println x+y;
println x.plus(y) // 等同于x+y
类
与java类似
但是class前面没有限定符,构造器基于Map初始化
不需要写get,set方法
class A{
String p1;
String p2;
}
def a = new A(p1:"a",p2:"b") // 实例化对象
println a.p1 // 相当于get方法
println a.p2
运算符
大部分与java相同
特别注意
== 比较值是否相等
.is() 比较对象引用的地址是否相等
java
== 比较对象引用的地址是否相等
.equals() 比较值是否相等
例
def str = 'hello';
def str2 = str;
def str3 = new String('hello');
def str4 = 'Hello';
println str == str2 // true
println str == str3 // true
println str == str4 // false
println str.is(str2) // true
println str.is(str3) // false
println str.is(str4) // false
if结构
在java中条件的表达式计算结果只能是布尔值
在Groovy中
传入boolean或Boolean时,与Java相同
传入数字时,非0为真,0为假
传入字符串时,空字符串尾假,反之为真
传入集合时,元素个数等于0为假,元素个数大于0为真
传入 对象时,null为假,反之为真
for结构
for传统风格
for(int index=0;index<10;index++){
println index;
}
for-each风格
for(int index in 0...10){
println index
}
times风格
10.times{
println it
}
switch结构
与java不同的是,case子句内可以进行多种复杂的判断
switch(10){
case 0:println "0";
break;
case 0..9:println "range from 0 to 9";
break;
case [8,9,11]:printl "in 8,9,11";
break;
case {it % 3 == 0}:println "multiple of 3";
break;
...
default: println "not found";
break;
}
例:
switch(78){
case 0..59: println "不及格";break;
case 60..68: println "及格"; break;
case 70..79: println "良好"; break;
}
groovy集合
列表List(java.util.List)
def datas = [10,8,4,1,3,7,6,2,5,9]
datas.max() // 最大值
datas.min() // 最小值
datas.sum() // 求和
datas.count(1) // 统计1 的个数
datas.sort() // 从小到大排序
datas.size() // 元素个数
datas.reverse() // 元素反转
datas<<5 // 在列表末尾添加元素5
映射Map(java.util.Map)
def datas = [name:"ZhangSan",age:"21",sex:"male"]
datas.name // 访问key为name的元素值
datas[name] // 访问key为name的元素值 (datas["name"]要加引号)
datas.remove(key) // 删除key元素
// 闭包
datas.each{
data ->
println data.key +","+data.value
}
区间Range
闭区间:起始..结束
右开区间:起始..<结束
def range1 = 1..5
def range2 = 1..<5
range1.size() // 元素个数
range2.contains(5) // 是否包含5元素
闭包
闭包是Java所不具备的语法结构
闭包就是一个代码块,用{}括起来。
程序代码也成为数据,可以被一个变量所引用
Groovy的API大量使用闭包,以实现对外开放
例:
// 不带参数的闭包
def closure1 = {
println it
};
closure1.call("Hello Groovy");
// 带一个参数的闭包
def closure2 = {
text ->
println text
}
closure2("Hello Groovy2");
// 带两个参数的闭包
def closure3 = {
name,age ->
println "my name is ${name},I am ${age} year old";
println name+age;
}
closure3("zhangsan",12)
Delegate属性
指定了闭包的代理对象,默认情况下delegate与this是相同的,
但可以手动修改delegate的值,使闭包可以访问其他对象的方法和属性。
class Handler{
def method(){
println "handler method called..."
}
}
class Example{
def method(){
println "example method called...";
}
def foo(closure){
// 指向Handler对象
closure.delegate = new Handler()
closure();
}
}
// 创建实例化对象
new Example().foo{
method();
}
文件的读取
new File("filepath").text
// 闭包方式读取文件
new File("C:/Users/caizh/Desktop/groovy笔记.txt").eachLine{
line ->
println line;
}
文件的写入
def out = new File("filepath").newPrintWriter()
out.write("content")
out.flush()
out.close()
new File("filepath").withPrintWriter{
out ->
out.println("content")
}
groovy的XML处理
xml文档
<languages type="current">
<language author="James Gosling">java</language>
<language author="Anders Hejlsbeng">C#</language>
</languages>
解析xml
def languages = new XmlParser().parse(new File("languages.xml"))
println "type=${languages.attribute("type")}"
languages.language.each{
println "language:${it.text()},author:${it.attribute("author")}"
}
创建xml
import groovy.xml.*;// 注意导包
def out = new StringWriter()
def xml = new MarkupBuilder(out)
// 根节点(属性值)
xml.langs(type:"current"){
// 前面如果没有属性名称,则为节点的文本信息
language("java",author:"James Gosling")
language("C#",author:"Anders Hejlsberg")
language("SQL",name:"mysql")
}
def file = new File("C:/Users/caizh/Desktop/languages.xml")
file.write(out.toString())
创建HTML
import groovy.xml.*;
def out = new StringWriter()
def html = new MarkupBuilder(out)
html.html{
head{
title("Hello HTML")
}
body{
h1("Here are my HTML bookmarks");
a(href:"http://www.baidu.com","百度一下");
}
}
def file = new File("C:/Users/caizh/Desktop/index.html");
file.write(out.toString());
Groovy的JSON处理
解析JSON
import groovy.json.*
// 实例化JsonSlurper对象
def root = new JsonSlurper().parseText(new File("C:/Users/caizh/Desktop/index.txt").text);
// 访问person。name
println root.person.name
println root.person.sex
println root.person.age
root.person.hobbies.each{
print it + ","
}
生成JSON
import groovy.json.*
def json = new JsonBuilder()
json.person{
name "Zhangsan1"
sex "male"
age 21
hobbies "running","basketball","tennis"
}
println JsonOutput.prettyPrint(json.toString())
groovy连接数据库
def sql = groovy.sql.Sql.newInstance("jdbc:mysql://localhost:3306/groovy","root","root","com.mysql.jdbc.Driver");
println sql.connection
// 插入数据操作
//sql.executeInsert("insert into student value(default,?,?)",["zhangsan",'male']);
//sql.executeInsert("insert into student value(default,?,?)",["li si",'female']);
//sql.executeInsert("insert into student value(default,'wang wu','male')");
// 更新数据操作
//sql.executeUpdate("update student set sex = ? where id = ?",['female',3]);
// 删除数据操作
//sql.execute("delete from student where id=?",[3]);
// 查询数据操作
sql.eachRow("select * from student"){
println "Id:${it.id} Name:${it.name} Sex:${it.sex}";
}
GORM
Grails Object Relational Mapping(对象关系映射)
在底层,它使用Hibernate5(一个非常流行和灵活的开源ORM解决方案),
但是因为Groovy天生的动态性,实际上,对动态类型和静态类型两者都支持,
由于Grails的规约,只需要很少的配置涉及Grails domain类的创建。
(操作对象一样来操作数据库中的数据,不再写繁琐的SQL语句)
import grailsorm.Student
// 插入数据操作
/*def stu1 = new Student(name:"zhangsan",sex:"male",age:21)
def stu2 = new Student(name:"lisi",sex:"female",age:12)
def stu3 = new Student(name:"wangwu",sex:"male",age:23)
stu1.save(flush: true)
stu2.save(flush: true)
stu3.save(flush: true)*/
// 读取数据
/*def student = Student.get(1)
println student.name;
println student.age;
println student.sex;*/
// 更新数据操作
/*def student = Student.get(1)
student.name = "Mike";
student.save(flush: true);*/
// 删除数据操作
/*def student = Student.get(3)
student.delete(flush: true)*/
// 查询列表
/*def students = Student.list()
students.each{
s->
println s.name
}*/
// 查询数据带条件
def students = Student.where{
sex == 'male'
}.find()
students.each{
s ->
println s.name
}