scala进阶

1.集合
Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质
在Scala中集合有可变（mutable）和不可变（immutable）两种类型(两个不同的包)， 包的全局路径：scala.collection.immutable默认使用的是该包中的集合如果想使用可变的集合，就需要导包scala.collection.mutableimmutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）使用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型。

2.数组
1.长度可不可变
Array 长度不可变（不能添加元素），内容可变（可改变元素值）
ArrayBuffer 长度内容都可变

Nothing是所有类型的子类

scala> var arr = Array[Nothing]()
arr: Array[Nothing] = Array()

Null的值是空null
通过New关键字创建的数组必须指定数组类型和数组长度

scala> var arr = new Array(2,5,3)
<console>:11: error: too many arguments for constructor Array: (_length: Int)Array[T]
       var arr = new Array(2,5,3)
                 ^
scala> var arr = new Array[Int](2)
arr: Array[Int] = Array(0, 0)

+= -=能向数组添加或删除单个元素或多个元素，添加多个元素格式：(2,5,3)
++= –=能向数组添加或删除一个数据，但不能添加单个或多个元素
insert(参数1，元素)：参数1是向数组中插入元素的起始索引；
remove(参数1，参数2)：参数1是删除数组中元素的起始索引；参数2是删除的个数

import scala.collection.mutable.ArrayBuffer

object Day02 {
  def main(args: Array[String]): Unit = {
    val arr = Array("speak","load","sky")
    println(arr(2).toString)

    val arr1 = ArrayBuffer[Int]()
    arr1 += 6
    arr1 += (6,8)
    arr1 += 6
    arr1 --= Array(8,6)
    arr1 ++= ArrayBuffer(8,6,2)
    arr1.remove(2,4)
    arr1.insert(0,5,6)
    println(arr1)
  }
}

2.遍历

scala> var arr4 = ArrayBuffer[Int](1,2,5,8,9,7,6,3)
arr4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 5, 8, 9, 7, 6, 3)

scala> for(i <- arr4) print(i+" ")
1 2 5 8 9 7 6 3 
scala> for(i <- 0 until arr4.length) print(arr4(i)+" ")
1 2 5 8 9 7 6 3

数组反转两种方式

scala> for(i <- (0 until arr4.length).reverse) print(arr4(i)+" ")
3 6 7 9 8 5 2 1 
scala> for(i <- arr4.length-1 to (0,-1)) print(arr4(i)+" ")
3 6 7 9 8 5 2 1 

3.转换

import scala.collection.mutable.ArrayBuffer

object Day02 {
  def main(args: Array[String]): Unit = {
    var arr = ArrayBuffer[Int](1,2,5,8,9,7,6,3)

    var res = for(i <- arr if(i%2==1)) yield i*10
    res.foreach(x =>print(x+" ")) //10 50 90 70 30

    println()
    /**
      * filter是过滤的一个方法，返回一个boolean类型的值
      * map取到数组每一个值做处理
      */
    var res2 = arr.filter(_%2==0).map(_*10).foreach(x=>print(x+" "))
    //20 80 60
  }
}

4.常用方法
++
++:
++=
++=:
+:
+=

+=:

–
–=
-=
/:
:+
:\
<<
addString
append
appendAll
apply
clear
clone
collect
count
distinct
drop
endsWith
equals
exists
filter
find
flatMap
flatten
fold
foreach
groupBy
grouped
hashCode
head
indexOf
insert
last
length
lift
map
max
min
readOnly
reduce
reduceLeft
reduceRight
remove
result
reverse
scan
size
slice
sortBy
sortWith
sorted
splitAt
startsWith
sum
tail
tails
to
toArray
toBuffer
toList
toMap
toSeq
toSet
toString
update
zip
zipAll
zipWithIndex
3.序列
List 内容长度均不可变
ListBuffer 内容长度均可变
1.不可变序列
创建List集合的两种方式：

val list1= List[Int](1,2,3)
scala> var list = List[Int](2,5,7)
list: List[Int] = List(2, 5, 7)
val list2 = 9::5::2::Nil
scala> var list = 7::6::5::Nil
list: List[Int] = List(7, 6, 5)

注意：:: 操作符是右结合的，该操作符就是将给定的头和尾创建一个新的列表
如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
注意：在Scala中列表要么为空,要么是一个head元素加上一个tail列表。

scala> list.head
res41: Int = 7

scala> list.tail
res43: List[Int] = List(6, 5)

scala> list.tail.tail
res44: List[Int] = List(5)

scala> list.tail.head
res45: Int = 6

scala> var list = 7::6::5::Nil
list: List[Int] = List(7, 6, 5)

//插入到lst1的前面生成一个新的List
+:左拼接

scala> var list2 = 2 :: list
list2: List[Int] = List(2, 7, 6, 5)

scala> var list3 = 4 +: list2
list3: List[Int] = List(4, 3, 7, 6, 5)

