Scala-Unit4-Scala数组/集合

一、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.collection.immutable."查看所有不可变集合

　　　　2）定义可变集合：定义可变集合前必须导入可变集合的包

　　　　　　import scala.collection.mutable._

　　　　　　val s = ArrayBuffer(2,4,6)

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

　　　　

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

　　

　　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 - _)