scala 基础语法

val 定义变量值不可变
var 定义变量值可变
Any 是所有数据类型的祖宗 类似于object
Unit 类 写做() 相当于java中的 void
数组的定义 Array(1,2,3) 注意是小括号
for循环语法结构: for( i <- 表达式\数组\集合)
1 to 10 返回1到10这个区间 包含1也包含10
1 until 10 返回1到10这个区间 包含1但不包含10
reverse 反转
双层for循环带条件 for(i <- 1 to 3 ; j <- 1 to 3 if i != j ) 注意if前没有分号
yield 的用法 val i = for (a <- 1 to 3 )yield a 就相当于产生个返回值返回给i i 相当于一个可变数组

定义方法

 def  m1 (x : int)  : int = x * x
def是定义方法的关键字  m1是方法名 括号里面的是参数和参数类型  int是返回值类型可不写 x*x是函数体 

定义一个定长数组

val arr =new Array[ Int ] (4)  定义一个长度为4的定长数组
println(arr) 直接打印  ,打印的是地址值
println(arr.toBuffer)  打印的是ArrayBuffer(null, null, null, null)
val arr = Array(1,2,3)  直接定义一个有数据的数组
println(arr.toBuffer) 打印的是ArrayBuffer(1,2,3)
ptintln(arr(1))  就是打印索引为1的元素所以返回2   注意是小括号

可变数组

val ab=ArrayBuffer[Int]()   添加一个可变数组
    ab += 1    向数组中添加一个元素
    ab += (1,2,3)    向数组中添加多个元素
    ab ++=Array(1,2,3)    向数组添加一个 数组
    ab ++=ArrayBuffer(1,2,3)   向数组添加一个可变数组
    ab.insert(0,4,5,6)     向数组指定索引处添加元素    参数一是索引
    ab.remove(0,3)         删除数组中从什么索引开始删除几个  这边是从0索引开始删除3个

val arr=Array(1,2,3)
for(i <- arr) println(i) 遍历这个数组并且打印出来
for(i <- (0 until arr.length).reverse)println(arr(i))
意思就是返回0索引到数组长度然后用reverse反转

val arr = Array(2,1,6,4)
arr.sum  数组的求和
arr.max  数组的求最大值
arr.sorted  数组的排序

构建映射 Map

val s = Map("zs" -> 13 , "ls" -> 23 , "ww" -> 33)     第一种用箭头构建map的方式
val m = Map(("zl" , 43) , ("ds" , 53))                第二种用元组构建map的方式
m("zl")   获取映射中的值就像根据k获取v一样
直接创建Map集合是immutable包下的Map内容不可变  创建mutable.Map是可变Map集合
val m = mutable.Map ("de" -> 13 , "zhi" -> 23)  这是创建可变Map集合
m ("de")= 53   修改map中的值 
m +=("wg" -> 22)   用+= 向原来的Map中追加元素

创建元组

val t = ("de" , 2 , 2.2) 定义元组将多个元素用小括号包起来,元素之间用逗号分隔,元素类型可不同
val r = t._1 获取元组中元素,用元组名点下划线角标,角标是从1开始的跟索引不同
val t,(a,b,c) = ("zhi" , 3, 3.3)  也可以这样定义元组
println( a )   这样就直接打印出来了

将对偶集合转换成Map映射

val arr = Array(("de",13),("zhi",23))  创建一个对偶集合
arr.toMap   用点toMap就转换成Map映射了

拉链操作 用zip命令可以将多个值绑定在一起

val s=Array(1,2,3)          创建一个数组s
val n=Array("a","b","c")    创建一个数组n
val h=n.zip(s)               用数组n点zip数组s就创建了一个对偶集合h
println(h.toBuffer)          toBuffer打印对偶就和h
println(h.toMap)              toMap将对偶结合转成Map映射打印

函数的定义 map做映射(动词) filter方法进行过滤

val f = (x:Int) => x*x     f接受函数运算后的值  括号里面写参数和参数类型可多个  x*x是函数体
val arr = Array(1,2,3)  创建一个数组   arr.map就是调用map方法做映射
arr.map(f)   返回的就是Aarray(1,4,9)  nap是一个方法参数是一个函数,内部进行for循环
val n = (x : Int) => x % 2 != 0   定义一个过滤的方法  这里是过滤出来奇数
val m = arr.filter(n)       返回的就是arr数组中所有的奇数

flatten 压平就是炸裂的意思
flatMap() 切割再炸裂
groupBy 分组
.toLowerCase 都转换成小写
toList 变成list集合就可以有排序的方法了
sortBy 排序
.reverse 倒序

小练习

val lines = Array("spark,hadoop,Flink,spark", "Spark,flink,spark,hadoop", "spark,flink,hive")
    //val s = lines.map(i => i.split(","))//将里面的三个元素一个一个拿出来做切割切割之后生成三个数组在数组里面
    //就成这样了Array(Array(spark,hadoop,Flink,spark),Array(Spark,flink,spark,hadoop),Array(spark,flink,hive))
    //val f = s.flatten  //再用flatten方法把内层数组炸裂开
    //就成这样了Array(spark, hadoop, Flink, spark, Spark, flink, spark, hadoop, spark, flink, hive)
val str = lines.flatMap(i => i.split(","))//这个方法可以同时完成上面两个操作切割炸裂
//    //就成这样了Array(spark, hadoop, Flink, spark, Spark, flink, spark, hadoop, spark, flink, hive)
//    val tu = str.map(i => (i, 1))//将里面的每一个元素做运算加1都变成一个元组
//    //就成这样了Array((spark,1), (hadoop,1), (Flink,1), (spark,1), (Spark,1), (flink,1), (spark,1), (hadoop,1), (spark,1), (flink,1), (hive,1))
//    val st = tu.groupBy(i => i._1)//根据元组的第一个元素进行分组就是元素后面跟相同的元组的集合 的对偶元组
//    val stri = st.map(i => (i._1, i._2.length))//再将这个元组的一元组作为k,第二个元素的长度作为v,就求出每个的个数了
//    val tuples = stri.toList.sortBy(i => i._2).reverse//再将他变成list集合调用sortBy方法排序.reverse倒序
val string = str.groupBy(i => i.toLowerCase)//将得到的单词分组且转成小写
val stringTo = string.map(i => (i._1, i._2.length))//将对偶元组元素一为k元素2的长度为v
val tuples = stringTo.toList.sortBy(i => i._2).reverse//转换成list集合再sortBy排序reverse降序
println(tuples)
val tuples1 = lines.flatMap(i => i.split(",")).groupBy(i => i.toLowerCase).map(i => (i._1, i._2.length)).toList.sortBy(i => -i._2)
println(tuples1)