Scala基础

• scala 中没有 static 关键字对于一个class来说，所有的方法和成员变量在实例被 new
  出来之前都是无法访问的因此class文件中的main方法也就没什么用了，scala object 中所有成员变量和方法默认都是
  static 的所以 可以直接访问main方法。

Scala声明变量有两种方式，一个用val，一个用var。
val / var 变量名 : 变量类型 = 变量值。
val定义的值是不可变的，它不是一个常量，是不可变量，或称之为只读变量。

创建项目中kind选项
Class：相当于java当中的class，scala中没有static修饰，无法调用静态方法
Object：里面的属性和方法都是静态的，可以直接进行调用
Trait：相当于java当中的接口
Scala会自动推断变量值的类型。

常用类型结构图

Java当中，顶级父类是object，但是在scala中，顶级父类是Any
AnyVal：值类型，例如Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型
AnyRef：引用类型，类如java中的class类
Scala中最底层的子类是Nothing
Scala中的Unit
Scala中认为一切都有返回值，如果没有的话，就用Unit = （）作为一个占位符，表示返回值
运算符
运算符在java当中参与计算，在scala中不仅仅是参与计算，还是方法。
Scala中没有++、–，用+=和-=完成相同的工作
分号的使用
在scala中，换行后，scala会认为当前行程序结束，换行后是另外一个程序，能自动识别，行尾不用分号进行分割；
一行当中写了多个程序，使用分号，让scala识别分号后是另一个程序了
块表达式
被大括号包含的一系列表达式，最后一个表达式的返回值就是块表达式的返回值。
if、while、for返回值
If语句有返回值
While语句没有返回值
For循环条件中可以使用to或until
To：（1 to 10）:[1,2,3…10]:左右均为闭合区间，既包含左侧，也包含右侧
Until：（1 until 10）：[1,2,3…10):左闭右开区间，包含左侧，不包含右侧
break和continue功能
1、breakble方法写到for循环里面，调用break方法起到了continue功能；
2、breakble方法写到for循环外面，调用break方法起到了break功能。
3、return起到了break功能。

快表达式

被大括号包含的一系列表达式，最后一个表达式的返回值就是快表达式的返回值。
if、while、for返回值
if 语句又返回值
While 语句没有返回值
for循环条件可以使用to或until
To:（1 to 10）：[1,2,3,4,5,6,7,8,9,10]左右均为闭合区间
until: (1 to 10):[1,2,3,4,5,6,7,8,9,10)左闭合右开

方法定义
def 方法名(参数名:参数类型, 参数名：参数类型):返回值类型={方法体}
def 方法名(参数名:参数类型, 参数名：参数类型)={方法体}

注意：方法和函数最多可以传22个参数
函数定义
//val 函数名 = （参数名：参数类型，参数名：参数类型）=>函数体
val fun = (x:Int,y:Int)=>{
x+y
}
val result: Int = fun(10,30)

//val 函数名：(参数类型，参数类型)=>返回值类型={函数体}
val fun1:(String,Int)=>String={
(x,y)=>x
}
val str: String = fun1(“list”,100)

定长数组和变长数组之间的转换
定长->变长：调用toBuffer方法
变长->定长：调用toArray方法

元组
被小括号包含的多个元素,元素可以是任意类型.
元祖当中存储最多元素的个数:22个

val arr = Array(1,2,3,4,5)
//fold
val result = arr.fold(0)(_-_)
println(result)
//运算流程 0-1-2-3-4-5=-15

//foldLeft
val result1: Int = arr.foldLeft(0)(_-_)
print(result1)
//运算流程同fold

//foldRight
val result2: Int = arr.foldRight(0)(_-_)
//运算流程
/*
5-0 = 5
4-5 = -1
3-(-1) = 4
2-4 = -2
1-(-2) = 3
*/

//scanLeft,类似于fold,只是将相加的中间结果保存下来,scan,scanRight同.
val result3: Array[Int] = arr.scanLeft(0)(_+_)
println(result3.toBuffer)
/*
ArrayBuffer(0, 1, 3, 6, 10, 15)
*/

val sentence = "一首现代诗《笑里藏刀》:哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈刀哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈"
//m +  (“一” -> 1, “首” -> 1, “哈” -> 1)
val i7 = (Map[Char, Int]() /: sentence)((m, c) => m + (c -> (m.getOrElse(c, 0) + 1)))
println(i7)
val map1 =sentence.foldLeft(Map[Char,Int]())((m,c)=>m+(c->(m.getOrElse(c,0)+1)))
println(map1)

/*
i7: scala.collection.immutable.Map[Char,Int] = Map(现 -> 1, 首 -> 1, 》 -> 1, 一 -> 1, 诗 -> 1, 哈 -> 34, 里 -> 1, 刀 -> 2, 笑 -> 1, 代 -> 1, 藏 -> 1, : -> 1, 《 -> 1)
Map(现 -> 1, 首 -> 1, 》 -> 1, 一 -> 1, 诗 -> 1, 哈 -> 34, 里 -> 1, 刀 -> 2, 笑 -> 1, 代 -> 1, 藏 -> 1, : -> 1, 《 -> 1)
res2: Unit = ()
map1: scala.collection.immutable.Map[Char,Int] = Map(现 -> 1, 首 -> 1, 》 -> 1, 一 -> 1, 诗 -> 1, 哈 -> 34, 里 -> 1, 刀 -> 2, 笑 -> 1, 代 -> 1, 藏 -> 1, : -> 1, 《 -> 1)
Map(现 -> 1, 首 -> 1, 》 -> 1, 一 -> 1, 诗 -> 1, 哈 -> 34, 里 -> 1, 刀 -> 2, 笑 -> 1, 代 -> 1, 藏 -> 1, : -> 1, 《 -> 1)
res3: Unit = ()
*/

迭代:

val lst = List(1,2,3,4,5).iterator
while (lst.hasNext){
  println(lst.next())
}