集合

集合简介

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。

对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包：

• 不可变集合：scala.collection.immutable
• 不可变集合：scala.collection.mutable

不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于Java中的String对象。

可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于Java中的StringBuidler对象。

数组

不可变数组

val arr1 = new Array[Int](10)

[Int] 是指定可以存放的数据类型，如果希望为任意类型，则可以指定为Any

(10) 表示数组的大小，确定后不可以变化

package chapter07

object Test01_ImmutableArray {
  def main(args: Array[String]): Unit = {
    // 1. 创建数组
    val arr = new Array[Int](10)

    // 另一种创建方式
    val arr2 = Array(12, 37, 42, 58, 97)

    // 2. 访问数组中的元素
    println(arr(0))
//    println(arr(5))
    // 赋值
    arr(0) = 12
    arr(1) = 24
    println(arr(0))

    // TODO 数组的遍历
    // 普通for循环
    for(i <- 0 to arr.length - 1) {
      println(arr(i))
    }

    for (i <- arr.indices) println(arr(i))

    // 直接遍历所有元素，增强for循环
    for(elem <- arr2) {
      println(elem)
    }

    // 迭代器
    val iter = arr.iterator
    while (iter.hasNext)
      println(iter.next())

    // 调用foreach方法
    arr2.foreach((elem: Int) => println(elem))
    arr2.foreach(println) // 至简原则
    
    // 以字符串输出
    println(arr2.mkString("--"))

  }
}

可变数组

package chapter07

import scala.collection.mutable.ArrayBuffer

object Test02_ArrayBuffer {
  def main(args: Array[String]): Unit = {
    // TODO 创建可变数组
    // 默认长度为16
    val arr = new ArrayBuffer[Int]()
    val arr2 = ArrayBuffer(25, 37, 98)

    println(arr.mkString(", "))
    // 重写了toString方法，可以直接打印
    println(arr2)

    // 访问元素
//    println(arr(0)) // 此时数组越界
    println(arr2(1))
    // arr(0) = 5
    // println(arr(0))

    // TODO 添加元素
    arr += 19
    77 +=: arr
    arr.append(36)
    arr.prepend(52, 34)
    // 索引位置和数据
    arr.insert(2, 32, 59)
    println(arr)

    // TODO 删除元素
    // 索引位置
    arr.remove(2)
    // 索引位置 删除个数
    arr.remove(2, 3)
    // 删除元素的Value，如果找不到什么都不做
    arr -= 36
    println(arr)

  }
}

可变数组与不可变数组的转换

// 可变数组转换为不可变数组
val arr:ArrayBuffer[Int] = ArrayBuffer(23, 56, 98)
var array: Array[Int] = arr.toArray

// 不可变数组转换为可变数组
val arrayBuffer = array.toBuffer

多维数组

package chapter07

object Test03_MulArray {
  def main(args: Array[String]): Unit = {
    // TODO 创建二维数组
    val array = Array.ofDim[Int](2, 3)

    // 访问元素
    array(0)(2) = 19
    array(1)(0) = 25

    // 遍历
    for(i <- 0 until array.length; j <- 0 until array(i).length) {
      println(array(i)(j))
    }

    for (i <- array.indices; j <- array(i).indices) {
      print(array(i)(j) + "\t")
      if (j == array(i).length-1)
        println()
    }

    array.foreach(line => line.foreach(println))


  }
}

列表

不可变List

List默认为不可变集合

创建一个List（数据有顺序，可重复）

遍历List

List增加数据

集合间合并：将一个整体拆分成一个一个的个体，成为扁平化

去指定数据

空集合Nil

package chapter07

import scala.+:

object Test04_List {
  def main(args: Array[String]): Unit = {
    // TODO 创建List
    // 通过List伴生对象的apply方法创建
    val list = List(23, 65, 87)

    // TODO 访问元素
    println(list(1))
    list.foreach(item => println(item))

    // TODO 添加元素
    val newList = list :+ 10
    val newList2 = 10 +: list
    println(newList)
    println(newList2)
    println("=======================")

    val newList3 = list.::(51)

    // 通常上述的这种操作的使用场景
    // 我们可以在一个空集合后面添加元素
    val list2 = Nil.::(13)
    // 但是这样使用看上去还是没什么用
    // 所以有了下边的方式，将想要的数字生成一个列表
    val list3 = 13 :: Nil
    val list4 = 14 :: 53 :: -32 :: Nil

    // TODO 合并列表
    // 扁平化处理
    val list5 = list ::: list4
    println(list5)

    val list6 = list ++ list4
    println(list6)
  }
}

可变

package chapter07

import scala.collection.mutable.ListBuffer

