文章目录
1.scala概述2.面试理论scala语言有什么特点？什么是函数式编程？函数式编程有什么优点？说几个你知道的Scala的数据类型。（5个以上）java中，Object是所有引用类型的超类。在scala中，哪个是所有类的超类？scala中哪个关键字修饰的是不可变变量？scala中修饰的是可变变量的是哪个关键字？scala中的函数的两个特点？scala中方法和函数的区别和联系说说scala中常用的5种数据结构
3.基础语法3.1Scala变量3.2变量的数据类型3.3Scala中操作符
4.Scala中的表达式4.1If表达式4.2块表达式4.3for循环
5.Scala中函数6.Scala中方法定义7.方法和函数的区别8.Scala中数据结构8.1不可变Array（长度不可变）8.2可变数组ArrayBuffer （长度和数据都可变）8.3 不可变list 列表8.4 ListBuffer 可变list ：长度可变8.5 Tuple（元组） 不可变的 （长度和数据都不可变）8.6Map(映射) 不可变Map8.7可变Map8.8Set(集合) 不可变Set8.9可变Set8.10 符号操作
9.集合API操作9.1单个Array的操作9.2两个Array的操作9.3 Array高阶操作
10.WordCount案例11.需掌握总结
1.scala概述
概念：Scala是既可以面向对象也可以面向函数的编程语言，多范式的编程语言。Scala是基于JVM的编程语言。Scala能够兼容Java的语法
面向对象：Scala是纯面向对象的语言。比如1+2： 1 是一个对象 + 方法 2是对象 方法的参数。在scala的世界中，每一个字符或者每一个值都是对象，每一个操作符方法操作面向函数：有两个基本点
函数是一个对象。函数和字符或者数值具有同等地位。函数可以赋值给变量、可以作为方法的参数、可以作为方法的返回值。数学f(x)=>y ：函数是输入数据到输出数据的映射。比如f（x）=>x*x 。x在这个函数处理过程中不能够改变。不可变变量 是安全。也是函数式编程的基石。
2.面试理论
scala语言有什么特点？
scala语言集成面向对象和函数式编程。
什么是函数式编程？
函数式编程是一种范式，将电脑的运算视作是函数的运算。
三种编程范式：面向对象、函数式、指令式
函数式编程有什么优点？
1.代码简洁，开发快速；2.接近自然语言，易于理解；3.易于并发编程"
因为Scala是函数式编程，变量强调不可变
说几个你知道的Scala的数据类型。（5个以上）
Byte、Short、Int、Long、Float、Double、Char、String、Boolean、Unit、Null、Nothing、Any
unit: 表示无，和java的void相同，用作不返回任何结果。unit只有一个实例，写成()null：空，只有一个实例值,nullnothing：是Scala的最底层，是任何其它类型的子类
当一个函数，我们确定没有正常的返回值时，可以用nothing来指定返回类型，这样有一个好处，就是我们可以把返回值(异常)赋给其它函数或者变量（兼容性）
java中，Object是所有引用类型的超类。在scala中，哪个是所有类的超类？
Any
scala中哪个关键字修饰的是不可变变量？
val
scala中修饰的是可变变量的是哪个关键字？
var
scala中的函数的两个特点？
1.函数是一个对象，如： val变量名称=函数；2.函数是一个映射关系，即（输入数据列表）=>输出数据， x=>y。
scala中方法和函数的区别和联系
1、函数是一个对象，拥有方法；2、方法只能作为对象的成员存在；3、方法能转换成函数。
说说scala中常用的5种数据结构
Array（数组）、List（列表）、Tuple（元组）、Map (映射)、Set（集）
3.基础语法
3.1Scala变量
val ：修饰的是不可变变量 相当于java中final修饰的变量 （scala中推荐使用这种变量）var : 修饰的是可变变量
注意：变量的数据类型可以省略。变量的数据类型由值的数据类型推导而来。scala中变量是强类型
val name
:String="itcast"
val name2
="itcast"
var age
:Int=20
var age2
=30
age
=30
3.2变量的数据类型
Scala中数据类型跟Java中数据类型一致
整型：Int Byte Shot Long Char浮点：Float Double布尔：Boolean字符串：Stringscala中以上的数据类型全是对象 相当于java中包装类型
插值器的使用
val name = "小王王"
val age = 20
val nameAge = s"${name}:${age}"
val nameAge2 = s"$name:$age"
val nameAge3 = name + age
val nameAge4 = s"小王王 $age"
println(nameAge)
println(nameAge2)
println(nameAge3)
println(nameAge4)
stripMargin:整洁对齐字符串
val str2 =
"""
|sfdsfd
|sfsfdsfdsf
|sfdsfsdfdss
""".stripMargin
println(str2)
3.3Scala中操作符
算数运算符 + - * / % 等比较运算符 > < >= <= ==逻辑运算符 && || !位运算 >> <<以上运算符跟java中运算符功能一致。以上所有的符号都是方法
val add
=1.+(2)
val add2
=1+2
println
(add
)
4.Scala中的表达式
4.1If表达式
if表达式是具有返回值的
val 变量名称=if(布尔表达式){
业务逻辑
}else if(布尔表达式){
}else{
}
val score=90
val isOk=if(score>=90) "合格" else "不合格"
val isVar=if(score>0) score else "ERROR"
val myFeel=if(score>95) "很高兴"
println(isOk)
println(isVar)
println(myFeel)
//1.if可以返回不同的数据类型，if返回值变量的类型跟返回值数据类型有关
//2.如果if没有返回值，缺省的返回“（）”
4.2块表达式
概念：使用花括号括起来的表达式并且具有返回值
格式：val 变量名称={表达式}
val h = 20
val w = 30
val area = {
h * w
}
//周长
val girth={
2*(h+w)
}
println(area)
println(girth)
应用场景：
1.方法内部，代码内聚
2.用作初始化
4.3for循环
不带返回值的
for(变量名称 <- 集合/数组/等){
循环体
}
val list = new util.ArrayList[String]()
list.add("熟悉Hadoop、spark等分布式数据处理工具")
list.add("熟悉Hadoop,spark,storm等计算平台")
list.add("熟悉Hadoop、hive、Spark、flink、presto等")
list.add("熟练掌握Linux Shell、Flume、Kafka、Redis等相关技术")
/**
* for(变量名称 <- 集合/数组/等){
* 循环体
* }
* 通过角标访问的形式遍历每个元素
*/
for(index <- 0 to list.size()-1){
println(list.get(index))
}
for(index<-0 until list.size()){
println(list.get(index))
}
// to 是闭区间 包含 0 to 5
// until 是开区间 不包含 0 to 5
for(变量名称 <- 集合/数组 if 条件表达式* ){
循环体
}
//遍历数据并且过滤出只包含hadoop单词的数据 并且包含storm
/**
* for(变量名称 <- 集合/数组 if 条件表达式* ){
* 循环体
* }
*/
val list = List[String]()
val newlist = list :+ "熟悉Hadoop、spark等分布式数据处理工具" :+ "熟悉Hadoop,spark,storm等计算平台" :+ "熟悉Hadoop、hive、Spark、flink、presto等" :+ "熟练掌握Linux Shell、Flume、Kafka、Redis等相关技术"
for(item <- newlist if item.contains("Hadoop") if item.contains("spark")){
println(item)
}
嵌套循环
for(变量名称 <- 集合/数组 if 表达式;变量名称 <- 集合/数组 if 表达式){
循环体
}
val listHadoop = new ListBuffer[String]()
listHadoop += "mapreduce"
listHadoop += "hdfs"
listHadoop += "yarn"
val listJava = new ListBuffer[String]()
listJava += "JavaSE"
listJava += ("JavaWeb")
listJava += ("javaEE")
println(listHadoop.toBuffer)
println(listJava.toBuffer)
println()
val map = Map("hadoop"->listHadoop, "java"->listJava)
for((k, v) <- map){
for(i <- v){
print(k + " " + i + "\n")
}
}
println()
for((k, v) <- map; i <- v){
print(k + " " + i + "\n")
}
/**
* hadoop
* ----mapreduce
* ----hdfs
* java
* ----JavaSE
* ----JavaWeb
* ----javaEE
* 需求：遍历出所有叶子节点
*
* for(变量名称 <- 集合/数组 if 表达式;变量名称 <- 集合/数组 if 表达式){
* 循环体
* }
* 步骤：
* 1. 拿到map key
* 2. 循环遍历key值 拿到key对应的list
*/
问题：key 是val 不变变得。for每次循环的时候都会重新创建key
注意：凡是省略val或者var的地方，默认的都是val变量
有返回值
for循环表达式 可以具有返回值。集合中的每一个元素都会进行业务逻辑处理，最终返回新的集合
val 集合名称=for(变量<-集合/数组/表达式) yield 业务逻辑
val goods = new util.ArrayList[Int]()
goods.add(100)
goods.add(50)
goods.add(25)
//val 集合名称=for(变量<-集合/数组/表达式) yield 业务逻辑
//实现95折
val newGoods = for (index <- 0 until goods.size()) yield goods.get(index) * 0.95
for (g <- newGoods) {
println(g)
}
5.Scala中函数
函数两个基本点：
函数是一个对象 val 变量名称=函数函数是一个映射关系 （输入数据列表）=>输出数据 x=>y
val 变量名称=（输入数据列表）=>{输出数据}
//val 变量名称=（输入数据列表）=>输出数据
//使用：val 返回值名称=变量名称（参数列表）
// 加法
val add=(X:Int, Y:Int) => X+Y
println(add(5, 5))
//求平方函数
val square = (x: Int) => x*x
val res = square(5)
println(res)
println(square.toString()) // <function1>
注意：函数的输入参数都是默认都是val修饰的
//求面积的函数
val area=(h:Int,w:Int)=>h*w
println(area(10,20))
println(area.toString()) //function2
//求立方
val c=(h:Int,w:Int,len:Int)=>h*w*len
println(c(1,2,3))
// 等同于
val cube:Function3[Int,Int,Int,Int]=(h:Int,w:Int,len:Int)=>h*w*len
println(cube(1,2,3))
// 等同于
val cube:（Int,Int,Int）=>Int =(h:Int,w:Int,len:Int)=>h*w*len
println(cube(1,2,3))
注意：函数都是继承自FunctionN 其中N代表就是参数的个数 N的最大值22。
6.Scala中方法定义
格式：def 方法名称
(方法参数
)：返回值数据类型
={
方法体
}
def
add(a
: Int
, b
: Int
) = a
+ b
def
add(x
:Int
, y
:Int
) = {
var s
= x
+ y
s
}
7.方法和函数的区别
函数是一个对象，拥有方法方法只能作为对象的成员存在方法转换成函数（提升方法级别）
格式： val 变量名称= 方法名称 _ //将方法通过 _ 转换成函数
//将sum转换成function
val a = add _
println(a) // <function2>
println(a.toString()) // <function2>
println(a(5, 5).toString()) // 10
8.Scala中数据结构
Scala学习5中数据结构
Array（数组）List（列表）Tuple（元组）Map (映射)Set（集）
以上数据结构Array、List、Map 、Set又可变和不可变之分
说明
不可变与java中String类型数据不可变是一致可变一般指的长度可变可变集合放在scala.collection.mutable包中不可变的集合放在scala.collection.immutable包中 以上数据结构 主要从增、删、改、查、遍历五个操作说明
8.1不可变Array（长度不可变）
赋值
arr[0] = value
声明格式：
//根据数组的长度创建数组
val 名称=new Array[数据类型](长度)
//根据初始化数据创建数组
val 名称=Array[数据类型]（初始化数据，以逗号隔开）
注意：不可变数组一旦声明 长度不可变，数据可以改变
val strArr=new Array[String](3)
strArr(0)="hadoop"
strArr(1)="spark"
strArr(2)="scala"
strArr(2)="storm" //重新赋值修改数据
for(str<-strArr){
println(str)
}
val strArr2=Array[String]("hadoop","spark","scala")
for(str<-strArr2){
println(str)
}
注意：strArr(2)：实际上是方法调用 apply方法
8.2可变数组ArrayBuffer （长度和数据都可变）
赋值
+= 添加一个或多个++= 添加一个array 删除
-= 删除一个或多个–= 删除一个array 修改
strArrBuffer(0)=value
声明格式：
val 名称
=new ArrayBuffer
[数据类型
](长度
)
val 名称
=ArrayBuffer
[数据类型
]（初始化数据，以逗号隔开）
val strArrBuffer
=new ArrayBuffer
[String]
val strArrBuffer2
=ArrayBuffer
[String]("hadoop","scala","spark")
strArrBuffer2
+="mapreduce"
strArrBuffer2
+=("html","css")
strArrBuffer2
++=Array
("java","javaEE")
strArrBuffer2
-="java"
strArrBuffer2
-=("html","mapreduce")
strArrBuffer2
--=Array
("hadoop","scala")
strArrBuffer2
(0)="storm"
for(str
<-strArrBuffer2
){
println
(str
)
}
不可变变量指的是val 修饰的变量不能被重新赋值
不可变数组 指定数组的长度不可变
8.3 不可变list 列表
list：以链表形式存在的集合不可变list
数据和长度都是不可改变，相当java String，对list的任何操作都会产生新的list
添加
添加元素：
头部增加一条数据： “ :: ” " +: "
尾部添加一条数据： “ :+ ”
添加list：
头部： “ ::: ” " ++:"
尾部添加: " ++ "
删除
list.drop(2) // 左侧删除两个list.dropRight(2) // 右侧删除两个
修改
list.updated(0,“zookeeper”)
格式
: val 名称
=List
[数据类型
](初始化数据，以逗号隔开
)
补充：
val 名称
=item1
::item2
::tiem3
::Nil
val hadoopList
= List
[String]("hadoop", "scala", "spark")
val stormList
= "storm" :: hadoopList
val kafkaList
= "kafka" +: stormList
val flinkList
= kafkaList
:+ "flink"
val solorList
=List
("solor","flume"):::flinkList
val redisList
=List
("redis")++:solorList
val aiList
=redisList
++List
("AI")
val dropList
=aiList
.drop
(2)
val dorpList2
=dropList
.dropRight
(2)
val zkList
=dorpList2
.updated
(0,"zookeeper")
println
(zkList
(2))
for (item
<- zkList
) {
println
(item
)
}
8.4 ListBuffer 可变list ：长度可变
添加：
元素：+=List集合：++= 删除：
元素：-=List集合：–=
格式：
val 名称=new ListBuffer[数据类型]（长度）
val 名称=ListBuffer[数据类型]（初始化数据）
val listBuffer=ListBuffer[String]("hadoop","scala","spark")
//增加
listBuffer+="java"
listBuffer+=("javaEE","Flume")
listBuffer++=List("redis","kafka")
//删除操作
listBuffer-="Flume"
listBuffer-=("hadoop","scala")
//修改操作
val list=listBuffer.updated(0,"flink")
//查询
println(listBuffer(0))
//遍历
for(item <- list){
println(item)
}
问题：空列表
val 名称=item1::item2::tiem3::Nil 问题2： “storm” :: hadoopList 说明 :: 实际上list的方法，但是看起来像字符串的方法
凡是以“：”结尾的方法，其作用于“：”右侧 问题3：List[Int],Array[Int] 这两种集合都能装Int类型的数据，需求，如果同时需要装多种数据类型的数据？
8.5 Tuple（元组） 不可变的 （长度和数据都不可变）
tuple 声明之后 不但长度不能变 元素也不能变
概念：tuple就是使用（）括起来的不同数据类型的集合
格式：val 名称=（不同数据类型的数据）
注意：tuple是不可变的 （长度和数据都不可变）
//tuple应用场景
// 接受具有多个返回值方法的返回值
def getArrayList(){
val arr=Array("hadoop","spark")
val list=List(30,60)
(arr,list)
}
def main(args: Array[String]): Unit = {
//val 名称=（不同数据类型的数据）
val t=("hadoop",100,99.9,true)
//访问 通过角标 从1开始
println(t._1)
println(t._2)
println(t._3)
println(t._4)
println(t.getClass) //Tuple4
println("---------")
val (arr,list)=getArrayList()
for (a<-arr){
println(a)
}
println("---------")
for(l<-list){
println(l)
}
}
说明：Tuple类型：都是TupleN N<=22
8.6Map(映射) 不可变Map
格式：val 名称=Map[key数据类型，value数据类型](key->value *)
格式：val 名称=Map[key数据类型，value数据类型](（key，value） *)
val tuple2="name"->"dddf" //("name","dddf")
//格式：val 名称=Map[key数据类型，value数据类型](key->value *)
val personMap=Map("name"->"itcast","age"->10,"sex"->"man")
val personMap2=Map(
("name","itcast")
)
//查询map中元素
println(personMap.get("name").get) // Some 有值 None 没有
println(personMap.get("salary"))
println(personMap.getOrElse("salary","20K"))
println("---------------------------")
println(personMap("name"))
//增加
// +
val salaryMap=personMap + ("salary"->"10K","dept"->"Java")
println(salaryMap)
println("---------------------------")
//删除 -
val ageMap=salaryMap - ("age","sex")
println("ageMap:"+ageMap)
println("---------------------------")
val newSalaryMap=ageMap+("salary"->"20K")
println("newSalaryMap:"+newSalaryMap)
println("---------------------------")
//遍历map
for((k,v)<-personMap2){
println(k+"\t"+v)
}
//第二种遍历方式
for(t<-personMap){
println(t._1+"\t"+t._2)
}
map的get和java中的不同, 多包了一层some是为了解决空值的问题
8.7可变Map
导包 scala.collection.mutable
格式：val 名称=mutable.Map[key数据类型，value数据类型](key->value *)
格式：val 名称=mutable.Map[key数据类型，value数据类型](（key，value） *)
val map=scala.collection.mutable.Map("hadoop"->30,"scala"->20,"spark"->50)
//增加 +=
map+=("java"->10,"hadoop"->15)
//删除 -=
map-=("spark","scala")
//遍历操作
for((k,v)<- map) println(k+"\t"+v)
8.8Set(集合) 不可变Set
Set特点：
无序 （输出顺序与输入顺序无关） 唯一（不能存在重复元素）
格式：val 名称=Set[数据类型](初始化数据)
//val 名称=Set[数据类型](初始化数据)
val set=Set[Int](1,2,2,4,10,6,8,9)
//增加 +
val newSet=set+(11,12)
//删除 -
val newSet2=newSet-(1,2)
//遍历
for(s<-newSet2) println(s)
val set2=Set[Int](3,4,6,5,7)
println("----------------")
//两个set的并集 ++
val bingSet=set++set2
println(bingSet)
println("----------------")
//交集 “&”
val jiaoSet=set & set2
println(jiaoSet) //4,6
//差集操作 &~
val chaSet=set &~ set2
println(chaSet) //1,2,10,8,9
8.9可变Set
导包 scala.collection.mutable
格式：val 名称=mutable.Set[数据类型](初始化数据)
val set = mutable.Set("hadoop", "scala", "spark")
//增加 +=
//删除 -=
set += "java"
set += ("javaee", "flume")
set -= "scala"
set -= ("spark", "hadoop")
//更新
set.update("kafka",true)
set.update("redis",false)
//遍历
for (s <- set) {
println(s)
}
8.10 符号操作
对于不可变的集合：+ - ++ +: :: :+ ::: ++: :++对于可变集合：+= ++= -= --=连个set的操作符号： ++（并集） &~（差集） &（交集）
9.集合API操作
以Array数组为例操作API
9.1单个Array的操作
val arr=Array(1,3,5,10,6,8,3,3)
//求和
println(arr.sum)
//最大值
println(arr.max)
//最小值
println(arr.min)
//去重复操作
println(arr.distinct.toBuffer)
//排序 默认升序
println(arr.sorted.toBuffer)
//倒序操作
println(arr.sorted.reverse.toBuffer)
9.2两个Array的操作
val arr=Array(1,3,5,10,6,8,3,3)
val strArr=Array("hadoop","spark","scala","flume")
//拉链操作 zip
val zipArray=strArr.zip(arr)
println(zipArray.toBuffer)
// ArrayBuffer((hadoop,1), (spark,3), (scala,5), (flume,10))
//zipAll
val zipAllArray=strArr.zipAll(arr,"itcast",100)
println(zipAllArray.toBuffer)
// ArrayBuffer((hadoop,1), (spark,3),
// (scala,5), (flume,10), (itcast,6), (itcast,8), (itcast,3), (itcast,3))
//扁平化
val arrArray=List(
Map("name"->"zs"),
Map("age"->18),
Map("score"->95.5)
)
//把二维数组压扁成一维数组
println(arrArray.flatten.toBuffer)
// ArrayBuffer((name,zs), (age,18), (score,95.5))
9.3 Array高阶操作
foreach
val arr = Array("hello", "hive", "spark", "hadoop")
arr.foreach(x => println(x))
val printFun = (str: String) => println(str)
arr.foreach(printFun)
arr.foreach((str: String) => println(str))
map
// map操作 将集合中每个元素都进行函数操作 转换成型的集合
val arr = Array("hello", "hive", "spark", "hadoop")
val res = arr.map(x => x+" hello")
println(res.toBuffer) // ArrayBuffer(hello hello, hive hello, spark hello, hadoop hello)
filter
// 过滤操作 过滤出包含h字符的元素
val arr = Array("hello", "hive", "spark", "hadoop")
val res = arr.filter(x => x.contains("h"))
println(res.toBuffer) // ArrayBuffer(hello, hive, hadoop)
flatMap
// 将数组中的数据进行分割 按照空格分割 合并成一个数组
// 扁平化
val arr = Array("hadoop mapreduce hdfs", "hive hadoop mapreduce")
val res = arr.flatMap(x => x.split(" "))
println(res.toBuffer) // ArrayBuffer(hadoop, mapreduce, hdfs, hive, hadoop, mapreduce)
groupBy
//groupBy操作 分组操作
val arr = Array("hadoop mapreduce hdfs", "hive hadoop mapreduce")
val res = arr.groupBy(x => x.take(1)) // 以每一个的第一个单词分组
println(res.toBuffer)
reduce
//x：初始化变量 0 相当于 临时变量 sum
//y： 是数组中每个元素
val intArray = Array(1, 3, 5, 7, 8)
val result: Int = intArray.reduce((x: Int, y: Int) => x+y)
println(result)
mapValues
val map = Map(
"hadoop" -> Array(
("hadoop", 10),
("hadoop", 20),
("hadoop", 30)
),
"spark" -> Array(
("spark", 10),
("spark", 30)
),
"java" -> Array(
("java", 100),
("java", 150),
("java", 180)
)
)
/**
* 需求：hadoop->60 spark ->40 java ->430
*/
val resultMap= map.mapValues(x=>{
val intArray=x.map(t=>t._2)
intArray.sum
})
10.WordCount案例
简单版
val arr = Array("hello", "hello", "hello", "scala", "scala")
// 1.做词袋模型
val arr2 = arr.map(x => (x, 1))
// 2.根据key分组
val arr3 = arr2.groupBy(t => t._1)
// for((i, j) <- arr3; m <- j) println(i + " " + m)
// 3.统计词频
val arr4 = arr3.mapValues(as => {val inarr=as.map(t=>t._2); inarr.sum})
println(arr4.toBuffer)
// 合起来写
arr.map(x=>(x,1)).groupBy(t=>t._1).mapValues(arr=>{val intArr=arr.map(t=>t._2);intArr.sum})
读文件版
// 读文件
val str = Source.fromFile(new File("H:\\wgs1.txt")).getLines().mkString(",")
// 分割
val arrstrs = str.split(",")
// 词袋模型
val arr = arrstrs.map(x => (x, 1))
// 分组
val arr2 = arr.groupBy(x => x._1)
// 词频统计
val arr3 = arr2.mapValues(as => {val inarr = as.map(t=>t._2); inarr.sum})
println(arr3)
// 合起来写
Source.fromFile(new File("e:/a.txt")).getLines.mkString(",").split(",").map(x=>(x,1))
.groupBy(t=>t._1).mapValues(arr=>{val intArr=arr.map(t=>t._2);intArr.sum})
11.需掌握总结
// 1、声明一个不可变变量
val tmp = "come on"
// 2、声明一个可变变量
var tmp2 = "come on"
// 3、for、if、块表达式，各举一例，代返回值的
val score = 100
val res = if(score >= 60) "合格" else "不合格"
println(res)
val h = 20
val w = 20
var area = { h * w }
println(area)
var tmpres = for(i <- 1 to 9) yield i*2
println(tmpres)
// 4、声明一个函数
val add = (x:Int, y:Int) => x+y
println(add(5, 5))
// 5、声明一个方法
def add(x:Int, y:Int) = {
x + y
}
def add2(x:Int, y:Int) = x+y
// 6、方法转换成函数
val funadd = add _
// 7、五种数据结构可变、不可变，声明，添加元素，变量
Array
不可变：
val arr = new Array[]()
val arr = Array[](1, 2, 3)
添加： arr(0) = value
可变：
val arrbuff = new ArrayBuffer[]()
val arrbuff = ArrayBuffer[](1, 2, 3)
添加:
arrbuff += 10
arrbuff += (10, 10)
arrbuff ++= Array(10, 10)
List
不可变:
val list = List[]()
val list = value::value::Nil
添加：
val stormList = "storm" :: hadoopList // 头部添加元素
val kafkaList = "kafka" +: stormList // 头部添加元素
val flinkList = kafkaList :+ "flink" // 尾部添加元素
val solorList=List("solor","flume"):::flinkList // 头部添加list
val redisList=List("redis")++:solorList // 头部添加list
val aiList=redisList++List("AI") // 尾部添加list
可变：
val listBuff = ListBuffer[]()
添加：
listBuffer += "java"
listBuffer += ("javaEE","Flume")
listBuffer ++= List("redis","kafka")
Tuple
声明之后 不但长度不能变 元素也不能变
不可变：
val t=("hadoop", 100, 99.9, true)
println(t._1)
println(t._2)
println(t._3)
println(t._4)
Map
不可变Map
val 名称=Map(key->value, key->value)
val 名称=Map(（key，value）, （key，value）)
添加：
val salaryMap=personMap + ("salary"->"10K","dept"->"Java")
for((k,v)<-personMap2){
println(k+"\t"+v)
}
println(personMap.get("name").get)
println(personMap("name"))
可变Map
val 名称=mutable.Map(key->value *)
val 名称=mutable.Map(（key，value） *)
map+=("java"->10,"hadoop"->15)
Set
不可变Set
val 名称=Set()
val set=Set(1,2,4,10,6,8,9)
val newSet=set+(11,12)
并集 ++
交集 “&”
差集 &~
可变Set
val set = mutable.Set("hadoop", "scala", "spark")
set += "java"
set += ("javaee", "flume")
// 8、集合Api操作（sum、max。。。）
val arr=Array(1,3,5,10,6,8,3,3)
//求和
println(arr.sum)
//最大值
println(arr.max)
//最小值
println(arr.min)
//去重复操作
println(arr.distinct.toBuffer)
//排序 默认升序
println(arr.sorted.toBuffer)
//倒序操作
println(arr.sorted.reverse.toBuffer)
// 9、集合zip操作
val arr=Array(1,3,5,10,6,8,3,3)
val strArr=Array("hadoop","spark","scala","flume")
//拉链操作 zip
val zipArray=strArr.zip(arr)
println(zipArray.toBuffer) // ArrayBuffer((hadoop,1), (spark,3), (scala,5), (flume,10))
//zipAll
val zipAllArray=strArr.zipAll(arr,"itcast",100)
println(zipAllArray.toBuffer)
// ArrayBuffer((hadoop,1), (spark,3), (scala,5), (flume,10), (itcast,6), (itcast,8), (itcast,3), (itcast,3))
// 10、集合7中高级操作
foreach：遍历
map：将集合中的元素进行转换
filter：过滤，过滤包含h的字符
flatMap：将数组中的数据扁平化进行分割
groupBy
reduce： x：初始化变量 0 相当于 临时变量 sum y： 是数组中每个元素
mapValues：对map的值进行替换
// 11、wordcount案例
