第四章 Groovy集合数据类型

1、range(范围)

1.1、具体的范围

  • left … right (下界,上界)

  • 示例

    • /**
       * 数字范围和日期范围
       * @author liangchen* @date 2020/10/24
       */
      class RangeDemo {
      
          static void main(String[] args) {
              // 包含
              assert (0..10).contains(0)
              assert (0..10).contains(5)
              assert (0..10).contains(10)
      
              // 不包含
              assert (0..10).contains(-1) == false
              assert (0..10).contains(11) == false
      
              // 包含
              assert (0..<10).contains(9)
              assert (0..<10).contains(10) == false
      
              def a = 0..10
              assert  a instanceof  Range
      
              assert a.contains(5)
      
              a = new IntRange(0,10)
      
              assert a.contains(5)
      
              assert (0.0..1.0).contains(1.0)
              assert (0.0..1.0).containsWithinBounds(0.5)
      
              // 日期范围
              def today = new Date()
              def  yesterday =  today -1
              assert (yesterday..today).size() == 2
      
              assert ('a'..'c').contains('b')
      
              def log =''
              for (element in 5..9) {
                  log += element
              }
              assert  log == '56789'
      
              log=''
              for (element in 9..5){
                  log += element
              }
              assert  log == '98765'
      
              log =''
              (9..<5).each {
                  element -> log += element
              }
              assert  log == '9876'
      
          }
      }
      
      

1.2、Range也是对象

  • 使用switch也可以使用range ,grep

  • /**
     * @author liangchen* @date 2020/10/24
     */
    class RangeObjectDemo {
        static void main(String[] args) {
            def result = ''
            (5..9).each {
                element -> result += element
            }
            assert  result == '56789'
            assert  5 in 0..10
            assert  (0..10).isCase(5)
    
            def age = 36
            def insuranceRate
            switch (age) {
                case  16..20 : insuranceRate = 0.05 ;break
                case 21..50 : insuranceRate = 0.06; break
                case 51..65: insuranceRate = 0.07; break
                default:throw new IllegalArgumentException()
            }
    
            assert insuranceRate == 0.06
            // 数组 grep 过滤范围数据
            def ages = [20, 36, 42, 56]
            def midage = 21..50
            assert  ages.grep(midage) == [36, 42]
        }
    }
    
    

1.3、Rangs实

  • 自定义日期类

    • /**
       * @author liangchen* @date 2020/10/24
       */
      class CustomWeekdayDemo {
      
      
          static void main(String[] args) {
              def mon = new Weekday('Mon')
              def fri = new Weekday('Fri')
              def worklog =''
              for (day in mon..fri) {
                  worklog += day.toString() + ' '
              }
              assert worklog == 'Mon Tue Wed Thu Fri '
      
          }
      }
      
      class Weekday implements  Comparable<Weekday> {
      
          static  final  DAYS = [
                  'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'
          ]
          private  int index = 0
      
          Weekday(String day){
              index = DAYS.indexOf(day)
          }
          @Override
          int compareTo(Weekday o) {
              return this.index <=> o.index
          }
      
          Weekday next(){
              return new Weekday((DAYS[(index +1) % DAYS.size()]))
          }
          Weekday previous (){
              return  new Weekday(DAYS[(index-1) % DAYS.size()])
          }
      
          String toString(){
              return DAYS[index]
          }
      }
      

2、 list集合

2.1、 具体List集合

  • 默认是java.util.LinkedList

    • /**
       * list 集合
       * @author liangchen* @date 2020/10/24
       */
      class ListSpecifyDemo {
      
          static void main(String[] args) {
              List myList = [1, 2, 3]
      
              assert myList.size() ==3
              assert myList[0] == 1
      
              assert  myList instanceof  ArrayList
      
              List emptyList =[]
              assert  emptyList.size() ==0
              // Rang转换成list
              List longList = (0..1000).toList()
              assert  longList[555] == 555
      
              List explicitList = new ArrayList()
              explicitList.addAll(myList)
      
              assert explicitList.size() == 3
              explicitList[0] = 10
      
              assert  explicitList[0] == 10
      
              explicitList = new LinkedList(myList)
              assert  explicitList.size() == 3
              explicitList[0] = 10
              assert explicitList[0] == 10
          }
      }
      
      