:+ 右拼接

scala> var list4 = list3 :+ 0
list4: List[Int] = List(4, 3, 7, 6, 5, 0)

scala> var list1 = List[Int](2,5,7)
list1: List[Int] = List(2, 5, 7)

scala> var list5 = list4 ++ list1
list5: List[Int] = List(4, 3, 7, 6, 5, 0, 2, 5, 7)

scala> var list6 = list4 ++: list1
list6: List[Int] = List(4, 3, 7, 6, 5, 0, 2, 5, 7)

scala> var list7 = list4 ::: list1
list7: List[Int] = List(4, 3, 7, 6, 5, 0, 2, 5, 7)

scala> var list8 = List.concat(list4,list1)
list8: List[Int] = List(4, 3, 7, 6, 5, 0, 2, 5, 7)

2.可变序列
ListBuffer
需要显示导包 import scala.collection.mutable._
创建ListBuffer的两种方式：
//导包

scala> import scala.collection.mutable._
import scala.collection.mutable._

//第一种方式

scala> val list0 = ListBuffer[Int](2,3,5)
list0: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 5)

//第二种方式

scala> val list1 = new ListBuffer[Int]
list1: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

//向序列中添加元素

scala> list1 += 3
res1: list1.type = ListBuffer(3)

scala> list1 += (6,5)
res3: list1.type = ListBuffer(3, 6, 5)

scala> list1.append(6,8)

scala> list1
res5: scala.collection.mutable.ListBuffer[Int] = ListBuffer(3, 6, 5, 6, 8)

//将list0中的数据追加到list中 注意：没有生成新表

scala> list1 ++= list0
res6: list1.type = ListBuffer(3, 6, 5, 6, 8, 2, 3, 5)

//将list中的数据追加到list0中 注意：生成了新表

scala> val list3 = list0 ++ list1
list3: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 5, 3, 6, 5, 6, 8, 2, 3, 5)

scala> val list4 = 112 +: list1
list4: scala.collection.mutable.ListBuffer[Int] = ListBuffer(112, 3, 6, 5, 6, 8, 2, 3, 5)

scala> val list5 =list4 :+ 110
list5: scala.collection.mutable.ListBuffer[Int] = ListBuffer(112, 3, 6, 5, 6, 8, 2, 3, 5, 110)

4.Map映射
map里面元素是k-v, 对偶元组，都是元组
在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变。
默认是immutable包下的map，
1.定义map

object Day02 {
  def main(args: Array[String]): Unit = {
    val map = Map((0,"jieke"),(1,"jimi"),(2,"hengri"))
    println(map)//Map(0 -> jieke, 1 -> jimi, 2 -> hengri)
    val map1 = Map(0 -> "jieke",1 -> "jimi",2 -> "henri")
    println(map1)//Map(0 -> jieke, 1 -> jimi, 2 -> hengri)
    val map2 = map1+(3 -> "hajia")
    println(map2)//Map(0 -> jieke, 1 -> jimi, 2 -> henri, 3 -> hajia)

    import scala.collection.mutable
    val map3 = new mutable.HashMap[Int,String]()
    val map4 = mutable.Map[Int,String]()

    map4 += ((0,"jirui"),(1,"kimi"))
    println(map4)//Map(1 -> kimi, 0 -> jirui)

    map4 +=(3->"hasi",4->"jieka")
    println(map4)//Map(4 -> jieka, 1 -> kimi, 3 -> hasi, 0 -> jirui)

    //只能添加一个
    map4.put(5,"cjhjs")
    println(map4)//Map(5 -> cjhjs, 4 -> jieka, 1 -> kimi, 3 -> hasi, 0 -> jirui)

    map4(6)="hsjcd"
    println(map4)//Map(5 -> cjhjs, 4 -> jieka, 1 -> kimi, 3 -> hasi, 6 -> hsjcd, 0 -> jirui)
  }
}

2.添加元素

3.获取映射值

println(map4.contains(6))//true
println(map4(6))//hsjcd
println(map4.get(6))//Some(hsjcd)
println(map4.get(5884))//None

//返回默认值

println(map4.getOrElse(552,"sdv"))//sdv

4.赋值修改值

map4(6)="new"
println(map4)//Map(5 -> cjhjs, 4 -> jieka, 1 -> kimi, 3 -> hasi, 6 -> new, 0 -> jirui)

map4.update(6,"newValue")
//map是不可变的时候会生成一个新的map
println(map4)//Map(5 -> cjhjs, 4 -> jieka, 1 -> kimi, 3 -> hasi, 6 -> newValue, 0 -> jirui)

5.删除元素

map4 -= (0)
println(map4)//Map(5 -> cjhjs, 4 -> jieka, 1 -> kimi, 3 -> hasi, 6 -> newValue)

map4 -= (6,3)
println(map4)//Map(5 -> cjhjs, 4 -> jieka, 1 -> kimi)

