Groovy学习-list操作

阳光穿透心脏的1/2处 2022-10-25 04:45 205阅读 0赞

###  常用操作 ###

assert [1, 2, 3].find { it > 1 } == 2           // 找出第一个符合条件的元素
    assert [1, 2, 3].findAll { it > 1 } == [2, 3]   //找出所有符合条件的元素
    assert ['a', 'b', 'c', 'd', 'e'].findIndexOf {      // 找出符合条件的第一个元素的index
        it in ['c', 'e', 'g']
    } == 2
    
    assert ['a', 'b', 'c', 'd', 'c'].indexOf('c') == 2  // 返回index
    assert ['a', 'b', 'c', 'd', 'c'].indexOf('z') == -1 // index返回-1意味着没有找到结果
    assert ['a', 'b', 'c', 'd', 'c'].lastIndexOf('c') == 4 // 返回相同元素的最后一个位置
    
    assert [1, 2, 3].every { it < 5 }               // 如果每一个元素都符合条件则返回true
    assert ![1, 2, 3].every { it < 3 }
    assert [1, 2, 3].any { it > 2 }                 // 如果有一个元素符合条件就返回true
    assert ![1, 2, 3].any { it > 3 }
    
    assert [1, 2, 3, 4, 5, 6].sum() == 21                // 所有元素求和
    assert ['a', 'b', 'c', 'd', 'e'].sum {
        it == 'a' ? 1 : it == 'b' ? 2 : it == 'c' ? 3 : it == 'd' ? 4 : it == 'e' ? 5 : 0
        // 求和的时候可以自定义元素的值
    } == 15
    assert ['a', 'b', 'c', 'd', 'e'].sum { ((char) it) - ((char) 'a') } == 10
    assert ['a', 'b', 'c', 'd', 'e'].sum() == 'abcde'
    assert [['a', 'b'], ['c', 'd']].sum() == ['a', 'b', 'c', 'd']
    
    // 可以提供初始值
    assert [].sum(1000) == 1000
    assert [1, 2, 3].sum(1000) == 1006
    
    assert [1, 2, 3].join('-') == '1-2-3'           // 每个元素之间添加字符串
    assert [1, 2, 3].inject('counting: ') { str, item ->
        str + item                     // 减少操作
    } == 'counting: 123'
    assert [1, 2, 3].inject(0) { count, item ->
        count + item
    } == 6

### 最大值和最小值操作  ###

// 查找最大和最下值
    def list = [9, 4, 2, 10, 5]
    assert list.max() == 10
    assert list.min() == 2
    
    // 单字符的list也可以查找最大值和最小值
    assert ['x', 'y', 'a', 'z'].min() == 'a'
    
    // 我们可以用Closure闭包来描述元素的大小
    def list2 = ['abc', 'z', 'xyzuvw', 'Hello', '321']
    assert list2.max { it.size() } == 'xyzuvw'
    assert list2.min { it.size() } == 'z'

### `Comparator`定义比较条件 ###

Comparator mc = { a, b -> a == b ? 0 : (a < b ? -1 : 1) }
    
    def list = [7, 4, 9, -6, -1, 11, 2, 3, -9, 5, -13]
    assert list.max(mc) == 11
    assert list.min(mc) == -13
    
    Comparator mc2 = { a, b -> a == b ? 0 : (Math.abs(a) < Math.abs(b)) ? -1 : 1 }
    
    assert list.max(mc2) == -13
    assert list.min(mc2) == -1
    
    assert list.max { a, b -> a.equals(b) ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } == -13
    assert list.min { a, b -> a.equals(b) ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } == -1

### 添加元素 ###

