Scala-day05-集合

一：集合简介

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

2：对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。

        可变集合：scala.collection.mutable

        不可变集合：scala.collection.immutable

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

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

二：数组

1：不可变数组-第一种定义

定义：val arr1 = new Array[Int](10)

new 是关键字

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

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

2：不可变数组：第二种定义

定义：val arr = Array(1,2)

在定义数组时，直接赋初始值

使用apply方法创建数组对象

 3：不可变数组-案例

package chapter06

object Test01_ImmutableArray {
  def main(args: Array[String]): Unit = {
    //1.创建数组
    val arr = new Array[Int](5)
    // 另一种创建方式
    val arr2 = Array(12,37,42,58,97)

    //2.访问元素
    println(arr(0))
    println(arr(1))
    println(arr(2))

    //修改
    arr(0)=12
    arr(4)=57
    println(arr(0))
    println(arr(1))
    println(arr(2))

    //遍历
    //普通for循环
    for(i <- 0 until arr.length){
      println(arr(i))
    }

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

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

    //迭代器
    val iter = arr2.iterator
    while (iter.hasNext){
      println(iter.next())
    }

    // 调用foreach方法
    arr2.foreach((elem:Int) => println(elem))

    println(arr2.mkString("--"))//12--37--42--58--97

    //添加元素
    val newArr = arr2.:+(73)//后面添加
    println(arr2.mkString("--"))//12--37--42--58--97
    println(newArr.mkString("--"))//12--37--42--58--97--73

    val newArr2 = newArr.+:(30)//前面添加
    println(newArr2.mkString("--"))//30--12--37--42--58--97--73

    val newArr3 = newArr2 :+ 15 //后面添加
    val newArr4 = 29 +: newArr3 //前面添加
    val newArr5 = 10 +: 29 +: newArr4 :+ 26 :+ 73
  }
}

        4：可变数组

val arr01 = ArrayBuffer[Any](3,2,5)

[Any]存放任意数据类型

（3，2，5）初始化好的三个元素

ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer

        5：可变数组的案例

package chapter06

import scala.collection.mutable.{AbstractBuffer, ArrayBuffer}

object Test02_ArrayBuffer {
  def main(args: Array[String]): Unit = {
    //1.创建可变数组
    val arr1 = new ArrayBuffer[Int]()
    val arr2 = ArrayBuffer(23,57,92)

    println(arr1.mkString(","))
    println(arr2)

    //访问元素
    println(arr2(1))
    arr2(1) = 39
    println(arr2(1))

    //添加元素
    val newArr1 = arr1 :+ 15
    println(arr1)
    println(newArr1)

    arr1 += 19//后面添加
    println(arr1)

    77 +=: arr1//前面添加
    println(arr1)

    arr1.append(36)//后面添加
    arr1.prepend(11,76)//前面添加
    arr1.insert(1,13,59)//具体位置来添加，第一个参数为索引位置
    arr1.insertAll(2,newArr1) //索引为2的地方，添加一个数组

    //删除元素
    arr1.remove(3)//参数为索引位置
    arr1.remove(0,10)//第一个参数为索引位置，第二个参数代表删除几个数

    arr1 -= 13 //arr1中删除13的数据，如果没有出现过，也可以，代表什么也不操作

    //可变数组转换为不可变数组
    val arr = ArrayBuffer(23,56,98)
    val newArr = arr.toArray
    
    //不可变数组转换为可变数组
    val buffer = newArr.toBuffer
  }
}

        6：多维数组

package chapter06

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

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

    println(array.mkString(","))
    for (i <- 0 until array.length; j <- 0 until array(i).length){
      println(array(i)(j))
    }

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

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

  }
}

三：列表

        可变列表和不可变列表

package chapter06

