scala编程

声明变量
val i = 1
var s = “hello”
val str : String = “1234”

常用类型
byte char short int long float double boolean(无包装类)

条件表达式
val x = 1
val y = if(x > 0) 1 else -1
val z = if(x > 1) 1 else “error”
val m = if(x > 2) 1相当于val m = if(x > 2) 1 else ()
val k = if(x < 0) 0 else if (x >= 1) 1 else -1

循环
for(i <- 1 to 10)
val arr = Array(“a”,“b”,“c”)
for(i <- arr)
for(i <- 1 to 3; j<- 1 to 3 if i != j) print((10*i+j)+" ")
val v = for(i <- 1 to 10) yield i * 10

定义方法和函数
def m1(x:Int,y:Int):Int = x * y
val f1=(x:Int,y:Int) => x + y

函数可以其他数据类型一样被传递和操作
def m2(f: (Int,Int) =>Int) = f(2,6)
val f2 = (x:Int,y:Int) => x - y
m2(f2)
def m1(f:(Int,Int) => Int):Int = {f(2,6)}
val f1=(x:Int,y:Int) => x + y
val f2=(x:Int,y:Int) => x * y
def main(args:Array[String]){
val r1 = m1(f1)
}

下划线
def m1(x:Int,y:Int):Int = x * y
val f1 = m1 _ 将方法转变成函数_

数组
定长数组
val arr1 = new ArrayInt 长度为8,元素为0
arr1.toBuffer 转变成数组缓冲

val arr2 = Array(“hadoop”,storm",“spark”)
print(arr2(2)) 使用()来访问元素

变长数组(数组缓冲)
val ab = ArrayBufferInt 变长数组
ab += 1
ab += (2,3,4,5)
ab ++= Array(6,7)
ab ++= ArrayBuffer(8,9)
ab.insert(0,-1,0) 插入元素
ab.remove(8,2)

遍历数组
val arr = Array(1,2,3,4,5,6)
for(i <- arr) 增强for循环
for(i <- (0 until arr.length).reversr) 0 until 10 生成一个包含0不包含10的区间

数组转换
val arr = Array(1,2,3,4,5,6)
val res = for(i <- arr) yield i * 2 yield生成一个新的数组
arr.map(_*2) 跟上面作用一样

val arr = Array(1,2,3,4,5,6)
val res = for(i <- arr if i % 2 == 0) yield i * 10
val res = arr.filter(_ % 2 == 0).map(_*2)

数组常用算法
val arr = Array(1,2,3,4,5,6)
arr.sum
arr.max
arr.sorted 排序

映射
val scores = Map(“tom” -> 1,“jerry” -> 2,“rose” -> 3) 使用箭头
val scores = Map((“tom”,1),(“jerry”,2),(“rose”,3)) 使用元祖
scores(“tom”) 获取值
scores.getOrElse(“thomas”,0) 如果映射中有值,返回值,没有返回默认值0

可变Map(导入mutable.Map包)
val scores = Map(“tom” -> 1,“jerry” -> 2,“rose” -> 3)
scores(“tom”) = 0 修改Map内容
scores += (“thomas” -> 4,“jack” -> 5)

元祖(对偶是元祖的最简单形式)
val t = (“hadoop”,2.58,123) 可以任意多个
val r1 = t._1 获取元祖中元素,元素脚标从1开始
val r2 = t._2

对偶集合转换成映射
val arr = Array((“tom”,1),(“jerry”,2))
arr.toMap 转换成映射

拉链操作
val scores = Array(1,2,3)
val names = Array(“tom”,“jack”,“rose”)
val ns = names.zip(scores) 如果两个数组的元素个数不一致,拉链操作后生成的数组为较小的那个数组的元素个数

集合(序列seq,集Set,映射Map)
不可变序列
val lst1 = List(1,2,3)
将0插入到lst1前面生成一个新的list
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0)
2个list合并成一个新的lsit
val lst6 = lst1 ++ lst0
将lst1插入到lst0前面生成一个新的集合
val lst7 = lst1 ++: lst0
将lst0插入到lst1前面生成一个新的集合
val lst8 = lst1.:::(lst0)

可变序列
val lst0 = ListBufferInt
val lst1 = new ListBuffer[Int]
lst1 += 1 追加元素
lst1.append(2)
lst0 ++= lst1 将lst1中的元素追加到lst0中,没有生成新的集合
val lst2 = lst0 ++ lst1 将lst0和lst1合并成一个新的ListBuffer,生成了一个新的集合

不可变set
val set1 = new HashSetInt
val set2 = set1 + 1 将元素和set1合并成一个新的set,原有set不变
val set3 = set1 ++ Set(2,3,4) set中元素不能重复
val set4 = Set(1,4,5) ++ set1

可变set
val set1 = new mutable.HashSetInt
set += 1 添加元素
set1.add(2) add等价于+=
set1 ++= Set(3,4,5)
set1 -= 5 删除一个元素
set1.remove(2) remove等价于-=

Map
val map1 = new mutable.HashMapString,Int
向map中添加数据
map1(“spark”) = 1
map1 += ((“storm”,2))
map1.put(“hadoop”,3)
从map中移除元素
map1 -= “storm”
map1.remove(“hadoop”)