object ImmutListTest {
  
 def main(args: Array[String]) {
 //创建一个不可变的集合
 val lst1 = List(1,2,3)
 //将0插入到lst1的前面生成一个新的List
 val lst2 = 0 :: lst1
 val lst4 = 0 +: lst1 
  
 //将一个元素添加到lst1的后面产生一个新的集合
 val lst6 = lst1 :+ 3
  
 val lst0 = List(4,5,6)

 //将2个list合并成一个新的List
 val lst7 = lst1 ++ lst0

val lst8 = lst1 ++: lst0

val lst9 = lst1 ::: lst0

val lst10 = List.concat(lst1,lst0)
  
  

// 列表反转

lst1.reverse

// 列表头元素

lst1.head

// 列表的尾列表
lst1.tail
}
}

import scala.collection.mutable.ListBuffer
  
  object MutListTest {

 def main(args: Array[String]) {
 //构建一个可变列表，初始有3个元素1,2,3
 val lst0 = ListBuffer[Int](1,2,3)
 //创建一个空的可变列表
 val lst1 = new ListBuffer[Int]
 //向lst1中追加元素，注意：没有生成新的集合
 lst1 += （4,6）
 lst1.append(5)
  
 //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个新集合
 val lst2 = lst0 ++ lst1

 //将lst1中的元素追加到lst0中， 注意：没有生成新的集合
 lst0 ++= lst1
  
 //将元素追加到lst0的后面生成一个新的集合
 val lst3 = lst0 :+ 5

 //将元素追加到lst0的前面

val lst4 = 5 +: lst0

// 去除元素
lb2 -= (1,3)
lb2 --= List(7,9)

lb2.remove(1,2) //去除元素 第一个参数是下标，第二个参数的个数

// 判断集合是否为空

Lb2.isEmpty()
}}

// 默认是immtable包下的Map

val mp1 = Map(("a",1),("b",2))
val mp2 = Map("a"->1,"b"->2)
// 添加元素之后生成新的map
val mp3 = mp2+("c"->1)

// 导包
  import scala.collection.mutable
  // 创建集合
  val mp4 = new mutable.HashMap[String,Int]()
  val mp5 = mutable.Map[String,Int]()

mp4 += ("e"->8, "f"->9)
mp4+= (("b1",121))
mp4.put("lyf",21)
mp4("nvshen")=18

// 合并时，相同的key元素会被覆盖
val colors1 = Map("nvshen" ->18,"nanshen" -> 35)
val colors2 = Map("bq" -> 40,"nvshen" -> 20)
var colors = colors1 ++ colors2

// import scala.collection.mutable.Map

import scala.collection.mutable

valmp2 = mutable.Map("a" -> 1)

// 定义一个数组
  val array = Array[Int](2,4,6,9,3)
  // map方法是将array数组中的每个元素进行某种映射操作, (x: Int) => x * 2 为一个匿名函数, x 就是array中的每个元素
  val y = array map((x: Int) => x * 2)
  // 或者这样写, 编译器会自动推测x的数据类型
  val z = array.map(x => x*2)
  // 亦或者, _ 表示入参, 表示数组中的每个元素值
  val x = array.map(_ * 2)
  
  println(x.toBuffer)
  
  
  println("--------分割线--------")
  
  // 定义一个数组
  val words = Array("hello tom hello jim hello jerry", "hello Hatano")
  
  // 将数组中的每个元素进行分割
  // Array(Array(hello, tom, hello, jim, hello, jerry), Array(hello, Hatano))
  val splitWords: Array[Array[String]] = words.map(wd => wd.split(" "))
  
  // 此时数组中的每个元素经过split之后变成了Array, flatten是对splitWords里面的元素进行扁平化操作
  // Array(hello, tom, hello, jim, hello, jerry, hello, Hatano)
  val flattenWords = splitWords.flatten
  
  
  // 上述的2步操作, 可以等价于flatMap, 意味先map操作后进行flatten操作
  val result: Array[String] = words.flatMap(wd => wd.split(" "))
  
  // 遍历数组, 打印每个元素
  result.foreach(println)

// 定义一个数组
  val words = Array("hello tom hello star hello sheep", "hello tao hello tom")
  
  words.flatMap(_.split(" ")) // 对数组中的每个元素进行切分, 并进行扁平化操作
 .map((_, 1)) // 将数组的每个元素转换成一个对偶元组, 元组的第二个元素为1
 .groupBy(_._1) // 对集合中的所有元素进行按单词分组, 相同单词的元组分到一组
 .mapValues(_.length) // 对每个key 的value集合进行求长度操作
 .toList // 将map 转换成List
  
