基本

和java 一样在jvm上工作；
有自动类型推断：定义常量用val，定义变量用var
常用类型：Byte,Char,Short,Int,Long,Float,Double,Boolean(无包装类)

逻辑

条件表达式虽然可以简写，但为了之后的可读可维护，还是按常用的，带大括号的写法吧

//块条件表达式
if （1>2） {
  println("true")
}else {
  println("false")
}
//可以有返回值
val a = if （1>2） {
   return 1
}else {
   return 2
}

for 循环 因为scalar是设计方向是面向函数式编程，so ,出现一些不同的循环

//1...10  1to10
for ( i <- 1 to 10) {
      println(i)
    }
//遍历数组
val arr = Array("a","b","c");
    for (i <- arr) {
      println(i)
    }
//遍历新增集合
val arr = for (i <- 1 to 10)yield i*2
    println(arr)
//高级遍历 （二重循环）
for (i<- 1 to 3 ; j<-2 to 5 if i==j ){
    println(i*j)
  }

数组

数组分为定长和不定长；
定长：new Array
补不定长：new ArrayBuffer
除了常用的+=添加数据外 还有++= 拼接数组
数组常用的方法：
求和sum
求最大值max
排序 sorted
反转 reverse
新构建数组 map()
过滤filter()

//注： arr 本身没有发生改变
    val arr = Array(1,3,7,8,5,4,2);
    var newArr =  arr.sorted.filter(_ % 2 == 0).map( _ * 2)
    println(newArr.toBuffer)
    println(newArr.sum)

函数

简单的说说函数和方法

//这是一个方法，需要传入一个函数，并将1，2赋值给函数
def  func( f:(Int,Int)=>Int):Int = {
      f(1,2)
    }
//这是一个函数，会将传入的参数相加
 val f1 = (x:Int,y:Int) => x + y;
//打印结果为3
println(func(f1))
//将方法转函数（面向函数），so 方法里还能继续传入方法（本质时将方法转为另一个函数）
val f2 = func _

集合

集合有序列List，集Set，映射Map , 同样分为可变和不可变

    //不可变序列
    val list = List(1,3,5)
    //在开头插入0,感觉都不易理解。。
    println(0::list)
    println(list.::(0))
    println(0+: list)//这个看起最有感觉吧
    println(list.+:(0))
    //在最后插入2
    println(list:+2)
    //2个集合合并
    val listt = List(2,4,6)
    println(list++listt)
    //倒插
    println(list.:::(listt))

    //可变序列
    //需要确定类型，防止追加未知数组
    val list = ListBuffer[Int](1,3,5);
    //or
    val list1 = new ListBuffer[Int];
    //追加 不生成新集合；+= 和 append的区别
    println(list1+=7)
    list1.append(9)
    println(list1)
    //追加数组
    println(list++=list1)
    //合并新集合
    println(list++list1)
    //追加生成新集合
    println(list:+ 11)
    println(list)

    //不可变set
    val set = new HashSet[Int]()
    //追加为新set
    val newSet = set+1
    //合并为新set
    println(set ++ newSet)
    println(set ++ Set(1,3,5))
    

    //可变set
    val set = new mutable.HashSet[Int]();
    println(set+= 1)
    set.add(3)
    println(set)
    //hash表排序
    println(set ++= Set(5,7))
    println(set -= 7)
    set.remove(5)
    println(set)

    //创建map映射 不可修改
    val map0 = Map("A"->1,"B"->2)
    println(map0)
    var map1 = Map(("A",1),("B",2))
    println(map1)
    //可修改map
    var map = new mutable.HashMap[String,Int]()
   //新增
    map("A") = 1
    println(map)
    map += (("B",2))
    println(map)
    map.put("C",3)
    println(map)
    //修改
    map("A") = 4
    //查询
    println(map.get("A"))
    //删除
    map -= "A"
    map.remove("B")
    println(map)


//泛型数组
    val tuple = (1,"string")
    println(tuple._2)
//数组切割
    val arr = Array("hello world","hello scalar")
    val x = arr.flatMap(_.split(" "))
    for (i <- x) {
      println(i)
    }

//分组
    val arr = Array("hello world","hello scalar")
    //先转为K-V形式，然后按照Key分组
    val x = arr.flatMap(_.split(" ")).map((_,1)).groupBy(_._1)
    for (i <- x) {
      println(i)
    }
//统计信息
    val arr = Array("hello world","hello scalar")
    //map先转为K-V形式，然后groupby按照Key分组,mapValues统计次数，toList转为List,sortBy根据次数从小到大排序，reverse从大到小
    val x = arr.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).reverse
    for (i <- x) {
      println(i)
    }