map4.remove(5)
println(map4)//Map(4 -> jieka, 1 -> kimi)

6.遍历

for(i <- map5) print(i)//(0,jieke)(1,jimi)(2,henri)(3,hajia)(4,jieka)
println()
for((k,v) <- map5) {
  print(k+" ")//0 1 2 3 4 
  //println()
  //print(v+" ")//jieke jimi henri hajia jieka
}

_是占位符，如果只需要遍历value，不需要遍历key，就可以用占位符

这里写代码片

7.获取keys和values

map5.keys.foreach(x =>print(x+" "))//0 1 2 3 4
map5.keySet.foreach(x =>print(x+" "))//0 1 2 3 4
map5.values.foreach(x =>print(x+" "))//jieke jimi henri hajia jieka

合并
使用 ++ 运算符或 mp.++() 方法来连接两个 Map，Map 合并时会移除重复的 key。

val map6 = map5.++(map2)
println(map6)
//Map(0 -> jieke, 1 -> jimi, 2 -> henri, 3 -> hajia, 4 -> jieka)
val map7 = map5 ++ map2
println(map7)
//Map(0 -> jieke, 1 -> jimi, 2 -> henri, 3 -> hajia, 4 -> jieka)

5.Set
1. 可变set
长度和值都不可变，set中的元素不能重复

val set1 = Set(1,5,6)//Set(1, 5, 6)
println(set1)

//set集合中不能有重复的值

val set2:Set[Int]= set1 + (4,5,8)
println(set2)//Set(5, 1, 6, 8, 4)

println(set2 - (5))//Set(1, 6, 8, 4)

val set3 = set2 ++ Set(7,9,3)
set3.foreach(x => print(x+" "))//5 1 6 9 7 3 8 4 

1. 不可变set
   可变Set中，remove方法，移除的是元素，而不是下标
   ListBuffer中，remove方法，参数是下标

import scala.collection.mutable.Set
val set4: mutable.HashSet[Int] = new mutable.HashSet[Int]()
val set5 = mutable.Set(1,2)
println(set4 += (4,6))//Set(6, 4)
//println(set4.add(7))
val newset = set4.add(7)
println(newset)//true
println(set5 += (4,5))//Set(1, 2, 4, 5)

println(set4 ++= set5)//Set(1, 2, 6, 7, 4)
println(set5.remove(2))



//转为不可变集合
val another = set5.toSet
println(another.getClass.getName)

6.Map和Option

7.集合常用方法
map 迭代集合中的每一个元素，然后按照自己的逻辑来修改元素
map方法操作集合中的每一个元素，返回值类型。
map方法有一个参数，是函数类型，该函数作用于集合的每一个元素上，对集合的每一个元素执行操作。有返回值。
map方法的内层返回值，是由函数的返回值决定的。
flatten 压平 如果有嵌套集合，就会把内层的嵌套去掉了
flatMap 先map 再flatten 先map 再压平
foreach 对每一个元素执行操作，相当于遍历 println 返回值是Unit

map和foreach的区别：
底层实现不同，map方法利用隐式转换实现的Builder,foreach底层使用的是iterator。
返回值不同，map返回值类型一般由函数返回值类型决定(map方法的参数就是一个函数)，foreach返回值为Unit
怎么选择？如果要求有返回值，就用map，如果是打印或者没有返回值的要求，是由foreach。

map
filter
过滤出满足条件的所有元素，并返回一个集合
find
过滤出满足条件的一个元素，并返回一个Option
如果说有结果值，返回值的是Some(元素值)，通过get方法来获取值
sorted
按元素的升序排序
sortBy
按照指定的条件排序
sortWith
接收两个参数，并进行比较
mapValues
类似于map，只是处理的是k-v类型中的v值，只能作用于map类型集合
groupBy
按照指定条件分组
grouped
按照指定元素个数进行分组
count
统计满足条件的元素个数
reduce *
元素归并
参数是一个函数，这个函数有两个参数 累加值 元素值 调用的就是reduceLeft
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(:::)

reduceLeft reduceRight
reduce底层调用的就是reduceLeft,只不过，reduce要求函数的输入类型和返回值类型必须一致，而reduceLeft,可以不一致。

fold foldLeft foldRight
fold有两个参数，第一个参数是默认值，第二个参数是一个函数，该函数有两个参数 累加值 元素值 调用的就是reduceLeft
fold 要求函数的2个输入参数类型必须一致，foldLeft 可以允许函数的2个输入参数类型不一致
示例：求平均值

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)

交集，并集 差集
intersect union diff
union是一个轻量级的方法
//比较常用的方法：先union，然后再分组
distinct 元素去重
mkString 把集合中的所有元素拼接成字符串
mkString(分隔符)
take(n) 获取集合中前几个元素 没有排序
slice(from,until) 截取元素，提取元素列表中的from 到until位置的元素
聚合 aggregate
val arr = List(List(1, 2, 3), List(2))