object Test05_ListBuffer {
  def main(args: Array[String]): Unit = {
    // TODO 创建可变列表
    val list: ListBuffer[Int] = new ListBuffer[Int]()
    val list2 = ListBuffer(12, 53, 75)
    println(list)
    println(list2)

    // TODO 添加元素
    list.append(15, 62)
    println("list =>" + list)
    list2.prepend(32, 25, 64)
    println("list2 => " + list2)
    // 指定位置添加
    list.insert(19, 22)
    println("list =>" + list)

    // list += 32 += 21
    31 +=: 16 +=: list += 32 += 21
    println("list => " + list)

    // 合并List
    val list3 = list ++ list2
    println("list3 => " + list3)

    list ++= list2
    println(list)

    // TODO 修改元素
    list2(2) = 80
    list2.update(0, 30)
    println(list2)

    // TODO 删除元素
    list2.remove(2)
    list2 -= 25
    println(list2)
    
  }
}

Set集合

默认情况下，Scala使用的是不可变集合。如果你想使用可变集合，需要引用scala.collection.mutable.Set包

不可变Set

Set默认是不可变集合，数据无序

数据不可重复

遍历集合

package chapter07

object Test06_ImmutableSet {
  def main(args: Array[String]): Unit = {
    // TODO 创建Set
    println("----------创建Set----------")
    val set = Set(13, 23, 53, 12, 13, 23, 78)
    println("set => " + set)

    // TODO 添加元素
    println("----------添加元素----------")
    val set2 = set.+(20)
    val set3 = set + 30
    println("set2 => " + set2)
    println("set3 => " + set3)

    // TODO 合并集合
    // 相同的数据会进行去重，不同的数据保存
    println("----------合并Set----------")
    val set4 = Set(19, 13, 23, 53, 67, 99)
    val set5 = set ++ set4
    println("set5 => " + set5)

    // TODO 删除元素
    println("----------删除元素----------")
    val set6 = set -12
    println("set6 => " + set6)


  }
}

可变Set

package chapter07

import scala.collection.mutable.Set

object Test07_MutableSet {
  def main(args: Array[String]): Unit = {
    // TODO 创建Set
    println("----------创建Set----------")
    val set: Set[Int] = Set[Int](13,23,53,12,13,23,78)
    println("set => " + set)

    // TODO 添加元素
    println("----------添加元素----------")
    set += 11
    println("set => " + set)
    val flag = set.add(20)
    println("set => " + set)
    println("flag =>" + flag)

    // TODO 删除元素
    println("----------删除元素----------")
    set -= 13
    println("set => " + set)

    val removeFlag = set.remove(2)
    println("set => " + set)
    println("removeFlag => " + removeFlag)

    // TODO 合并Set
    println("----------合并Set----------")
    val set2 = Set(13, 12, 13, 27, 28, 29)
    val set3 = set ++ set2
    println("set =>" + set)
    println("set2 => " + set2)
    println("set3 => " + set3)

    set ++= set2
    println("set =>" + set)
    println("set2 => " + set2)
    
  }
}

Map集合

Scala中的Map和Java类似，也是一个散列表，他存储的内容也是键值对映射

不可变Map

不可变的Map集合中不可以增加元素。

package chapter07

object Test08_ImmutableMap {
  def main(args: Array[String]): Unit = {
    // TODO 创建Map
    println("----------创建Map----------")
    val map: Map[String, Int] = Map("Hello" -> 4, "World" -> 2)
    println(map)
    println(map.getClass)

    // TODO 遍历元素
    println("----------遍历元素----------")
    map.foreach(println)
    map.foreach((kv: (String, Int)) => println(kv))

    // TODO 取map中所有的key和value
    println("----------取map中所有的key和value----------")
    for (key <- map.keys) {
      println(s"${key} ---> ${map.get(key).get}")
    }

    // TODO 访问某一个key的value
    println(map.get("Hello").get)
    // 推荐写法
    println(map.getOrElse("World", 0))
    println(map.getOrElse("Nothing", 0))

  }
}

可变Map

package chapter07

import scala.collection.mutable.Map

object Test09_MutableMap {
  def main(args: Array[String]): Unit = {
    val map:Map[String, Int] = Map("Hello" -> 4, "World" -> 2)

    // TODO 添加元素
    println("----------添加元素----------")
    map.put("Scala", 2)
    println(map)

    // 使用符号添加
    map += (("Spark", 3))
    println(map)

    // TODO 删除元素
    println("----------删除元素----------")
    map.remove("Hello")

    map -= "Spark"
    println(map)

    // TODO 修改元素
    println("----------修改元素----------")
    map.update("Scala", 3)
    println(map)

    // TODO 合并两个Map
    println("----------合并两个Map----------")
    val map2 = Map[String, Int]("Hello" -> 20, "aaa" -> 32)
    map ++= map2
    // map2会覆盖map中重复的值
    println(map)
  }
}

元组

元组也是可以理解为一个容器，可以存放各种相同或者不同类库的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。

元组最大只能有22个元素。

package chapter07

object Test10_Tuple {
  def main(args: Array[String]): Unit = {
    // TODO 创建元组
    val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
    println(tuple)

    // TODO 访问数据
    println(tuple._1)
    println(tuple._2)
    println(tuple.productElement(2))

    // TODO 遍历元组数据
    for (elem <- tuple.productIterator) {
      println(elem)
    }
    
    // TODO 嵌套元组
    val mulTuple = (12, 0.3, "hello", ("haha", "scala", 23), true)
    println(mulTuple._4._1)
  }
}

集合常用函数

