Scala集合、数组、元组的使用

概述：该单元为scala中数组、元组、集合等操作的单元，包括数组、元组、集合的定义、添加、删除、修改、以及常用函数操作等重点。
（1）变长数组ArrayBuffer
在Sacla中，如果需要类似于JAVA中的ArrayList这种可变长度的集合类，则可以使用ArrayBuffer。
①　语法
//定义方式一
var 变量名 = ArrayBuffer数据类型

//定义方式二
var 变量名 = ArrayBuffer(数据，数据，数据)

②　案例

/**

• 变长数组
  */
  object ArrayBufferTest {
  def main(args: Array[String]): Unit = {
  //定义

//虽然定义了其长度，但是默认长度是0,没有任何内容，
//初始化情况下，无法使用下标获取或赋值
//可以不指定长度，数组长度不受限制
var ab = new ArrayBufferInt

//另一种定义方式

var ab = ArrayBuffer(5,4,5,76,1,90)

//在没有元素的情况下，无法使用下标赋值
ab(0) = 1  


//在头部添加数据
ab.+=:(1)

ab.+=:(2)

//在尾部添加数据

ab.+=(3)

println(ab.length)
println(ab)


//删除元素,根据下标来删除
ab.remove(0)


//移除末尾三个

ab.trimEnd(3)

//排序
//变长数组转化成定长数组
var arr = ab.toArray

Sorting.quickSort(arr)

println(ab)

//将数组变成字符串输出
println(arr.mkString(","))

//定长数组转化成变长数
 println(arr.toBuffer)   

}
}
③　坑点
变长数组使用长度定义时，其长度其实是0，此时不可以使用下标来赋值。
④　小结
ArrayBuffer的数组长度不受限制，使用长度定义时，其长度其实是0，此时不可以使用下标来赋值。

（2）不可变列表List
Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表具有递归的结构（也就是链接表结构）而数组不是。
①　语法
//定义方式一
var 变量名 = List(数据，数据，数据)

//定义方式二
var 变量名 = 数据::数据::数据::Nil

②　案例

/**

• 不可变list
  */
  object ListTest {
  def main(args: Array[String]): Unit = {

  //定义方式一
  var li = List(3,1,5,7,9)

//定义方式二
var list1 = 13::45::1::9::Nil

println(list1) 

 //获取值

println(li(0))

//添加单个元素操作
li = li.+:(0)

li = li.:+(10)

//两个list集合加法操作
println(li.:::(list1))
println(li ::: list1)

println(li.++(list1))

//修改元素
li = li.updated(0, 2)
println(li)


//删除元素
li = li.drop(2)

println(li)

//循环遍历一
for(i <- 0 until li.size){
  println(li(i))

}

//循环遍历二
for(i <- li){
println(i)
}

//循环遍历三
li.foreach(println(_))

//循环遍历四
li.map(println(_))

println(li)

//头 获取第一个元素

println(li.head)

//尾 获取除了第一个元素的其他元素

println(li.tail)

//排序 
//默认从小到大排序

println(li.sorted)

//自定义条件

println(li.sortBy( n =>{ -n }))

//自定义排序，根据元素和元素的比较进行排序

println(li.sortWith( (a,b) => { a > b } ))

var strli = List("11","2","20","108","3")

println(strli.sorted)

//reverse反转
println(strli.sortBy( s => { s }).reverse)

}
}

③　坑点
List添加元素或删除元素时会生成一个新的集合。
④　小结
List一旦创建，已有元素的值不能改变，可以使用添加元素或删除元素生成一个新的集合返回。

（3）可变列表ListBuffer
ListBuffer是可变列表，可以在原列表中添加或删除元素。
①　语法
//定义
var 变量名 = ListBuffer(数据，数据，数据)

②　案例

/**

• 可变list
  */
  object ListBufferTest {
  def main(args: Array[String]): Unit = {

  //定义
  var lb = ListBuffer(3,4,6,1,8,6,2,4,3,0)

  //添加元素
  //头部添加
  lb.+=:(0)
  lb.+=:(8)

  //尾部添加
  lb.+=(10)
  println(lb)

  //删除元素
  //根据下标删除
  lb.remove(1)

  //第一个参数是开始的下标，第二个参数是删除的个数
  lb.remove(1, 2)

  println(lb)

  //去重,会形成新的list，不会修改原来的集合
  var lb1 = lb.distinct

  println(lb1)
  }
  }
  ③　坑点
  使用ListBuffer时需要导入scala.collection.mutable.ListBuffer。
  ④　小结
  ListBuffer是可变列表，可以在原列表中添加或删除元素，其他的方法操作和list一致。

（4）Set集合
ListBuffer是可变列表，可以在原列表中添加或删除元素。
①　语法
//定义
var 变量名 = Set(数据，数据，数据)

