- 数据类型
int x = 10;
println x.class; //Integer
double y = 10.10;
println y.class;//Double
def x_1 = 11;
println x_1.class//Integer
def y_1 = 11.11;
println y_1.class//BigDecimal
def name = "Huangxiaoguo"
println name.class//String
name=18
println name.class//Integer
- String
package variable
/**
* String
*/
println "-----------------单引号---------------------"
def name = 'a single \'H\' string'
println name.class//string
println "-----------------单引号---------------------"
println "-----------------三引号---------------------"
def thuplename = ''' huangxiaoguo
132213123
thuplename'''
println thuplename
println thuplename.class//string
println "-----------------三引号---------------------"
println "----------------双引号-------------------------"
def doubleName = "this a common String"
println doubleName.class//string
println "----------------双引号-------------------------"
println "------------------GString(插值)--------------------"
def name1 = "Huangxiaoguo"
def eat = "cafan:${name1}"
println eat//cafan:Huangxiaoguo
println eat.class//GString
println "------------------GString(插值)--------------------"
println "------------------GString(运算)--------------------"
def sum = "The sun of 1 and 1 equals ${1 + 1}"//可拓展任意的表达式
println sum//The sun of 1 and 1 equals 2
println "------------------GString(运算)--------------------"
println "-----------------方法---------------------"
def result = echo("我是一个message");
println result//我是一个message
println result.class//String
String echo(String message) {
return message;
}
println "-----------------方法---------------------"
/*=========================字符串的方法=========================*/
/**
* 字符串的填充
*/
def str = "groovy Hello huangxiaoguo"
println str.center(28, 'a')//从中间对两边进行填充,agroovy Hello huangxiaoguoaa
println str.center(28,)//用空格进行填充, groovy Hello huangxiaoguo
println str.padLeft(28, 'a')//从左边进行填充,aaagroovy Hello huangxiaoguo
println str.padRight(28, 'a')//从右边进行填充,groovy Hello huangxiaoguoaaa
/**
* 字符串大小比较
*/
def str1 = "Hello"
println str > str1 //true
/**
* 索引
*/
println str1.charAt(1)//e
println str1[1]//e
println str1[0..3]//Hell
/**
* 减法
*/
println str.minus(str1)//groovy huangxiaoguo
println str - str1//groovy huangxiaoguo
/**
* 倒叙输出
*/
println str.reverse()//ougoaixgnauh olleH yvoorg
/**
* 首字母大写
*/
println str.capitalize()//Groovy Hello huangxiaoguo
/**
* 是否是数字
*/
println str.isNumber()//false
/**
* 数据类型转换
*/
println str.toBoolean()//false
//强制转换为boolean
println str as boolean//true
//println str.toInteger()
/**
* 大小写
*/
println str.toLowerCase()//groovy hello huangxiaoguo
println str.toUpperCase()//GROOVY HELLO HUANGXIAOGUO
- 逻辑控制
println "------------------switch--------------------"
def x = "a";
def result;
switch (x.class) { //这个相当于
case "a":
result = "我是 a"
break
case 'b':
result = "我是 b"
break
case [4, 5, 6, 'c']://列表
result = "我是个数组"
break
case 10..50://范围
result = "我是10到50的数"
break
case Integer:
result = "我是Integer类型"
break
case BigDecimal:
result = "我是BigDecimal类型"
break
case String:
result = "我是String类型"
break
default:
result = "default"
break
}
println result//我是String类型
println "------------------switch--------------------"
/**
* 对范围的for循环
*/
def sum=0;
for (i in 0..9){
sum+=i;
}
println sum//45
/**
* 对list的循环
*/
def sum1=0;
for (i in [1,3,5,32,4,2,6,9,5,45,1]){
sum1+=i;
}
println sum1//113
/**
* 对Map进行循环
*/
def sum2=0;
for (i in ['a':1,"b":2,"c":"ha"]){
sum2+=i.value
}
println sum2//3ha
- 数据结构
/**
* 数据结构
*
* 范围
*/
def range=1..10;
println range[0]//1
println range.contains(10)//true
println range.contains(11)//false
println range.from//1
println range.to//10
/**
* 遍历
*/
//第一种
range.each {println it}
//第二种
for (i in range){
println i
}
/**
* 范围使用
* @param number
*/
def getGrade(Number number){
def result
switch (number){
case 0..<60:
result='不及格'
break
case 60..<70:
result='及格'
break
case 70..79:
result='良好'
break
case 80..<100:
result='优秀'
break
}
return result
}
def result=getGrade(80)
println result//优秀
/**
* 数据结构
*
* 列表
*/
println "------------------------------------------------列表的定义-----------------------------------------"
//def list =new ArrayList()//java的定义方式
def list = [1, 2, 3, 4, 5]
println list.class//ArrayList
def array = [1, 2, 3, 4, 5] as int[]
int[] array2 = [1, 2, 3, 4, 5]
println array.class//数组
println array2.class//数组
println "------------------------------------------------列表的排序-----------------------------------------"
/**
* java的方式
*/
def sortList = [6, 12, 1, -8, 5, -2, 5, 55]
Comparator mc = { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 }
Collections.sort(sortList, mc)
println sortList
/**
* groovy的方式
*/
def sortList1 = [6, 12, 1, -8, 5, -2, 55]
sortList1.sort { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? 1 : -1 }
println sortList1
def sortStringList = ['abc', 'z', 'huang', 'hello', 'groovy']
sortStringList.sort { it -> return it.size() }
println sortStringList
println "------------------------------------------------列表的查找-----------------------------------------"
def findList = [-3, 6, 2, 7, -9, 1, 5]
int result = findList.find { return it % 2 == 0 }
println result//6
def result1 = findList.findAll { return it % 2 != 0 }
println result1.toListString()//[-3, 7, -9, 1, 5]
def result2 = findList.any { return it % 2 != 0 }
println result2//true
def result3 = findList.every { return it % 2 != 0 }
println result3//false
def result4 = findList.min()
println result4//-9
def result5 = findList.max()
println result5//7
def result6 = findList.min { return Math.abs(it) }
println result6//1
def result7 = findList.max { return Math.abs(it) }
println result7//-9
def count = findList.count { return it % 2 == 0 }
println count//2
/**
* 数据结构
*
*
* 映射
*/
println "------------------------------------------------map的定义-----------------------------------------"
//def list =new HashMap()//java的定义方式
def colors = [red : 'ff0000',
green: '00ff00',
blue : '0000ff']
def colors1 = [red1 : 'ff0000',
green1: '00ff00',
blue1 : '0000ff']
/**
* 索引方式
*/
println colors['green']
println colors.blue
/**
* 添加元素
*/
colors.yellow = 'ffff00'
colors.compute = [a: 1, b: 2]
colors.putAll(colors1)
colors.remove("red1")
println colors.toMapString()
println colors.getClass()//LinkedHashMap,不能使用colors.class
println "------------------------------------------------map的详解-----------------------------------------"
def students = [
1: [name: 'huang1', age: 17],
2: [name: 'huang2', age: 20],
3: [name: 'huang3', age: 19],
4: [name: 'huang4', age: 21],
5: [name: 'huang4', age: 18]
]
/**
* 遍历
*/
students.each { def student ->
println "key===>${student.key},value==>${student.value}"
}
/**
* 带索引的遍历
*/
students.eachWithIndex { def student, int position ->
println "index===>${position},key===>${student.key},value==>${student.value}"
}
/**
* 直接遍历key-value
*/
students.each { key, value ->
println "key==>${key},value==>${value}"
}
/**
* 带索引的直接遍历key-value
*/
students.eachWithIndex { key, value, position ->
println "index===>${position},key===>${key},value==>${value}"
}
/**
* map的查找
*/
def entry = students.find { def student ->
return student.value.age > 19
}
println entry//2={name=huang2, age=20}
def entrys = students.findAll { def student ->
return student.value.age > 19
}
println entrys//[2:[name:huang2, age:20], 4:[name:huang4, age:21]]
def count = students.count { def student ->
return student.value.age > 19
}
println count//2
def names = students.findAll { def student ->
return student.value.age > 19
}.collect {
return it.value.name//过滤名字
}
println names.toListString()//[huang2, huang4]
/**
* 分组
*/
def group = students.groupBy { def student ->
return student.value.age >= 18 ? '成年' : '未成年'
}
println group.toMapString()//[未成年:[1:[name:huang1, age:17]], 成年:[2:[name:huang2, age:20], 3:[name:huang3, age:19], 4:[name:huang4, age:21], 5:[name:huang4, age:18]]]
/**
* 排序
*/
def sort = students.sort { def student1, def student2 ->
Number socre1 = student1.value.age
Number socre2 = student2.value.age
return socre1 == socre2 ? 0 : socre1 < socre2 ? -1 : 1
}
println sort.toMapString()//[1:[name:huang1, age:17], 5:[name:huang4, age:18], 3:[name:huang3, age:19], 2:[name:huang2, age:20], 4:[name:huang4, age:21]]
- 闭包
/**
* 闭包
*/
def clouser = { println "Hello groovy" }
clouser.call()
clouser()
/**
* 闭包传参
*/
def clouser1 = { String name, int age -> println "Hello ${name},age is ${age}" }
clouser1.call("huang", 18)
clouser1("groovy", 99)
/**
* 闭包传参(默认，隐式参数)
*/
def clouser2 = { println "Hello ${it}" }
clouser2.call("huang")
clouser2("groovy")
/**
* 返回值
*/
def clouser3 = { String name -> return "Hello ${name}" }
def result = clouser3("huangxiaoguo")
println result
println "------------------------------------------------闭包在基本数据类型中使用-----------------------------------------"
/**
* 用来求指定number的阶乘
* @param number
* @return
*/
int fab(int number) {
int result = 1
1.upto(number, { num -> result *= num })
return result
}
int fab2(int number) {
int result = 1
number.downto(1) {
//在groovy中可以把Closure放到括号外面，效果一样
num -> result *= num
}
return result
}
//int x = fab(5);
int x = fab2(5);
println x
/**
* 求和，（注意times的起始值一直是0，因此不能用作阶乘等其他操作）
* @param number
* @return
*/
int cal(int number) {
int result;
number.times {
num -> result += num
}
return result
}
int x1 = cal(101);
println x1
/**
* 绝对值
* @param number
* @return
*/
int abs(int number) {
return number.abs()
}
int x2 = abs(-101);
println x2
println "---------------------------------------------字符串和闭包结合使用-----------------------------------------------"
String str = "love and 2 to be 1 love all 8 happiness"
/**
* each的遍历
*/
str.each {
// String temp ->print temp.multiply(2)
String temp -> print temp
}
println()
/**
* find来查找符合条件的第一个
*/
println str.find {
String s -> s.isNumber()
} //2
/**
* findAll来查找符合条件的集合
*/
def list = str.findAll { String s -> s.isNumber() }
println list.toListString()//[2, 1, 8]
/**
* 只要满足就是true
*/
println str.any {
s -> s.isNumber()
}
/**
* 要全部满足才返回true
*/
println str.every {
s -> s.isNumber()
}
/**
* 遍历所有字母
*/
def list2 = str.collect {
it.toUpperCase()
}
println list2.toListString()//[L, O, V, E, , A, N, D, , 2, , T, O, , B, E, , 1, , L, O, V, E, , A, L, L, , 8, , H, A, P, P, I, N, E, S, S]
println "-------------------------------------闭包的三个重要变量：this,owner,delegate-----------------------------------"
def scriptClouser={
println "scriptClouser this:"+this//代表闭包定义处的类
println "scriptClouser owner:"+owner//代表闭包定义处的类或者对象
println "scriptClouser delegate:"+delegate//代表任意对象,默认与owner一致
}
scriptClouser.call()
/**
* 定义了一个内部类
*/
class Person{
def static classClouser={
println "scriptClouser this:"+this
println "scriptClouser owner:"+owner
println "scriptClouser delegate:"+delegate
}
def static say(){
def classClouser={
println "methodScriptClouser this:"+this
println "methodScriptClouser owner:"+owner
println "methodScriptClouser delegate:"+delegate
}
classClouser.call()
}
}
Person.classClouser.call()
Person.say()
println "-------------------------------------"
/**
* 闭包中定义一个闭包
*/
def nesrClouser={
def innerClouser={
println "innerClouser this:"+this
println "innerClouser owner:"+owner//与this不一样,variable.clouserstudy$_run_closure12@1500b2f3
println "innerClouser delegate:"+delegate //默认和owner一样
}
innerClouser.delegate=Person //修改默认的delegate, delegate:class variable.Person
innerClouser.call()
}
nesrClouser.call()
println "------------------------------------------------闭包的委托策略-------------------------------------------------"
class Student{
String name;
def pretty ={
"My name is ${name}"
}
String toString(){
pretty.call()
}
}
class Teacher{
String name
}
def stu = new Student(name:"Student")
def tea = new Teacher(name: 'Teacher')
println stu.toString()//My name is Student
stu.pretty.delegate=tea
//修改委托策略（DELEGATE_FIRST,DELEGATE_ONLY......）
stu.pretty.resolveStrategy=Closure.DELEGATE_FIRST//有限寻找tea，找不到再找stu
println stu.toString()//My name is Teacher
-
面向对象
创建接口
/**
* 接口中不允许定义非public的方法
*/
interface Action {
void eat()
void drink()
void play()
}
创建抽象接口
/**
* 类似于interface ，但是trait可以进行方法的实现（类似java中的abstract）
*/
trait DefaultAction {
abstract void eat();
void play1(){
println 'DefaultAction'
}
}
构建对象
/**
* 1.groovy中默认都是public类型
*/
class Persion implements Action, DefaultAction {
String name
Integer age
def increaseAge(Integer years) {
this.age = years
}
@Override
void eat() {
}
@Override
void drink() {
}
@Override
void play() {
}
/**
* 一个方法找不到时，调用它代替
* @param name
* @param args
* @return
*/
def invokeMethod(String name, Object args) {
return "name=>${name},args=>${args}"
}
def methodMissing(String name, Object args){
return "the method ${name} is missing"
}
}
具体操作
/**
* 2无论你是直接，还是调用get/set最终都是调用get/set
*/
def persion = new Persion(name: 'android', age: 26)
println " name is ${persion.name},age is ${persion.getAge()}"// name is android,age is 26
persion.increaseAge(20)
println " name is ${persion.name},age is ${persion.getAge()}"// name is android,age is 20
persion.play1() //DefaultAction
//the method cry is missing
println persion.cry()//没有cry这个方法时，默认调用methodMissing方法->没有的话->invokeMethod方法
/**
* 为类动态的添加一个属性
*/
Persion.metaClass.sex = '我是动态添加的属性'
Persion.metaClass.nameMethod = { -> name.toUpperCase() }
Persion.metaClass.static.createPerson={
String name, int age->new Persion(name: name,age: age)
}
def person = new Persion(name: 'android', age: 26)
println person.sex //我是动态添加的属性
person.sex = '修改属性'
println person.sex //修改属性
println person.nameMethod() //ANDROID
def person1 = Persion.createPerson("dongtai", 99)
println person1.name+","+person1.age //dongtai,99
- groovy 运行时时序表
- json操作
/**
* 1.groovy中默认都是public类型
*/
class Person implements Serializable {
String name
Integer age
String getName() {
return name
}
void setName(String name) {
this.name = name
}
Integer getAge() {
return age
}
void setAge(Integer age) {
this.age = age
}
}
import groovy.json.JsonOutput
import groovy.json.JsonSlurper
import objectorention.Persion
def list=[new Persion(name: 'huangxiaoguo1',age: 25),
new Persion(name: 'huangxiaoguo2',age: 26),
new Persion(name: 'huangxiaoguo3',age: 27),
new Persion(name: 'huangxiaoguo4',age: 28)]
/**
* 将对象转换为json
*/
println JsonOutput.toJson(list)
/**
* 打印格式化的json串
*/
def json = JsonOutput.toJson(list)
println JsonOutput.prettyPrint(json)
/**
* 将json串转换为实体对象
*/
def jsonSlpuer=new JsonSlurper()
def parse = jsonSlpuer.parseText(json)
println parse.toString()
println "--------------------------------groovy中进行网络请求---------------------------------------------"
def getNetworkData(String url){
//发送http请求
def connection=new URL(url).openConnection()
connection.setRequestMethod('GET')
connection.connect()
def request = connection.content.text
//将json转换为实体对象
def jsonSlpuer=new JsonSlurper()
return jsonSlpuer.parseText(request)
}
def reponse = getNetworkData("http://******/wsd/dictionary/getMapByDicflag?dicFlag=wsd.grade.type")
println reponse.data
- xml操作
import groovy.xml.MarkupBuilder
final String xml='''
<search>
<entry id="1">
<title>about</title>
<link href="/website/about/index.html"/>
<url>/website/about/index.html</url>
<content type="html1"><![CDATA[<p><img src="http://pcv76qg6d.bkt.clouddn.com/big_04.jpg"></p>]]></content>
</entry>
<entry id="2">
<title>分类</title>
<link href="/website/categories/index.html"/>
<url>/website/categories/index.html</url>
<content type="html2"><![CDATA[]]></content>
</entry>
<entry id="3">
<url>/website/tags/index.html</url>
<title>标签</title>
<link href="/website/tags/index.html"/>
<content type="html3"><![CDATA[]]></content>
</entry>
<entry id="4">
<url>/website/tags2/index.html</url>
<title>标签</title>
<link href="/website/tags/index.html"/>
<content type="html4"><![CDATA[]]></content>
</entry>
</search>
'''
println "------------------------------------------------解析xml-----------------------------------------"
/**
* 开始解析xml数据
*/
def xmlSlurper = new XmlSlurper()
def search = xmlSlurper.parseText(xml)
println search.entry[0].url.text();//打印内容，/website/about/index.html
println search.entry[0].content.@type;//打印属性，html
/**
* 遍历
*/
def list=[]
search.entry.each{ entry->
def title=entry.title.text();
if (title.equals("标签")){
list.add(entry.url.text())
}
}
println list.toListString() //[/website/tags/index.html, /website/tags2/index.html]
/**
* 深度遍历xml数据（即使xml多层也可以找到）
*/
def titles= search.depthFirst().findAll {entry->
return entry.title.text()=='标签'?true:false
}
println titles.toListString() //[/website/tags/index.html标签, /website/tags2/index.html标签]
/**
* 广度遍历xml数据
*/
def urls= search.children().findAll {node->
node.title=='标签'&&node.@id=='3'
}.collect{node->
return node.url.text()
}
println urls //[/website/tags/index.html]
println "------------------------------------------------生成xml-----------------------------------------"
/**
*
<langs type='curent' count='3' mainstream='true'>
<language flavor='static' version='1.5'>
<age>16</age>
</language>
<language flavor='dynamic' version='1.6'>
<age>10</age>
</language>
<language flavor='dynamic' version='1.7'>Python</language>
</langs>
*/
def writer = new StringWriter()
def xmlBuilder = new MarkupBuilder(writer)//用来生成xml数据的核心类
//根节点langs创建
xmlBuilder.langs(type:'curent',count:'3',mainstream:'true'){
//创建language结点
language(flavor:'static',version:'1.5',){
age(16)
}
language(flavor:'dynamic',version:'1.6',){
age(10)
}
language(flavor:'dynamic',version:'1.7','Python')
}
println writer
/**
* 动态生成
*/
def writer1 = new StringWriter()
def xmlBuilder1 = new MarkupBuilder(writer1)//用来生成xml数据的核心类
def langs = new Langs();
xmlBuilder1.langs(type:langs.type,count: langs.count,mainstream: langs.mainstream ){
langs.langages.each{lang->
language(flavor:lang.flavor, version:lang.version, value:lang.value)
}
}
class Langs{
String type='curent'
int count=3
boolean mainstream=true
def langages=[
new Language(flavor:'static',version:'1.5',value:"java"),
new Language(flavor:'dynamic',version:'1.6',value: "H5"),
new Language(flavor:'dynamic',version:'1.7',value: "java")
]
}
class Language{
String flavor
String version
String value
}
println writer1
- file操作
/**
* 文件操作
*/
def file = new File('../../groovy.iml')
file.eachLine { line ->
println line
}
println "-----------------------------------------------------------------------------------------"
def text = file.getText()
println text
println "-----------------------------------------------------------------------------------------"
def lines = file.readLines()
println lines
println "-----------------------------------------------------------------------------------------"
/**
* 读取文件部分内容
*/
def reader = file.withReader { reader ->
char[] buffer = new char[100]
reader.read(buffer)
return buffer
}
println reader
println "-----------------------------------------------------------------------------------------"
/**
* 边读边写
* @param sourcePath
* @param desPath
* @return
*/
def copy(String sourcePath, String desPath) {
try {
//创建目标文件
def desFile = new File(desPath)
if (!desFile.exists()) {
desFile.createNewFile()
}
//copy
new File(sourcePath).withReader { reade ->
def lines = reade.readLines()
desFile.withWriter { writer ->
lines.each { line ->
writer.append(line + "\r\n")
}
}
}
return true
} catch (Exception e) {
e.printStackTrace()
}
return false
}
def result = copy("../../groovy.iml", "../../groovy2.iml")
println result
println "-----------------------------------------------------------------------------------------"
/**
* 对象的读写
*/
def person = new Person(name: "huangxiaoguo",age: 18)
def saveObject(Object obj, String path) {
try {
//创建文件
def desFile = new File(path)
if (!desFile.exists()) {
desFile.createNewFile()
}
desFile.withObjectOutputStream { out ->
out.writeObject(obj)
}
return true
} catch (Exception e) {
e.printStackTrace()
}
return false
}
def readObject(String path) {
def obj = null
try {
//创建文件
def file = new File(path)
if (file == null || !file.exists()) {
return
}
//从文件中读取对象
file.withObjectInputStream { input ->
obj = input.readObject()
}
} catch (Exception e) {
e.printStackTrace()
}
return obj
}
println saveObject(person,"../../person.txt")
def personr = (Person)readObject("../../person.txt")
println "name:${personr.name},age:${personr.age}"