def list = []
    assert list.empty
    
    list << 5
    assert list.size() == 1
    
    list << 7 << 'i' << 11
    assert list == [5, 7, 'i', 11]
    
    list << ['m', 'o']
    assert list == [5, 7, 'i', 11, ['m', 'o']]
    
    // 在<<表达式最前端的list是目标list
    assert ([1, 2] << 3 << [4, 5] << 6) == [1, 2, 3, [4, 5], 6]
    
    // 使用leftShift方法等价于使用 <<
    assert ([1, 2, 3] << 4) == ([1, 2, 3].leftShift(4))
    
    assert [1, 2] + 3 + [4, 5] + 6 == [1, 2, 3, 4, 5, 6]
    // 等价于调用plus方法
    assert [1, 2].plus(3).plus([4, 5]).plus(6) == [1, 2, 3, 4, 5, 6]
    
    def a = [1, 2, 3]
    a += 4      //创建了一个新的List
    a += [5, 6]
    assert a == [1, 2, 3, 4, 5, 6]
    
    assert [1, *[222, 333], 456] == [1, 222, 333, 456]
    assert [*[1, 2, 3]] == [1, 2, 3]
    assert [1, [2, 3, [4, 5], 6], 7, [8, 9]].flatten() == [1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    def list = [1, 2]
    list.add(3)
    list.addAll([5, 4])
    assert list == [1, 2, 3, 5, 4]
    
    list = [1, 2]
    list.add(1, 3) //在索引1前面插入元素3
    assert list == [1, 3, 2]
    
    list.addAll(2, [5, 4]) //在索引2前面插入元素[5,4]
    assert list == [1, 3, 5, 4, 2]
    
    list = ['a', 'b', 'z', 'e', 'u', 'v', 'g']
    list[8] = 'x' // []运算符根据需要使列表增长
    // 如果需要插入null
    assert list == ['a', 'b', 'z', 'e', 'u', 'v', 'g', null, 'x']

### 删除元素 ###

assert ['a','b','c','b','b'] - 'c' == ['a','b','b','b']
    assert ['a','b','c','b','b'] - 'b' == ['a','c']
    assert ['a','b','c','b','b'] - ['b','c'] == ['a']
    
    def list = [1,2,3,4,3,2,1]
    list -= 3           //从原始list创建一个新的list，并删除元素3
    assert list == [1,2,4,2,1]
    assert ( list -= [2,4] ) == [1,1]
    
    def list = [1,2,3,4,5,6,2,2,1]
    assert list.remove(2) == 3          //删除第三个元素并返回第三个元素的值
    assert list == [1,2,4,5,6,2,2,1]
    
    def list = [1,2,3,4,5,6,2,2,1]
    assert list.remove(2) == 3          //删除第三个元素并返回第三个元素的值
    assert list == [1,2,4,5,6,2,2,1]
    
    def list= ['a','b','c','b','b']
    assert list.remove('c')             // 删除元素'c'如果删除成功返回true
    assert list.remove('b')             // 删除第一个找到的元素'b'，如果删除成功返回true
    assert ! list.remove('z')           // 返回false，因为没有任何元素删除
    assert list == ['a','b','b']
    
    def list= ['a',2,'c',4]
    list.clear()
    assert list == []

### 设置操作 ###

assert 'a' in ['a','b','c']             // 如果元素'a'在list中返回true
    assert ['a','b','c'].contains('a')      // 等价于java中的`contains`方法
    assert [1,3,4].containsAll([1,4])       // `containsAll` 将检测每一个待查元素，如果都包含在list中，返回true
    
    assert [1,2,3,3,3,3,4,5].count(3) == 4  // 返回元素3在列表中包含的数量
    assert [1,2,3,3,3,3,4,5].count {
        it%2==0                             // 返回符合断言的元素在列表中包含的数量
    } == 2
    
    assert [1,2,4,6,8,10,12].intersect([1,3,6,9,12]) == [1,6,12]    // 返回两个列表的交集
    
    assert [1,2,3].disjoint( [4,6,9] )   // 两个列表是互斥的，返回true
    assert ![1,2,3].disjoint( [2,4,6] )

### 排序 ###

assert [6, 3, 9, 2, 7, 1, 5].sort() == [1, 2, 3, 5, 6, 7, 9]
    
    def list = ['abc', 'z', 'xyzuvw', 'Hello', '321']
    assert list.sort {
        it.size()
    } == ['z', 'abc', '321', 'Hello', 'xyzuvw']
    
    def list2 = [7, 4, -6, -1, 11, 2, 3, -9, 5, -13]
    assert list2.sort { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } ==
            [-1, 2, 3, 4, 5, -6, 7, -9, 11, -13]
    
    Comparator mc = { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 }
    
    // 仅限于JDK 8+
    // list2.sort(mc)
    // assert list2 == [-1, 2, 3, 4, 5, -6, 7, -9, 11, -13]
    
    def list3 = [6, -3, 9, 2, -7, 1, 5]
    
    Collections.sort(list3)
    assert list3 == [-7, -3, 1, 2, 5, 6, 9]
    
    Collections.sort(list3, mc)
    assert list3 == [1, 2, -3, 5, 6, -7, 9]

### 复制元素 ###

assert [1, 2, 3] * 3 == [1, 2, 3, 1, 2, 3, 1, 2, 3]
    assert [1, 2, 3].multiply(2) == [1, 2, 3, 1, 2, 3]
    assert Collections.nCopies(3, 'b') == ['b', 'b', 'b']
    
    // 来自JDK的nCopies具有与列表的乘法不同的语义
    assert Collections.nCopies(2, [1, 2]) == [[1, 2], [1, 2]] //而不是[1,2,1,2]