基本属性和常用操作

package chapter07

object Test11_CommonOperation {
  def main(args: Array[String]): Unit = {
    val list = List(1,3,5,7,2,89,100)
    val set = Set(23,34,423,75)

    // 获取集合长度
    println(list.length)

    // 获取集合大小
    println(list.size)
    println(set.size)

    // 循环遍历
    for(elem <- list) {
      print(elem + "\t")
    }
    println()

    for (elem <- set) {
      print(elem + "\t")
    }
    println()

    // 迭代器
    for (elem <- set.iterator) print(elem + "\t")
    println()

    // 生成字符串
    println(list)

    // 是否包含
    println(list.contains(23))
  }
}

衍生集合

package chapter07

object Test12_DerivedCollection {
  def main(args: Array[String]): Unit = {
    val list = List(1,3,5,7,2,89,100)
    val list2 = List(3, 89, 32, 6, 5, 2)
    println(list)

    // 获取集合的第一个元素
    println(list.head)

    // 获取除了集合第一个元素外所有的元素
    println(list.tail)

    // 集合初始数据（不包含最后一个）
    println(list.init)

    // 获取集合的最后一个元素
    println(list.last)

    // 反转
    println(list.reverse)

    // 取前（后）n个元素
    println(list.take(3))
    println(list.takeRight(3))

    // 去掉前（后）n个元素
    println(list.drop(3))
    println(list.dropRight(1))

    // 并集
    val union = list.union(list2)
    println("union =>" + union)
    println(list:::list2)
    // 如果是set做并集，则会去重

    // 交集
    val intersection = list.intersect(list2)
    println("intersection =>" + intersection)

    // 差集
    val diff1 = list.diff(list2)
    val diff2 = list.diff(list)
    println("diff1 => " + diff1)
    println("diff2 => " + diff2)

    // 拉链
    println("zip => " + list.zip(list2))

    println("--------------------")
    // 滑窗
    for (elem <- list.sliding(3)) {
      println(elem)
    }

    println("--------------------")
    for(elem <- list2.sliding(3, 2))
      println(elem)
  }
}

集合计算初级函数

package chapter07

object Test13_SimpleFunction {
  def main(args: Array[String]): Unit = {
    val list=  List(5,1,8,2,-3,4)
    val list2 = List(("a", 3), ("b", 5), ("c", 9), ("d", 2), ("e", 6))

    // 求和
    val sum = list.sum
    println(sum)

    // 求乘积
    println(list.product)

    // 最大值
    println(list.max)
    println(list2.maxBy((tuple: (String, Int)) => tuple._2))
    // 简化
    println(list2.maxBy(_._2))

    // 最小值
    println(list.min)
    println(list2.minBy(_._2))

    // 排序
    val sortedList = list.sorted
    println(sortedList)

    // 从大到小逆序排列
    // 传入一个隐式参数
    val sortedListDesc = list.sorted(Ordering[Int].reverse)
    println(sortedListDesc)

    println(list2.sortBy((tuple:(String, Int)) => tuple._2)(Ordering[Int].reverse))

    // sortWith
    println(list.sortWith((a: Int, b: Int) => { a < b }))
    // 简化
    println(list.sortWith(_ < _))
    println(list.sortWith(_ > _))
  }
}

集合计算高级函数

package chapter07

object Test14_HighLevelFunction_Map {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4,5,6,7)

    // TODO 过滤
    // 选取偶数
    list.filter( (elem:Int) => {elem % 2 == 0} )
    println(list.filter(_%2==0))

    // TODO 转化映射map
    // 把集合每个数*2
    list.map((elem: Int) => {elem * 2})

    // TODO 扁平化
    val nestedList: List[List[Int]] = List(List(1,23,5), List(6,7,8,9), List(4,5))

    println(nestedList.flatten)

    // 扁平映射
    // 将一组字符串进行分词，并保存成单词的列表
    val strings: List[String] = List("Hello world", "Hello Scala", "Hello Java")
    // 1.分词
    val splitList: List[Array[String]] = strings.map(string => { string.split(" ")})
    println(splitList)
    // 扁平化
    val flattenList = splitList.flatten
    println(flattenList)

    // 这样的步骤看着有点复杂，所以引出我们的扁平化操作
    val flattenMapList = strings.flatMap(_.split(" "))
    println(flattenMapList)

    // TODO 分组操作
    // 分成奇偶两组
    val groupMap = list.groupBy( _ % 2 == 0 )
    
    val groupMap2 = list.groupBy(data => if (data % 2 == 0) "偶数" else "奇数" )
  }
}

package chapter07

object Test15_HighLevelFunction_Reduce {
  def main(args: Array[String]): Unit = {
    val list= List(1,2,3,4,5)
    // 归约
    // reduce
    println(list.reduce( _ + _ ))

    println(list.reduceRight(_ - _)) // 1 - ( 2 - ( 3 - ( 4 - 5) ) )

    // fold
    println(list.fold(10)( _ + _))

    println(list.foldRight(10)( _ - _ )) // 1 - ( 2 -( 3 - ( 4 - (5 - 10) ) ))
  }
}