Scala-Unit4-Scala数组/集合

时间:2022-02-23 21:39:36

一、Scala数组

  1.数组的定义:

  方法一:val arr = new Array[String](3)

    String代表数据的元素类型、3表示数组的长度

  方法二:val arr = Array[Int](1,3,5,7)

    修改数组某元素:arr(1) = 18

  注意:数组的长度不可改变,arr += 9(错误,数组不可添加元素),在定义数组时数据类型可以省略

  2.数组的方法

    1)map(映射)  

object MapTest {
def main(args: Array[String]): Unit = {
val arr = Array[Int](1,3,5,7) val arr1 = arr.map(x => x*5) println(arr1.toBuffer)
}
}

    注意:在Scala语言中,使用toBuffer来将堆地址转换为其对应数据信息。

    

    2)flatten(扁平化)

    命令行操作:val arr = Array("hello hunter henchou","hello reba henmei")

          arr.map(_.split(" "))       //res1: Array[Array[String]] = Array(Array(hello, hunter, henchou), Array(hello, reba, henmei))

          arr.map(_.split(" ")).flatten    //res2: Array[String] = Array(hello, hunter, henchou, hello, reba, henmei)

    3)flatMap(先做map映射,再做flatten扁平化)

     命令行操作:arr.flatMap(_.split(" "))    //res3: Array[String] = Array(hello, hunter, henchou, hello, reba, henmei)

    4)foreach(遍历数组)

     命令行操作:val arr = Array(2,4,6,8)

           arr.foreach(x => print(x))    //2468

    5)groupBy(分组)

     命令行操作:val arr = Array("hello hunter henchou","hello reba henmei")

          需求1:将arr分解成一个包含arr所有单词的数组,然后根据单词进行分类

           arr.flatMap(_.split(" ")).groupBy(x => x)    

          //结果:res9: scala.collection.immutable.Map[String,Array[String]] = Map(reba -> Array(reba), henmei -> Array(henmei), hunter -> Array(hunter), henchou -> Array(henchou), hello -> Array(hello, hello))

          需求2:将arr进行单词计数wordcount

           arr.flatMap(_.split(" ")).groupBy(x => x).map(x => (x._1,x._2.length))

          //结果:res12: scala.collection.immutable.Map[String,Int] = Map(reba -> 1, henmei -> 1, hunter -> 1, henchou -> 1, hello -> 2)

    6)sortBy(排序)

     命令行操作:val arr = Array("hello hunter henchou","hello reba henmei")

      需求:将arr进行单词计数并按照降序排序:

        arr.flatMap(_.split(" ")).groupBy(x => x).map(x => (x._1,x._2.length)).toList.sortBy(x => x._2)

        //结果:res16: List[(String, Int)] = List((reba,1), (henmei,1), (hunter,1), (henchou,1), (hello,2))

      注意:arr数组进行完groupBy后时Map集合,而Map集合不支持sortBy方法,必须将其用toLis或toArrayt转为List集合或Array数组再进行排序。

二、集合

  1.集合的分类:1)可变集合(mutable)

         2)不可变集合(Immutable)

  2.集合的定义:

    1)定义不可变集合:val s = List(1,3,5)

      不可变集合元素不可修改,长度也不能改变(即不能添加元素)

    Scala-Unit4-Scala数组/集合

    可以通过命令"scala.collection.immutable."查看所有不可变集合

Scala-Unit4-Scala数组/集合

    2)定义可变集合:定义可变集合前必须导入可变集合的包

      import scala.collection.mutable._

      val s = ArrayBuffer(2,4,6)

      可变集合可以修改集合元素,也可以添加元素

    Scala-Unit4-Scala数组/集合

    可以通过命令”scala.collection.mutable.“查看所有可变集合

  Scala-Unit4-Scala数组/集合

  3.集合的部分方法

  方法名   方法作用

  head      取头元素

  tail       取尾元素(除了头全是尾元素)

  ::       在部分集合头部加入元素(如List,Nil,可以同时添加多个元素)

  +       字符串的拼接

  .+:       在集合头部追加元素

  .:+       在集合尾部追加元素

  ++/++:/:::  两个集合相加合并

  count     统计个数

  filter    过滤

  sortBy   排序(按照集合中某一个元素进行升序或降序排序)

  sortWith   排序(按照条件给定的对应两个元素进行排序)

  grouped   分组(按照条件数字将集合分组,如条件为2,则两两分组)

  fold     折叠

  foldLeft    左折叠(同fold)

  foldRight  右折叠(初始值在右,按照从右到左的顺序进行计算)

  reduce     聚合

  aggregate  先局部聚合再全局聚合(分布式优化的方式,它底层调用的是flodLeft)

  zip      拉链

  sum    一个集合求和

  **举例如下:

    val l1 = List(4,3,5,1,9)

    val l2 = List(("h",2),("r"4),("m",8))

    val l3 = List(1,2,3,4,5)

    var l4 = List(3)

    1)取出集合l1中的头元素和尾元素

      l1.head //4  l1.tail  //3,5,1,9

    2)算出集合l1与l3中大于4的元素个数

      l1.count(x => x>4)  //2

      l3.count(x => x>4)  //1

    3)将集合l1中大于等于5的元素取出成为一个新的集合

      l1.filter(x => x>=5)  //(5,9)

    4)新定义集合l5等于集合l4头部添加元素1,在尾部添加元素4

      var l5 = l4.+:1    l5 = l4.:+4

    5)将集合l2按照每个元素中的数字进行倒叙排序

      l2.sortBy(x => - x._2)  l2.sortWith((x,y) => x._2 > y._2)

    6)将新的集合l5分别进行左折叠和右折叠相减,初始值都为2

      l5.fold(2)(_ - _)    //-6

      l5.foldRight(2)(_ - _)  //0

    7)将集合l3与集合l1进行拉链

      l3.zip(l1)

    8)将集合l1、l3、l4进行相加形成新集合   

      l1:::l3:::l4

  4.部分特殊集合

    1)Nil:空列表

      在空列表前加入多个元素: 1::2::3::Nil

    2)Set集:无序的、不可重复的、不可变的集合

      val s = Set(2,3,3,4)  //=>得到的集合为s = (2,3,4)

      s += 5  //先集合s添加元素5,语法错误

    3)HashSet:可变的集合

      val hs = collection.mutable.HashSet(2,3,4)

      hs += 5

      hs.remove(2)  //删除的是元素2,而不是索引为2的元素

    4)Map集:不可变  

      val m = Map[String,Int]("hello" -> 2,"reba" -> 8)

      m("hello")  //查看key为hello对应的value值

    5)HashMap:可变

      val hm = collection.mutable.HashMap[String,Int]()

      hm.put("hunter",32)  hm += "weight" -> 140  //添加元素kv对

      hm.get("hunter")    hm("hunter")      //查看hunter对应的值

      hm.remove("hunter")  hm -= "hunter"    //删除hunter对应的值

      hm.getOrElse("hunter",28)  //28  如果有值返回值,没有返回默认值,hunter对应的值被删除了

    

  5.元祖tuple:元祖中可以是任意元素

    val t = (2,"hunter",true,Unit)

    t._1    //2,取出元祖中第一个元素

    对偶元祖:有两个元素的元祖

    val t1 = ("hunter",18)

     t1.swap  //(18,"hunter"),将两个元素换位

    val t2 = Array(("reba",18),("hunter",32))  用右折叠计算hunter比reba大几岁?

    t2.swap

    t2.foldRight(0)(_._2 - _)