Groovy之数据结构

• 2019 年 12 月 26 日
• 笔记

列表list

定义

Java中定义方式：def list = ArrayList()//java 中定义列表方式

Groovy中定义方式：def list = [1, 2, 3, 4, 5]//groovy 中定义列表方式

增加

1. 直接通过add的方式添加元素，与Java一直
2. 使用Groovy特有的语法leftShift进行添加，例如：listMake.leftShift(9)
3. 使用<<进行添加元素，例如：listMake << 8

def listMake = [1, 2, 3, 4]  /**   * list 添加元素   */  //listMake.add(10)  //listMake.leftShift(9)  listMake << 8  println listMake

删除

1. 通过与Java一样的方法remove与removeAt方法
2. 可以自定义闭包对集合中的元素特殊处理进行移除操作
3. 可以通过-符号进行删除集合中存在的元素，有就删除，没有不删除

/**   * list 删除元素   */  //listMake.remove(0)  //listMake.removeAt(1)  //listMake.removeElement(2)     //自定义闭包方式移除集合中所有的奇数  listMake.removeAll { return (it & 1) == 1 }  //减去当前集合中存在的元素，有就移除，没有不移除  println listMake - [2, 4]

查找

1. find 查找集合中第一个满足条件的元素，并返回查找元素
2. findAll 查找集合中所有满足条件的元素，返回的是一个集合
3. any 返回的是Boolean，集合中有一个元素满足条件，就返回true，否则false
4. every 与any一样返回的是Boolean，不同的是集合中所有的元素都需要满足该条件才返回true，如果有一个没有满足就返回false

*  列表查找   */  def findList = [2, 4, 3, 5, 7, -100]  //查找第一个满足是奇数条件的数  int result = findList.find { return (it & 1) == 1 }  println result  def resultLsit = findList.findAll { return (it & 1) == 0 }  println resultLsit.toListString()     def anyResult = findList.any { return (it & 1) == 1 }  println anyResult  def everyResult = findList.every { return (it & 1) == 1 }  println everyResult  println findList.min()  //获取绝对值的最大值  println findList.max { Math.abs(it) }

排序

列表排序可以自定义闭包的方式进行排序，例如：Comparator mc = { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } 或者直接调用sort方法进行排序，也可以在sort方法进行自定义闭包形式排序

/**   * 列表排序   */  def sortList = [-4, -10, 23, 4, 11, 9]  //自定义排序方式，按照绝对值进行排序  Comparator mc = { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 }  //Collections.sort(sortList,mc)  //sortList.sort()  //按照绝对值从大到小进行排序  sortList.sort { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? 1 : -1 }  println sortList

其他操作

def array = [2, 3, 4, 5] as int[]//将列表转换成数组形式  int[] array2 = [1, 2, 3, 4]     println findList.min()  //获取绝对值的最大值  println findList.max { Math.abs(it) }     //统计个数  def count = findList.count { return (it & 1) == 1 }  println count

Map

值得注意的是：groovy 中定义map，默认都是LinkedHashMap。但可以通过as HashMap转换成HashMap，或者一开始就定义HashMap，否则默认都是LinkedHashMap

添加

1. 通过 color.complex = [a: 1, b: 2]
2. 通过leftShirt进行添加，例如：color.leftShift("ss": "222")

def color = ["red"  : "ff0000",               "green": "00ff00",               "black": "000000"]     //索引方式  println color['red']  println color.green  //添加元素，查找元素，没有则添加  color.yello = "fff000"  //添加新的map  color.complex = [a: 1, b: 2]  //添加一个元素  color.leftShift("ss": "222")  println color.toMapString()  //只能通过getClass 来获取类型，否则color.class 就是查找当前中是否有key为class内容，没有则返回null  println color.getClass()

遍历

1. 通过each进行遍历
2. 通过eachWithIndex进行索引遍历
3. 通过key与value进行遍历

def student = [          1: [number: 001, score: 45, age: 23, name: "ztz"],          2: [number: 002, score: 56, age: 25, name: "yif"],          3: [number: 003, score: 67, age: 26, name: "fxy"],          4: [number: 004, score: 78, age: 28, name: "cxm"],  ]     //遍历  student.each { def stu ->      println "the key is ${stu.key},and the value is ${stu.value}"  }     /**   * 索引遍历 注意：student与index不能颠倒顺序，否则输出报错，因为会首先迭代获取当前map中内容   */  student.eachWithIndex { def stu, int index ->      println "the index is ${index}," + "the key is ${stu.value}" + " the value is ${stu.value}"  }     //直接遍历 key与value  student.each { key, value ->      println "the key is $key," + "the value is $value"  }     student.eachWithIndex { key, value, index ->      println "the index is $index," + "the key is $key," + "the value is $value"  }

查找

1. find 中闭包处理，内部通过get来通过key获取value值，返回第一个符合条件的对象
2. findAll 中闭包处理，内部通过get来通过key获取value值，返回所有符合条件的对象

/**   * map 查找   */  def student = [          1: [number: 001, score: 45, age: 24, name: "ztz"],          2: [number: 002, score: 56, age: 25, name: "yif"],          3: [number: 003, score: 67, age: 26, name: "fxy"],          4: [number: 004, score: 78, age: 26, name: "cxm"],  ]     def entry = student.find { def students ->      //必须通过get来获取key值      return students.value.get("score") >= 60  }  def entrys = student.findAll { def stu ->      return stu.value.get("score") >= 60  }  println entry  println entrys     def counts = student.count { def stu ->      return stu.value.get("score") >= 60 && stu.value.get("age") == 26  }  println counts     def names = student.findAll { def stu ->      return stu.value.get("score") >= 60  }.collect {      //使用collect进行过滤，只输出名字      return it.value.get("name")  }  println names.toListString()     //groupBy 进行分组输出  def groupResult = student.groupBy { def stu ->      return stu.value.get("score") >= 60 ? "及格" : "不及格"  }  println groupResult.toMapString()

排序

与列表排序类似，通过闭包进行自定义排序方式

/*  map 排序   */  def sortResult = student.sort { def stu1, def stu2 ->      Number sore1 = stu1.value.get("score")      Number sore2 = stu2.value.get("score")      return sore1 == sore2 ? 0 : sore1 > sore2 ? 1 : -1  }  println sortResult.toMapString()

Range

Range 返回处理，可以进行each返回输出，或者在switch中定义范围进行处理

/*  范围   */  def range = 1..10  println range[0]  println range.contains(10)  //获取范围起始值  println range.from  println range.to  range.each {      print it + " "  }     def getGrade(Number number) {      def result = 0      switch (number) {          case 0..<60:              result = "不及格"              break          case 60..<70:              result = "及格"              break          case 70..<80:              result = "良好"              break          case 80..<100:              result = "优秀"              break      }      //return 可以省略      return result  }     println getGrade(90)