import scala.collection.mutable.ListBuffer

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

    println(list1)
    println(list2)

    //添加元素
    list1.append(15,62)
    list2.prepend(20)

    list1.insert(1,19,22)
    println(list1)
    println(list2)

    list1 += 25 += 11
    31 +=: 96 +=: list1
    println(list1)

    val list3 = list1 ++ list2
    println(list1)
    println(list2)//list1和list2都不会发生改变

    list1 ++= list2
    println(list1)//list1发生改变，list2不发生改变
    println(list2)

    //修改元素
    list2(3) = 30
    println(list2)

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

四：set集合（无序、不可重复）

        不可变set集合

package chapter06

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

    //添加元素
    val set2 = set1.+(20)//set1本身不变
    println(set1)
    println(set2)

    //合并
    val set3 = Set(19,13,23,53,67,99)
    val set4 = set2 ++ set3
    println(set4)
    println(set2)
    println(set3)

    //删除元素
    val set5 = set3 - 13
    println(set5)
  }
}

        可变set集合

package chapter06

import scala.collection.mutable

object Test07_MutableSet {
  def main(args: Array[String]): Unit = {
    //创建set
    val set1 = mutable.Set(13,23,53,12,13,23,78)
    println(set1)

    //添加元素
    val set2 = set1 + 11
    println(set1)
    println(set2)

    set1 += 11
    println(set1)

    set1.add(10)
    println(set1)

    //删除元素
    set1 -= 11
    println(set1)

    //合并
    val set3 = mutable.Set(13,12,13,27,98,29)
    println(set1)
    println(set3)

    set1 ++= set3
    println(set1)

  }
}

五：Map集合

        不可变Map

package chapter06

object Test08_ImmutableMap {
  def main(args: Array[String]): Unit = {
    //创建map
    val map1:Map[String,Int] = Map("a" -> 12,"b" -> 25)
    println(map1)
    println(map1.getClass)

    //遍历元素
    map1.foreach(println)
    map1.foreach( (kv:(String,Int)) => println(kv))

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

    //访问某一个key的value
    println(map1.get("a").get)
    println(map1.get("c"))
    println(map1.getOrElse("c",0))//获取c的值，如果没有，返回初始值
  }
}

        可变Map

package chapter06

import scala.collection.mutable

object Test09_MutableMap {
  def main(args: Array[String]): Unit = {
    //创建map
    val map1:mutable.Map[String,Int] = mutable.Map("a" -> 12,"b" -> 25)
    println(map1)
    println(map1.getClass)

    //添加元素
    map1.put("c",5)
    map1.put("d",9)
    println(map1)

    map1 += (("e",7))
    println(map1)

    //删除元素
    map1.remove("c")
    map1 -= "d"
    println(map1)

    //修改元素
    map1.update("a",5)

    //合并
    val map2:mutable.Map[String,Int] = mutable.Map("aa" -> 12,"bb" -> 25)
    map1 ++= map2
    println(map1)

    val map3 = map2 ++ map1
    println(map1)
    println(map2)
    println(map3)
  }
}

六：元组

package chapter06

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

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

    println(tuple.productElement(1))//从0开始

    //遍历元组数据
    for (elem <- tuple.productIterator){
      println(elem)
    }

    //嵌套元组
    val mulTuple = (12,0.3,"hello",(23,"scala",29))
    println(mulTuple._4._2)//scala

  }
}

七：集合-通用属性和操作

package chapter06

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

    println(list.length)
    println(set.size)

    for (elem <- list){
      println(elem)
    }
    set.foreach(println)

    for(elem <- list.iterator) println(elem)

    //生成字符串
    println(list.mkString("--"))

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

八：集合-衍生集合

package chapter06