2.2、 使用 list 操作符

  • 例子

  • /**
     * @author liangchen* @date 2020/10/24
     */
    class ListOperatorDemo {
    
        static void main(String[] args) {
           def myList = ['a', 'b', 'c', 'd', 'e','f']
            assert  myList [0..2] == ['a','b','c']
            assert  myList [0,2,4] == ['a', 'c', 'e']
    
            // myList
            myList[0..2] = ['x', 'y', 'z']
            assert  myList == ['x','y','z', 'd','e', 'f']
    
            // 删除3..5元素
            myList [3..5] = []
    
            assert  myList == ['x','y','z']
    
            // 替换1号位置元素
            myList[1..1] = [0,1,2]
            assert  myList == ['x', 0, 1,2,'z']
    
            // 添加元素
            def yourList = []
    
            yourList += 'a'
            assert  yourList == ['a']
    
            yourList +=['b','c']
            assert  yourList == ['a','b','c']
    
            yourList =[]
            yourList << 'a' << 'b'
    
            assert  yourList == ['a', 'b']
            // 减去一个元素
            assert  yourList - ['b'] == ['a']
    
            //乘以元素
            assert yourList * 2 == ['a','b','a','b']
    
    
            //控制结构
            def controlList = ['a', 'b','c']
            assert  controlList.isCase('a')
            assert 'b' in controlList
            def candidate = 'c'
            switch (candidate) {
             case controlList : assert true; break
             default: assert  false
            }
            // 取交集
            assert ['x', 'a','z'].grep(controlList) == ['a']
            controlList = []
    
            if(controlList) assert  false
            // 遍历list集合
             def  expr =''
          for (i in [1, '*', 5]) {
           expr +=i
          }
          assert expr == '1*5'
    
        }
    }
    
    

2.3、使用list方法

  • 例子

  • class ListMethodDemo {
    
        static void main(String[] args) {
    
            //平铺元素
            assert [1, [2,3]].flatten() == [1,2,3]
            //取交集
            assert [1,2,3].intersect([4,3,1]) == [3,1]
    
            assert [1,2,3].disjoint([4,5,6])
    
            def  list = [1,2,3]
            //移除第一个元素
            def popped = list.pop()
    
            assert popped == 1
            assert  list == [2,3]
            //反转
            assert [1,2].reverse() == [2,1]
            //排序
            assert [3,1,2].sort() == [1,2,3]
            def sortMultiArray = [[1,0],[0,1,2]]
            // 第一个元素排序
            sortMultiArray = sortMultiArray.sort{a,b -> a[0]<=> b[0]}
            assert sortMultiArray == [[0,1,2], [1,0]]
            // 数组大小排序
            sortMultiArray.sort{item -> item.size()}
            assert  sortMultiArray == [[1,0], [0,1,2]]
    
            // 移除第三个元素
            list = ['a', 'b','c']
            list.remove(2)
            assert list == ['a','b']
            list.remove('b')
            assert list == ['a']
            // 移除多个元素
            list =['a','b','b','c']
            list.removeAll(['b','c'])
            assert  list == ['a']
    
            // 乘以2
            def doubled  = [1,2,3].collect{
                item -> item*2
            }
    
            // 遍历查找元素
            assert doubled == [2,4,6]
            def  odd = [1,2,3].findAll {
                item -> item % 2 == 1
    
            }
            assert  odd == [1,3]
    
    
            //去重
            def x = [1,1,1]
            assert [1] == new HashSet(x).toList()
            assert [1] == x.unique()
    
            x = [1,null,1]
            assert  [1,1] == x.findAll { it != null }
            assert [1,1] == x.grep{it}
    
        }
    }
    
    
  • list的聚合操作

    • package com.jack.groovy.ch4
      
      /**
       * @author liangchen* @date 2020/10/27
       */
      class ListAccumulationDemo {
      
          static void main(String[] args) {
              def list = [1, 2, 3]
              assert list.first() == 1
              assert list.head() == 1
              assert list.tail() == [2, 3]
              assert list.last() == 3
              // 计数
              assert list.count(2) == 1
              assert list.max() == 3
      
              assert list.min() == 1
      
              def  even = list.find {
                  item -> item % 2 == 0
      
              }
              assert even == 2
              // 每个元素都满足如下条件
              assert list.every() { item -> item < 5 }
              // 任意一个元素满足条件
              assert list.any { item -> item < 2 }
      
              def store =''
              // 字符串拼接
              list.each { item -> store += item }
              assert  store == '123'
      
              // 逆序
              store = ''
              list.reverseEach {
                  item -> store += item
              }
              assert  store == '321'
      
              // 遍历索引和值
              store = ''
              list.eachWithIndex { item, index ->
                  store += "$index:$item "
              }
              assert store == '0:1 1:2 2:3 '
      
              // 拼接
              assert  list.join('-') == '1-2-3'
      
              // 进行连续计算,0 和 list第一个元素算出结果,继续+下一个元素
              def result =list.inject ( 0 ) { clinks, guests -> clinks + guests }
              assert  result == 0 + 1 + 2 + 3
      
              assert  list.sum() == 6
      
              def factorial = list.inject (1) {
                  fac, item -> fac * item
      
              }
              assert  factorial == 1 * 1 * 2 * 3
      
          }
      }
      
      