②　案例

import scala.collection.SortedSet
//import scala.collection.immutable.Set

/**

• set集合
  */
  object SetTest {
  def main(args: Array[String]): Unit = {

  //定义 无序不可重复，默认情况下是不可变的
  var s = scala.collection.immutable.Set(3,1,5,7,98,0,1,2,4,4)
  // Set

  //增加
  s = s.+(10)
  s +10
  s = s + 10
  println(s)

  s += (20)
  s.+=(30)

  println(" <<<<<<<<<<<<<<<<<<")

  //删除
  s = s.-(10)

  //排序set
  var ss = SortedSet(3,4,5,7,81,20,24,6,3)

  println(s)
  println(ss)

  //查看集合中元素是否存在
  println(s(100))

  //遍历
  for(i <- s){
  println(i)
  }

//使用迭代器遍历
var it = s.iterator
while(it.hasNext){
println(it.next())
}
}
}

③　坑点
Set集合后面加上(元素)，是在判断集合中是否存在对应的元素，并非根据下标取值。
④　小结
Set集合是无序不可重复的。
Set集合默认情况下是不可变的，如果要变成可变Set需要导入import scala.collection.mutable.Set。

（5）Set集合
ListBuffer是可变列表，可以在原列表中添加或删除元素。
①　语法
//定义
var 变量名 = Map(键->值，键->值，键->值)

②　案例

import scala.collection.SortedMap

/**

• map集合
  */
  object MapTest {
  def main(args: Array[String]): Unit = {

  //定义,无序 默认是不可变的
  var m = scala.collection.mutable.Map(
  1 -> “宋江”,
  2 -> “卢俊义”,
  3 -> “吴用”,
  4 -> “公孙胜”,
  5 -> “关胜”,
  6 -> “林冲”)

  //获取
  // Some(宋江)
  // None 避免空指针异常
  println(m.get(10))

  //如果有匹配的值，则输出值，如果没有，则输出默认值
  println(m.getOrElse(1, “高俅”))

  // 如果没有匹配的值，则报错 NoSuchElementException
  println(m(10))

  //修改
  m = m.+(7 -> “秦明”)

  //不可变map不能使用
  m(1) = “及时雨”

  //删除
  m = m.-(7)
  println(m)

  //循环遍历
  var ks = m.keySet
  for(s <- ks){
  println(s + “,” + m(s))
  }

  for( (k,v) <- m){
  println(k + “,” + v)
  }

  //根据key的值来排序，默认从小到大
  var sm = SortedMap(
  4 -> “公孙胜”,
  1 -> “宋江”,
  2 -> “卢俊义”,
  3 -> “吴用”,
  5 -> “关胜”,
  6 -> “林冲”)

  println(sm)
  }
  }
  ③　坑点
  Set集合后面加上(元素)，是在判断集合中是否存在对应的元素，并非根据下标取值。
  ④　小结
  Map集合中的数据是键值对的，其中键是无序不可重复的。
  Map集合默认情况下是不可变的，如果要变成可变Map需要导入import scala.collection.mutable.Map。

4．【练习案例】
1.使用scala语言，创建一个Map集合，添加以下数据，并在控制台输出
唐家三少 37
天蚕土豆 29
无罪 39
月关 46
天使奥斯卡 42
骷髅精灵 37
跳舞 37
柳下挥 30
藤萍 37
何常在 42

2.使用scala语言，创建一个List集合，将下面每组数据以元组的方式存放到List集合中，并在控制台 输出
盗墓笔记 南派三叔
鬼吹灯 天下霸唱
明朝那些事儿 当年明月
三体 刘慈欣
解忧杂货店 东野圭吾
姑获鸟之夏 京极夏彦

object day03 {
def main(args: Array[String]): Unit = {

var map = Map(
  "唐家三少" -> 37,
  "天蚕土豆" -> 29,
  "无罪" -> 39,
  "月关" -> 46,
  "天使奥斯卡" -> 42,
  "骷髅精灵" -> 37,
  "跳舞" -> 37,
  "柳下挥" -> 30,
  "藤萍" -> 37,
  "何常在" -> 42)

    println(map)
      for((k,v) <- map){
        println( k + "\t" + v)
      }

      map.foreach(println(_))

var list = List(
  ("盗墓笔记", "南派三叔"),
  ("鬼吹灯", "天下霸唱"),
  ("明朝那些事儿", "当年明月"),
  ("三体", "刘慈欣"),
  ("解忧杂货店", "东野圭吾"),
  ("姑获鸟之夏", "京极夏彦"))
  
  println(list)

}
}
5．【能力提升】
将若干个不同个数的球类存放到List中，如何使用Map集合将球类个数分别统计？