object Test12_DerivedCollection {
  def main(args: Array[String]): Unit = {
    val list1 = List(1,3,5,7,9)
    val list2 = List(3,7,2,4,8)

    //获取集合的头
    println(list1.head)

    //获取集合的尾
    println(list1.tail)//除了头全是尾

    //集合最后一个元素
    println(list2.last)

    //集合初始元素（不包含最后一个）
    println(list2.init)

    //反转
    println(list1.reverse)

    //取前n个元素，后n个元素
    println(list1.take(3))//前3
    println(list1.takeRight(4))//后4

    //去掉前后n个元素
    println(list1.drop(3))
    println(list1.dropRight(4))

    //并集，如果是set会去重
    val union = list1.union(list2)
    println(union)

    //交集
    val intersection = list1.intersect(list2)
    println(intersection)

    //差集
    val diff1 = list1.diff(list2)//属于list1，但不属于list2
    val diff2 = list2.diff(list1)//属于list2，但不属于list1

    //拉链
    println(list1.zip(list2))//对应位置构成二元组

    //滑窗
    list1.sliding(3)//要得到大小为3的滑动窗口

    for(elem <- list1.sliding(3)){
      println(elem)
    }

  }
}

九：集合-简单函数

package chapter06

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

    //求和
    var sum = 0
    for(elem <- list){
      sum += elem
    }
    println(sum)

    println(list.sum)

    //乘积
    println(list.product)

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

    //最小
    println(list.min)

    //排序
    val sortedList = list.sorted
    println(sortedList)//从小到大

    //从大到小
    println(list.sorted(Ordering[Int].reverse))
    println(list2.sortBy(_._2))

  }
}

十：集合-高级计算函数-Map

package chapter06

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

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

    //map
    //把集合中的每个数乘2
    println(list.maxBy(_*2))
    println(list.map( x => x*x))

    //扁平化
    val nestList:List[List[Int]] = List(List(1,2,3),List(4,5),List(6,7,8,9))

    val flatList = nestList(0):::nestList(1):::nestList(2)
    println(flatList)
    val flatList2 = nestList.flatten
    println(flatList2)

    //扁平映射
    //将一组字符串进行分词，并博爱村成单词的列表
    val strings:List[String] = List("hello world","hello scala","hello java","we study")
    val splitList = strings.map(string => string.split(" "));

    val flattenList = splitList.flatten //打散扁平化
    println(flattenList)

    val flatmapList = strings.flatMap(_.split(" "))
    println(flatmapList)

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

    //给定一组词汇，按照单词的首字母进行分组
    val wordList = List("china","america","canada","cary","bob")
    println(wordList.groupBy( _.charAt(0)))
  }
}

十一：集合-高级计算函数-Reduce/fold

package chapter06

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

    println(list.reduce( _ + _ ))

    val list2 = List(3,4,5,6,8,10)
    println(list2.reduce(_ + _))
    println(list2.reduceLeft(_ + _))//从左向右减
    println(list2.reduceRight(_ + _))//3-(4-(5-(8-10)))

    //fold
    println(list.fold(10)(_ + _)) //10+1+2+3+4
    println(list.foldLeft(10)(_ - _)) //10-1-2-3-4
    println(list.foldRight(11)(_ - _))  //3-(4-(5-(8-(10-11))))

  }
}

package chapter06

import scala.collection.mutable

object Test16_MergeMap {
  def main(args: Array[String]): Unit = {
    val map1 = Map("a" -> 1,"b" -> 3,"c" -> 6)
    val map2 = mutable.Map("a" -> 6,"b" -> 2,"c" -> 9,"d" -> 3)

    val map3 = map1.foldLeft(map2)(
      (mergedMap,kv) => {
        val key = kv._1
        val value = kv._2
        mergedMap(key) = mergedMap.getOrElse(key,0)+value
        mergedMap
      }
    )
  }
}

十二：队列

package chapter06

import scala.collection.immutable.Queue
import scala.collection.mutable
import scala.collection.parallel.immutable

object Test18_Queue {
  def main(args: Array[String]): Unit = {
    //创建可变队列
    val queue = new mutable.Queue()

    //入队
    queue.enqueue("a","b","c")
    println(queue)

    //出队
    println(queue.dequeue())

    //不可变队列
    val queue2 = Queue("a","b","c")

    println(queue2.dequeue)
  }
}