// 实现方式二
  words.flatMap(_.split(" ")).groupBy(x => x).map(t => (t._1, t._2.length)).toList

object ImmutSetTest {

 def main(args: Array[String]) {
 // 默认是immtable包下的Set
  val set1 = Set (1,4,6)
  // 执行添加,删除的操作，都是生成了新的Set集合
  val s2: Set[Int] = set1 + (10,12)
set1 - (1)
  println(set1)

 // 查看set集合内容

set1.foreach(println)
  
 //set中元素不能重复
 val set3 = set1 ++ Set(5, 6, 7)
 val set0 = Set(1,3,4) ++ set1
 }

}

import scala.collection.mutable
  
  object MutSetTest {

 def main(args: Array[String]) {
   import scala.collection.mutable.Set // 可以在任何地方引入 可变集合
 val mSet = new mutable.HashSet[Int]()
 val mutableSet = Set(1,2,3)
  
 mutableSet.add(4)
  // mutableSet += 5
 mutableSet += (5,15)
 // 添加set集合
 mutableSet ++= Set(12,14)
  // mutableSet -= 4
 mutableSet -= (4,2)
  
 // remove方法，删除的不是下标，而是元素
 mutableSet.remove(2)
 println(mutableSet)
 // 转换为不可变集合
 val another = mutableSet.toSet
 println(another.getClass.getName) // scala.collection.immutable.Set
}

}

// Option是Some和None的父类
  // Some代表有（多例），样例类
  // None代表没有（单例），样例对象
  
  val mp = Map("a" -> 1, "b" -> 2, "c" -> 3)
  val r: Int = mp("d")
  
  // Map 的get方法返回的为Option, 也就意味着 rv 可能取到也有可能没取到
  val rv: Option[Int] = mp.get("d")
  
  // 如果rv=None时， 会出现异常情况
  val r1 = rv.get
  
  // 使用getOrElse方法，
  // 第一个参数为要获取的key,
// 第二个参数为默认值， 如果没有获取到key对应的值就返回默认值
  val r2 = mp.getOrElse("d", -1)
  
  println(r2)

val arr=Array("aa","bb","cc","dd")

arr.reduce((x,y)=>自定义操作)

自定义操作的方法，必须是x数据类型上支持的方法。x可以是任意类型

arr.reduce(_ + _)

arr.reduce(_ ++ _)

val lst = List(List("a"),List("b"),List("c"))

lst.reduce(_++_)

lst.reduce(_:::_)

val arr = Array(1,3,5,7,9)

reduce(_ - _) reduce((a,b)=>a-b)

false ---> true

a：累加值 b:元素值

1 1

3 1 3 1-3 -2

5 -2 5 -2 - 5 -7

7 -7 7 -7-7 -14

9 -14 9 -14 - 9 -23

(((((1)-3)-5)-7)-9) -23

reduce reduceLeft

(1-(3-(5-(7-(9))))) 5

reduce[A1 >: A](op: (A1, A1) => A1)

reduceLeft[B >: A](op: (B, A) => B)

deffold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1

def foldLeft[B](z: B)(op: (B, A) => B): B

示例：求平均值

val d1 = Array(("bj",28.1), ("sh",28.7), ("gz",32.0), ("sz", 33.1))
val d2 = Array(("bj",27.3), ("sh",30.1), ("gz",33.3))
val d3 = Array(("bj",28.2), ("sh",29.1), ("gz",32.0), ("sz", 30.5))

// 1,需要把数据组装到一起
val data1: Array[(String, Double)] = d1.union(d2).union(d3) // d1 union d2 union d3
//d1 ++ d2 ++ d3

// 2 分组 按照城市名称来分组
val data2: Map[String, Array[(String, Double)]] = data1.groupBy(t=>t._1)

// 统计
val data4 = data2.mapValues({
kv=>
// kv数据类型： Array[(String,Double)]
// t的数据类型是元组（String,Double）

})
println("--------111------------")
println(data4)


// 3 统计 拿到这几个月份的温度的总值，然后再求平均
val result: Map[String, Double] = data2.map {
t =>
// t (String,Array[(String, Double)])
val city = t._1
// foldLeft 第一个是累加值 第二个是元素值
val wendu: Double = t._2.foldLeft(0d)({
// total是Double a是(String, Double)
(total, a) =>
total + a._2
}) / t._2.length
(city, wendu)
}
println(result)