grails学习笔记——Groovy与java的比较
来源:互联网 发布:helloworld代码 python 编辑:程序博客网 时间:2024/05/17 13:10
grails学习笔记——Groovy与java的比较
1.支持函数式编程,不需要main函数
2.默认导入常用的包,包括:
3.断言不支持jvm的-ea参数进行开关
4.支持对对象进行布尔求值
6.受检查类型异常(Checked Exception)也可以不用捕获
7.一些新的运算符
. . .
}if (obj != null && obj.value != null) {
. . .
}?:
String name = person.getName() ?: "<unknown>"String name = (person.getName() != null) ? person.getName() : "<unknown>"*.
List names = people*.nameList names = new ArrayList();
for(Iterator it = people.iterator();it.hasNext();){
People people = (People)it.next();
names.add(people.getName());
}
<=>public int compare(int i1, int i2) {
return i1 <=> i2;
}public int compare(int i1, int i2) {
if (i1 == i2) return 0;
else if (i1 < i2) return -1;
else return 1;
}==String str = null
assert str == null
assert str != "test"
str = "test"
assert str != null
assert str == "test"
str += " string"
assert str == "test string"相当与equals方法,如果左侧的对象实现了compareTo方法,则调用compareTo方法且返回0时,返回true.而对象的比较则要调用is方法,如:
BigDecimal x = 0.234
BigDecimal y = x
assert y.is(x)
assert !y.is(0.234)
assert y == 0.234
assert 0.1 * 3 == 0.3
assert 1.1 + 0.1 == 1.2
assert 1 / 0.25 == 4
String greeting = "Good morning, ${name}"
assert greeting == 'Good morning, Ben'
String output = "The result of 2 + 2 is: ${2 + 2}"
assert output == "The result of 2 + 2 is: 4"
return """Dear ${name},
Thank you for your recent inquiry. One of our team members
will process it shortly and get back to you. Some time in
the next decade. Probably.
Warmest and best regards,
Customer Services
"""
assert ch instanceof Character
String str = "Good morning Ben"
str = str.replace(' ' as char, '+' as char)
assert str == "Good+morning+Ben"
assert 1234.compareTo("34749397" as int) < 0
目标类型
说明
StringNumber (int, double, Long,BigDecimal, and so on)转换成相应的数字类型,如果字符串不是数字,则抛出NumberFormatException
ListArray将List转换成Array,如myList as String[]List 或 arraySet将List或array直接转换为setb
任意对象
boolean使用groovy的布尔运算逻辑进行求值
CollectionList复制原始collection中的对象创建一个List,对象在List中的顺序由原collection的迭代顺序决定
StringList将字符串转换为每个字符的序列,并放到List中
Map myMap = [ 3: "three", 6: "six", 2: "two" ]
assert 3 == [ 5, 6, 7 ].size()
assert numbers[0] == 5 //获取List中的对象
assert numbers[3] == 20
assert numbers[-1] == 25 //逆序获取List对象
assert numbers[-3] == 15
numbers[2] = 3 //更新List对象
assert numbers[2] == 3
numbers << 30 //添加数据
assert numbers[5] == 30
Map items = [ "one": "apple",
"two": "orange",
"three": "pear",
"four": "cherry" ]
assert items["two"] == "orange" //从Map中获得对象
assert items["four"] == "cherry"
items["one"] = "banana" //更新Map中对象
assert items["one"] == "banana"
items["five"] = "grape" //增加对象到中
assert items["five"] == "grape"
assert range.size() == 4
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
assert range.contains(8)
// lets use an exclusive range
range = 5..<8
assert range.size() == 3
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
assert ! range.contains(8)
//get the end points of the range without using indexes
def range = 1..10
assert range.from == 1
assert range.to == 10
List fruit = [
"pear",
"lemon",
"orange",
"cherry" ]
for (int i in 0..<fruit.size()) { //Iterates through an exclusive range B
println "Fruit number $i is '${fruit[i]}'"
}
List subList = fruit[1..3] //Extracts a list slice C
+ "banana, cherry, nectarine"
println()
println([1, 2, 3, 4])
assert ~//w+/ instanceof java.util.regex.Pattern
assert !("Speaking plain English" ==~ /plain/)
assert "Speaking plain English" ==~ /.*plain.*/
String str = "The rain in Spain falls mainly on the plain"
Matcher m = str =~ //b(/w*)ain(/w*)/b/
if (m) {
for (int i in 0..<m.count) {
println "Found: '${m[i][0]}' - " +
"prefix: '${m[i][1]}'" +
", suffix: '${m[i][2]}'"
}
}
输出:
Found: 'rain' - prefix: 'r', suffix: ''
Found: 'Spain' - prefix: 'Sp', suffix: ''
Found: 'mainly' - prefix: 'm', suffix: 'ly'
Found: 'plain' - prefix: 'pl', suffix: ''
println "Current time in milliseconds: ${ now.time }"
now.time = 103467843L
assert now.time == 103467843L
static String classVar
final String constant = "constant"
String name
public String publicField
private String privateField
}
lenient: false,
numberFormat: NumberFormat.getIntegerInstance(),
timeZone: TimeZone.getTimeZone("EST"))
assert values.fred == 1
values.peter = 10
assert values.peter == 10
注:groovy将map的key作为字符串处理,除非是数字或者用圆括号包含。这里的fred就是字符串"fred",但引号不是必须的,只有在key包含空格、句点或其他不能作为Groovy标示符的字符存在时才需要。如果需要使用一个变量的值作为key,则使用圆括号,如 [ (fred): 1 ]。
16.groovy的重要特性——闭包:
for (int i = 0, j = 0; i < 10; i++, j++) { ... }
17.groovy的重要特性——动态编程
List fruit = [ "apple", "Orange", "Avocado", "pear", "cherry" ]
fruit.sort { String a, String b -> a.compareToIgnoreCase(b) }
println "Sorted fruit: ${fruit}"
注:sort方法只有一个闭包类型的参数,省略了圆括号;闭包中使用了默认的return值
[ "apple", "pear", "cherry" ].each { println it }
Closure comparator = { String a, String b ->
a.compareToIgnoreCase(b)
}
List fruit = [ "apple", "Orange", "Avocado", "pear", "cherry" ]
fruit.sort(comparator)
println "Sorted fruit: ${fruit}"
assert comparator("banana", "Lemon") < 0
List list = [ 1, 3, 5, 6 ]
list.inject(0, { runningTotal, value -> runningTotal + value })
可以这样写:
assert 15 == list.inject(0) { runningTotal, value -> runningTotal + value }
便于闭包中具有多行时代码更加清晰
18.Groovy JDK中的增强
public void sortPeopleByGivenName(List<Person> personList) {
Collections.sort(personList, new Comparator<Person>() {
public int compare(Person p1, Person p2) {
return p1.getFamilyName().compareTo(p2.getFamilyName());
}
} ) ;
}
可使用下面的代替,当需要使用其他字段比较时,不需要修改代码
def sortPeople(people, property) {
people.sort { p1, p2 -> p1."${property}" <=> p2."${property}" }
}
peopleList.sort()
peopleList."sort"()
19.XML的处理
def glen = personList.find { it.firstName == "Glen" }
def names = [ "Glen", "Peter", "Alice", "Graham", "Fiona" ]
assert [ 4, 5, 5, 6, 5 ] == names.collect { it.size() }
一个参数的闭包,如:
def names = [ "Glen", "Peter", "Ann", "Graham", "Veronica" ]
def sortedNames = names.sort { it.size() }
assert [ "Ann", "Glen", "Peter", "Graham", "Veronica" ] == sortedNames
两个参数的闭包,如:
def names = [ "Glen", "Peter", "Ann", "Graham", "Veronica" ]
def sortedNames = names.sort { name1, name2 ->
name1.size() <=> name2.size()
}
assert [ "Ann", "Glen", "Peter", "Graham", "Veronica" ] == sortedNames
def names = [ "Glen", "Peter", "Alice", "Fiona" ]
assert "Glen, Peter, Alice, Fiona" == names.join(", ")
20.最佳实践
<root>
<item qty="10">
<name>Orange</name>
<type>Fruit</type>
</item>
<item qty="6">
<name>Apple</name>
<type>Fruit</type>
</item>
<item qty="2">
<name>Chair</name>
<type>Furniture</type>
</item>
</root>
import groovy.util.XmlSlurper
def file = new File("test.xml")
def objs = [
[ quantity: 10, name: "Orange", type: "Fruit" ],
[ quantity: 6, name: "Apple", type: "Fruit" ],
[ quantity: 2, name: "Chair", type: "Furniture" ] ]
def b = new MarkupBuilder(new FileWriter(file))创建MarkupBuilder对象b.root {
动态调用root方法,但builder对象并没有该方法,把它作为一个新的XML对象的根节点,并且把方法名作为根节点名称
objs.each { o ->
item(qty: o.quantity) {
name(o.name)
type(o.type)
}
}
}
遍历集合,创建节点,其中item/name/type也是动态的方法,以方法名作为节点名,方法参数作为节点的属性
def xml = new XmlSlurper().parse(file)
使用XmlSlurper对象解析内存中的XML文件assert xml.item.size() == 3
assert xml.item[0].name == "Orange"
assert xml.item[0].@qty == "10"
使用动态的属性名读取XML节点
使用@字符读取节点属性
println "Fruits: ${xml.item.findAll {it.type == 'Fruit'}*.name }"
println "Total: ${xml.item.@qty.list().sum {it.toInteger()} }"
- grails学习笔记——Groovy与java的比较
- Groovy轻松入门——通过与Java的比较,迅速掌握Groovy(1)
- Groovy轻松入门——通过与Java的比较,迅速掌握Groovy(2)
- Groovy轻松入门——通过与Java的比较,迅速掌握Groovy(3)
- Groovy/Grails的发展与回顾
- groovy与java比较,展现groovy的魅力
- Groovy轻松入门——通过与Java的比较,迅速掌握Groovy (更新于2008.10.18)
- Groovy轻松入门——通过与Java的比较,迅速掌握Groovy (更新于2008.10.18)
- Groovy& Grails学习纪录
- Groovy轻松入门——通过与Java的比较,迅速掌握
- grails,java,groovy定时执行
- 通过与Java的比较,迅速掌握Groovy
- 通过与Java的比较,迅速掌握Groovy
- Groovy轻松入门——Grails实战基础篇(1)
- Groovy轻松入门——Grails实战基础篇(2)
- Groovy轻松入门——Grails实战基础篇(3)
- Groovy轻松入门——Grails实战基础篇(4)
- Groovy轻松入门——Grails实战之GORM篇
- 深入理解iPhone静态库
- shell参数
- uCOS-II是如何避免调整堆栈指针的?
- 浪费时间
- Use volatile judiciously
- grails学习笔记——Groovy与java的比较
- SOCKET
- Linux操作系统定时任务系统 Cron
- 详解:数据库名、实例名、ORACLE_SID、数据库域名、全局数据库名、服务名
- 库操作工具以及命令
- 关于手机应用到Samsung Galaxy Tab屏幕的适应问题解决
- HTML5设计原理-----------Jeremy Keith在 Fronteers 2010 上的主题演讲
- 根据图幅号(新图幅号)计算左下角点坐标的方法及代码(C#)
- Place volatile accurately