2.4、list 实操

  • 快速排序例子

    • /**
       * 快速排序
       * @author liangchen* @date 2020/10/30
       */
      class QuickSortDemo {
      
          static void main(String[] args) {
      
              assert quickSort([]) == []
              assert  quickSort([1])==[1]
              assert quickSort([2,1]) == [1,2]
              assert quickSort([3, 1, 2]) == [1, 2, 3]
              assert quickSort([3,1,2,2]) == [1,2,2,3]
              assert quickSort([1.0f, 'a', 10, null]) == [null, 1.0f, 10, 'a']
              assert quickSort('bca') == 'abc'.toList()
          }
      
          def static quickSort(list) {
              if (list.size() < 2) {
                  return list
              }
              def pivot = list[list.size().intdiv(2)]
              def left = list.findAll {
                  item -> item < pivot
              }
              def middle = list.findAll{
                  item -> item == pivot
              }
              def right = list.findAll{
                  item -> item > pivot
              }
              return quickSort(left) + middle + quickSort(right)
          }
      
      }
      
      

3、 map集合

3.1、指定Map

  • /** 
     * 一般map使用
     * 指定map
     * @author liangchen* @date 2020/11/1
     */
    class SpecifyingMap {
        static void main(String[] args) {
            // 默认创建是LinkedHashMap
            def myMap = [a: 1, b: 2, c: 3]
            assert myMap instanceof  LinkedHashMap;
    
            assert myMap.size() == 3
    
            assert myMap['a'] == 1
    
            //创建一个空Map
            def emptyMap = [:]
            assert emptyMap.size() == 0
    
            // 将map放入TreeMap
            def explicitMap = new TreeMap()
            explicitMap.putAll(myMap)
            assert explicitMap['a'] == 1
    
            //直接用*map集合 进行引用,组合成Map
            def composed = [x: 'y', *: myMap]
            assert composed == [x: 'y', a: 1, b: 2, c: 3]
    
            def x = 'a'
            // 表示默认加上'x'
            assert ['x': 1] == [x: 1]
            // 如果要是引用变量时候需要加上括号
            assert ['a': 1] == [(x): 1]
    
    
    
        }
    }
    
    

