Groovy<第六篇>：基础语法(5)---集合

Groovy常见的集合由四种，分别是List、Set、Map、Queue，本章节只介绍常用的两种集合List和Map

（1）List集合

假设定义一个这样的数组

    def numList = [9,1,2,7,3,4,8,5,6]

[打印整个数组]

    println numList                     //打印整个数组

输出结果为：

[9, 1, 2, 7, 3, 4, 8, 5, 6]

[数组的对象类型]

    println numList.getClass().name     //打印数组类型

输出结果为：

java.util.ArrayList

[数组的长度]

    println numList.size()              //打印数组的长度

输出结果为：

9

[根据数组的索引快速访问元素]

数组的角标是从0开始的，如图：

图片.png

所以，可以将数组下标当成索引来访问元素

    println numList[0]                  //打印第一个元素
    println numList[1]                  //打印第二个元素

有关数组的下标，Groovy是支持负数下标的，如下图：

图片.png

负数下标是从-1开始的，-1表示倒数第一个元素，-2表示倒数第二个元素，以此类推。

    println numList[-1]                  //打印倒数第一个元素
    println numList[-2]                  //打印倒数第二个元素

Groovy还支持一次性指定多个下标，下标之间用逗号隔开

    println numList[-3, -1]              //打印倒数第三个元素和倒数第一个元素
    println numList[2, 4]                //打印第三个元素和第五个元素

还可以用..指定一个下标范围，如下：

    println numList[2..4]                //打印第三个元素到第五个元素  

[遍历数组]

Groovy使用each来遍历数组，代码如下：

    numList.each {
        println it
    }

it变量是正在遍历的元素。

这里有闭包的概念，会在后面的章节讲解，此章节不会解释。

[添加元素]

    def numList = [9,1,2,7,3,4,8,5,6]

    numList.add(10)

    println numList

add方法默认在数组结尾添加一个元素。

当然也可以在指定位置插入一个元素

   numList.add(1, 10)

[检查数组中是否含有指定元素]

    def numList = [9,1,2,7,3,4,8,5,6]

    println numList.contains(19)

打印结果为false，因为数组中根本就没有19这个元素。

[获取指定位置元素]

    def numList = [9,1,2,7,3,4,8,5,6]

    println numList.get(1)

get方法传递的数字是数组的下标，从0开始的下标，不能是负数。

[判断数组是否为空]

    def numList = [9,1,2,7,3,4,8,5,6]

    println numList.isEmpty()

[根据原数组生成一个新的数组]

    def numList = [9,1,2,7,3,4,8,5,6]
    def deleteList = [1,3,5]
    def newNumList = numList.minus(deleteList)
    println newNumList

打印结果如下：

[9, 2, 7, 4, 8, 6]

minus方法可以删除数组的一些元素，并生成另一个数组，minus传递的参数是将要删除的数组，如果不想删除任何元素，那么可以传空数组

    def deleteList = []

我们可以添加一些元素并生成一个新的数组，plus方法可以实现，代码如下：

    def numList = [9,1,2,7,3,4,8,5,6]
    def addList = [10,11,12]
    def newNumList = numList.plus(addList)
    println newNumList

打印结果如下：

[9, 1, 2, 7, 3, 4, 8, 5, 6, 10, 11, 12]

plus还可以在指定位置插入元素，如下代码

    def newNumList = numList.plus(1, addList)

[出栈]

数组有一个pop这个方法，意思是弹出第一个数据，代码如下：

    def numList = [9,1,2,7,3,4,8,5,6]
    println numList.pop()

打印结果是：9

[删除指定元素]

remove方法可以删除数组中的指定元素。

可以根据索引删除：（索引不能为负数）

    def numList = [9,1,2,7,3,4,8,5,6]
    numList.remove(3)
    println numList

也可以删除一组数据：

    def numList = [9,1,2,7,3,4,8,5,6]
    numList.removeAll([1,2,3])
    println numList

