1       Maps

maps中的元素是key-value对儿，key与value之间使用冒号（:）分割。创建一个空value的map，使用[:]。默认情况下，map的类型是java.util.HashMap。如果这些keys是String类型的，那么你可以不使用单引号或双引号括起来。

但是，如果使用变量作为key，需要将key用（）括起来。

重新赋值map中的指定value，使用map[key]=value。

访问该map中的value，使用map[key]；还可以使用get(key) or get(key,default)。在get(key,default)中，如果key不存在，返回的是default，同时，该(key,default)会增加到该map中。

package map

/**

* 声明和访问map

* @author zuoys

*

*/

class DeclareAndAccess {

static main(args) {

//创建一个有值的map

def map = ["Jim":"Knopf","Thomas":"Edison"];

//点（.）操作符被重载来访问该value

map.AnotherKey = "Testing";

//创建没加引号的keys

def anotherMap = [Jim:"Knopf",Thomas:"Edison"];

//.size()：map中元素的数量

assert anotherMap.size()==2;

//key可以使用变量，但必须使用括号括起来，否则默认是"x"，因为key可以不使用引号。

def x = "a";

//以下返回false，因为x可以不使用引号，因此认为是"x"

println ([a:1]==[x:1]);

//以下返回true

println ([a:1]==[(x):1]);

//创建一个空的map

def emptyMap = [:]

println("===============set/get");

println (map.get("Jim"))

//重新设置value

map["Jim"]="左运松";

//获取map中指定value

println (map["Jim"]);

println (map.get("Jim"));

println (map.get("zuoys", "遥远2"));//map中没有zuoys，返回 遥远2，并新增zuoys:遥远2

println (map.get("zuoys"))//再次获取zuoys，获取到的是 遥远2

println("===============keySet()");

Set sets = map.keySet();

if (!sets.isEmpty()) {

Iterator iterator = sets.iterator();

while (iterator.hasNext()) {

String i = iterator.next();

println(i);

}

}

}

}

输出

keySet()方法返回所有的keys，不重复的元素且没有顺序的。

操作元素，可以使用闭包，基于each(), any() and every()方法。

each()返回T，遍历每个元素；any()和every()返回符合闭包中条件的Boolean。

package map

import java.beans.WeakIdentityMap.Entry;

class EachAnyEveryMethod {

static main(args) {

def mymap = [1:"左1",2:"左2",3:"左23"];

println("=======each,遍历每个元素，并验证每个key是否大于1")

mymap.each { entry -> println(entry.key > 1)};

println("=======each,遍历每个元素，并验证每个value是否包含 2")

mymap.each { entry -> println(entry.value.contains("2"))};

println "=======any,任何一个:"

//验证 map中任何一个value，哪怕有一个value包含【左】都返回true，否则返回false

println mymap.any {entry -> entry.value.contains("左")};

println "=======every,每一个";

/**

* 验证 map中每一个的key的大小都要小于3，才返回true，否则哪怕有一个不小于3都返回false

* 如果小于4，则输出true

*/

println mymap.every{ entry -> entry.key < 3};

println("=============使用keySet()遍历map");

def result = '';

for (key in mymap.keySet()) {

result += key;

}

println (result);

println("=============使用each{}遍历map");

mymap.each { key, value ->

print key + " ";

println value;

};

println("=============使用each{}遍历map");

mymap.each { entry ->

print entry.key +" ";

println entry.value;

};

}

}

输出

each{}，中的参数：

可以是entry（完整的一条元素【含key，value】，entry可以起任意名字，因为只是参数而已）。

也可以是key，value（可以起任意名字，因为只是参数而已）。

能够使用下边的方法搜索map：

• findAll(closure) – 找到符合闭包条件的所有元素
• find(closure) – 找到符合闭包条件的第一条元素。
• collect(closure) – 返回符合闭包条件的所有元素，其类型是list。
• submap('key1', 'key2',) – 返回含有key1,key2元素的map.

在方法调用时，可能会用到命名参数。

package map.namedarguments

class Address {

String street, city;

}

package map.namedarguments

class Person {

String name;

Address address;

String phoneNumber;

def moveToNewPlace(inputAsMap,newPhoneNumber) {

address.street = inputAsMap.street;

address.city = inputAsMap.city;

phoneNumber = newPhoneNumber;

}

}

package map.namedarguments

class NamedArguments {

static main(args) {

def address = new Address(street:"开发区大街",city:"燕郊");

def p = new Person(name:"zuo",address:address,phoneNumber:"18600000000");

assert "zuo" == p.name;

assert "18600000000" == p.phoneNumber;

assert "开发区大街" == p.address.street;

assert "燕郊" == p.address.city;

/**

* 下边会自动转换为

* [street:"北三环中路",city:"北京"],"15699999999"。其实用此种方式是最好的。

*/

p.moveToNewPlace(street:"北三环中路", "15699999999",city:"北京");

assert "zuo" == p.name;

assert "15699999999" == p.phoneNumber;

assert "北三环中路" == p.address.street;

assert "北京" == p.address.city;

}

}

所有的命名参数都会被groovy转换为一个map，并且传递到被调用的方法的第一个参数中。剩下的所有参数会被传递到其后的参数中。传递进去后，该方法从map中提取相应的参数。

使用collectEntries 方法将list转换为map。

package map

class List2Map {

static main(args) {

def words = ['a','b','ac','d'];

//简单的转换,必须使用it

def result = words.collectEntries {

[(it):0]

}

assert result.size() == 4;

assert result.a == 0;

//下边使用闭包检索包含'a'的元素

def map = words.collectEntries() {

[(it):it.contains('a')];

}

println map;

assert map.a && map.ac && !map.b && !map.d

}

}

输出

[a:true, b:false, ac:true, d:false]

contains方法，返回的value是Boolean。