3.2、使用map操作

  • 默认的值是null

  • /**
     * 获取map的值以及默认值
     * @author liangchen* @date 2020/11/1
     */
    class AccessingMapDemo {
        static void main(String[] args) {
    
            def mayMap = [a: 1, b: 2, c: 3]
            // 获取存在key对应的值
            assert mayMap['a'] == 1
            assert mayMap.a ==1
            assert mayMap.get('a') == 1
            // 如果获取不到返回默认值1
            assert mayMap.get('f',1) == 1
    
            assert mayMap['d'] == null
            assert mayMap.d == null
            assert mayMap.get('d') == null
    
            // 获取不到值默认是1, 同时设置d = 1
            assert mayMap.get('d', 1) == 1
            assert mayMap.d == 1
    
            mayMap['d'] = 2
            assert mayMap.d == 2
    
            mayMap.d = 2
            assert mayMap.d == 2
    
            mayMap = ['a.b': 1]
            assert  mayMap.'a.b' ==1
        }
    }
    
    
  • 元素遍历

    • /**
       * map的查询遍历
       * @author liangchen* @date 2020/11/1
       */
      class QueryMapDemo {
      
          static void main(String[] args) {
      
              def myMap = [a: 1, b: 2, c: 3]
              def other = [b: 2, c: 3, a: 1]
              assert myMap == other
      
              assert !myMap.isEmpty()
              assert myMap.size()
              assert myMap.containsKey("a")
              assert myMap.containsValue(1)
              assert myMap.entrySet() instanceof Collection
      
              assert myMap.any { entry -> entry.value > 2 }
              assert myMap.every { entry -> entry.key < 'd' }
              assert myMap.keySet() == ['a', 'b', 'c'] as Set
              assert myMap.values().toList() == [1, 2, 3]
      
              //========= 迭代,遍历元素
              def store = ''
              myMap.each { entry ->
                  store += entry.key
                  store += entry.value
              }
              assert store == 'a1b2c3'
      
              store = ''
              myMap.each { key, value ->
                  store += key
                  store += value
              }
      
              assert store == 'a1b2c3'
      
              store = ''
              for (key in myMap.keySet()) {
                  store += key
              }
              assert store == 'abc'
      
              store = ''
              for (value in myMap.values()) {
                  store += value
              }
              assert  store == '123'
          }
      }
      
      
    • 改变map构建新对象

      • /**
         * @author liangchen* @date 2020/11/1
         */
        class ChangeMapDemo {
        
            static void main(String[] args) {
        
                //清除原始
                def myMap = [a: 1, b: 2, c: 3]
                myMap.clear()
                assert myMap.isEmpty()
        
                //移除元素
                myMap = [a: 1, b: 2, c: 3]
                myMap.remove('a')
                assert myMap.size() == 2
        
                // 创建子map
                assert [a: 1] + [b: 2] == [a: 1, b: 2]
                myMap = [a: 1, b: 2, c: 3]
                def abMap = myMap.subMap(['a', 'b'])
                assert abMap.size() == 2
        
                // 查找所有满足要求元素
                abMap = myMap.findAll { entry -> entry.value < 3 }
                assert abMap.size() == 2
                assert abMap.a == 1
        
                //查询满足条件第一元素
                def found = myMap.find { entry -> entry.value < 2 }
                assert found.key == 'a'
                assert found.value == 1
        
                def doubled = myMap.collect { entry -> entry.value *= 2 }
                assert doubled instanceof List
                assert doubled.every { item -> item % 2 == 0 }
        
                def addTo = []
                myMap.collect (addTo) { entry -> entry.value *= 2 }
                assert  addTo instanceof  List
                assert  addTo.every { item -> item % 2 == 0 }
        
        
            }
        }
        
        

4、Groovy集合注意事项

  • 并发修改会抛出ConcurrentModificationException

5、总结

  • Range 对象
  • List 和Map操作都类似java,也就在jdk基础上封装一下
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值