打印结果如下：

[9, 7, 4, 8, 5, 6]

[数组元素的反转]

reverse可以将数组的元素反转。

    def numList = [9,1,2,7,3,4,8,5,6]
    println numList.reverse()

打印结构如下：

[6, 5, 8, 4, 3, 7, 2, 1, 9]

[排序]

    def numList = [9,1,2,7,3,4,8,5,6]
    println numList.sort()

打印结果:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

sort()方法默认将数组正序排序。

如果想要降序排序也比较简单，代码如下：

    def numList = [9,1,2,7,3,4,8,5,6]
    println numList.sort().reverse()

反转一下即可。

当然，还有一种办法，就是使用比对器：Comparator

如果不指定Comparator，那么底层默认使用这个比对器NumberAwareComparator，源码如下：

public class NumberAwareComparator<T> implements Comparator<T>, Serializable {
    private static final long serialVersionUID = 9017657289076651660L;

    public NumberAwareComparator() {
    }

    public int compare(T o1, T o2) {
        try {
            return DefaultTypeTransformation.compareTo(o1, o2);
        } catch (IllegalArgumentException | GroovyRuntimeException | ClassCastException var5) {
            int x1 = o1.hashCode();
            int x2 = o2.hashCode();
            if (x1 == x2 && o1.equals(o2)) {
                return 0;
            } else {
                return x1 > x2 ? 1 : -1;
            }
        }
    }
}

我们将这段代码拿出来，并将

                return x1 > x2 ? 1 : -1;

改成

                return x1 > x2 ? -1 : 1;

那么，使用比较器的代码如下：

    def numList = [9,1,2,7,3,4,8,5,6]
    numList.sort(new NumberAwareNewComparator())
    println numList

输出结果依然是倒叙的

[9, 8, 7, 6, 5, 4, 3, 2, 1]

（2）Map集合

Map的用法和List比较类似，只不过它的值时一个键值对（K：V）的形式。

定义一个Map集合

    def map = ["name":"张三", "age":43]

[打印map集合]

    println map

打印结果如下：

[name:张三, age:43]

[获取map集合的对象类型]

    println map.getClass().name

打印结果如下：

java.util.LinkedHashMap

我们发现，其对象其实就是LinkedHashMap对象。

[map集合的长度]

    println map.size()

打印结果如下：

2

[根据键（key）快速访问元素]

    println map["name"]                  //打印key=name对应的元素
    println map["age"]                  //打印key=age对应的元素

打印结果如下：

张三
43

[如何判断map集合中是否含有此键（key）]

    println map.containsKey("name")

打印结果如下：

true

[直接获取对应键（key）对应的值]

    println map.get("name")

打印结果如下：

张三

如果在map集合中找不到指定的键，那么打印结果就是：null

[获取一组键]

    println map.keySet()

打印结果如下：

[name, age]

[获取一组值]

    println map.values()

打印结果如下：

[张三, 43]

[在map集合中添加元素]

    def map = ["name":"张三", "age":43]
    map.put("birthday", "2019/5/9")
    println map

打印结果如下：

[name:张三, age:43, birthday:2019/5/9]

但是，map集合中的key是不能重复的，如果使用这个方法添加一个已有key的键值对会怎样呢？

代码如下：

    def map = ["name":"张三", "age":43]
    map.put("name", "李四")
    println map

打印结果如下：

[name:李四, age:43]

从打印结果上看，map集合中并没有添加一个新的键值对，而是覆盖了name键对应的值。

[遍历map集合]

Groovy语言中，遍历List使用each()方法，而遍历map集合也是使用each()，代码如下：

    def map = ["name":"张三", "age":43]
    map.each {
        println it.key+":"+it.value
    }

打印结果如下：

name:张三
age:43

it是正在遍历的元素，Map集合的元素是Map.Entry，Map.Entry中存放了键值对。

[本章完...]