scala语法中，每一行代码后面可以不需要以分号结束
在scala中，val修饰的变量表示不可修改的变量（这个相当于java中的final 关键字），var 修饰的变量表示可修改变量。其中分号后面的变量类型可不填写，
var str:String = "zhoucg" println(str) val finalStr:String = "zhoucg" var t1 = 3 println(t1) val ch:Char = 'A' val toInt = ch.toInt println(toInt)val修饰的变量可以通过lazy修饰，表示先不赋值，使用时再进行赋值操作 语法： lazy val 变量名：变量类型 = 变量初始值
scala和java一样，存在8种基本的数据类型，同时scala中没有像java那样存在基本数据类型的包装类，可以直接对scala的基本数据类型进行方法调用
scala访问修饰符基本和java一致，分别：private protected public 如果没有执行访问修饰符，默认情况下，scala的对象访问级别都是public（java的默认访问修饰符是default：只能被本类访问）
基本的算术运算符： 基本的关系运算符： 基本的逻辑运算符：
逻辑运算的表达式 if() { } else { } 赋值 val test = if() str1 else str2
val x =2 val test = if(x>0) 1 else -1在scala种，{} 可以包含一系列的表达式，块中的最后一个表达式的值就是块的值
val x0 = 1 val y0 = 1 val x1 = 2 val y1 = 2 val distance = { val dx = x1 - x0 val dy = y1 - y0 Math.sqrt(dx*dx+dy*dy) } println(distance)scala的循环和java类似，提供了
while（）{} do{} while() for(i <- 表达式/数组/集合) {}其中，for的基础用法和java不太相同，使用了 <- 指向对应的表达式的数据
val s = "hello" for (i <- 0 to s.length-1) {println(s(i))} for (i <-1 to 10) {println(i)} for(i<- 1 unitl 10) println(i) //until包含左边不包含右边提供scala对应跳出循环的操作，使用了函数式风格解决break和continue的功能， 首先导包： import scala.until.control.Breas._
// 跳出循环实例,break,break:breanable()包住整个循环体 breakable( for(i <-1 to 10){ if(i == 5){ break() } } ) // 跳出循环实例，continue，break：breakable包住整个判断条件 for(j<-1 to 10) { breakable{ if(j == 5) { break } println(j) } }scala有方法和函数，scala方法是类的一部分，而函数是一个对象可以赋值给一个变量 换句话说，在类中定义的函数即使方法 Scala 中的方法跟 Java 的类似，方法是组成类的一部分。 Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。 scala种使用val 语句定义函数，def语句定义方法
class Test{ def m(x: Int) = x + 3 val f = (x: Int) => x + 3 }这一点：其实把函数理解成方法是没有问题的 方法的定义：
def funcionName（变量名）：（【参数，单个参数定义：参数名：参数类型，多个参数用英文逗号进行隔开】）：【return type】 = {}如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。 如果方法没有返回值，可以使用Unti，整个类似java 的void
def voidType:Unit = { println("这个是一个无参的函数信息"); }同时，可以给方法传入一个函数类型的参数 代码：
/** * 定义一个方法， * 方法m1参数要求是一个函数，参数的参数必须是两个Int类型 * 返回值类型也是一个Int类型 * @param f * @return */ def m1(f:(Int,Int) => Int) :Int = { f(2,6) } //定义一个函数 val f1 = (x:Int,y:Int) => x +y; println(f1) m1(f1)scala函数的可变参数类型： Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)
def printString(args:String*) : Unit = { var i:Int = 0; for(arg <- args) { println("Arg value[" + i + "] = " + arg) i = i+1 } }scala默认参数值 定义规则：
def functionName(【变量名：变量类型=默认值】)：【返回值类型】 = {} def addInt( a:Int=5, b:Int=7 ) : Int = { var sum:Int = 0 sum = a + b return sum }scala声明数组的语法格式
定长数组：
val z：Array[String] = new Array[String] (3) val z = new Arrayy[String] (3)变长数组定义: 使用ArrayBuffer进行定义
// 定义变长数组的方法 var arr3 = new ArrayBuffer[Int](10) // 等价于 var arr5 = new ArrayBuffer[Int]()数组定义
var arr = Array(1,2,3)定义：
// 定义整型 List val x = List(1,2,3,4) // 定义 Set val x = Set(1,3,5,7) // 定义 Map val x = Map("one" -> 1, "two" -> 2, "three" -> 3) // 创建两个不同类型元素的元组 val x = (10, "Runoob") // 定义 Option val x:Option[Int] = Some(5)Scala迭代器 Scala迭代器（Iterator）不是一个集合，它是一种用于访问集合的方式
object Test { def main(args: Array[String]) { val it = Iterator("Baidu", "Google", "Runoob", "Taobao") while (it.hasNext){ println(it.next()) } } }同时，使用迭代器（Iterator）能够查出最大值和对应的最小值（迭代器的常用方法可以参考对应的api）
val iterable = Iterator(listStr) println(iterable.max) println(iterable.min)在Scala中，把哈希表这种数据结构叫做映射 在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变。 创建一个不可变的Map
val scores = Map("zhangsan"->90,"lisi"->80,"wangwu"->70) val scores = Map(("zhangsan",90),("lisi",80),("wangwu",70))创建一个可变的Map
val scores = scala.collection.mutable.Map(("zhangsan",90),("lisi",80),("wangwu",70))映射操作： 获取映射中的结果
val score1 = scores("lisi") val score2 = if(scores.contains("lisi")) scores("lisi") else 0 val score3 = scores.getOrElse("lisi",0) //0为默认值，如果不存在则返回默认值修改对应的映射的值：
scores("tom") = 99 scores("tom11") = 99 不存在时会添加一个值 scores.update("tom",66)遍历：
val keys = scores.keySet set集合 val key = scores.keys 返回一个迭代器 val value = scores.values 返回值的迭代器 for((k,v)<-scores) println(k+" “+v) 返回键值对 for (item <- scores) print(item+” ") 返回键值对集合的高级运用：（高级函数） 示例：
val seq = Seq(1,2,3,4,5) seq.max seq.min seq.count(_%2==0) //根据条件计数 seq.filter(_%2==0) 返回符合Boolean条件的结果map:（映射）列表元素 map函数的逻辑是遍历集合中的元素并对每个元素调用函数
val listStr = List(1,2,3,4) val seq1 = Seq(1,2,3,4,5) seq1.map(n => n*2) // 2 4 6 8 10 listStr.map(n =>n*2)flatten:取集合里面的元素
学习参考
1：https://www.runoob.com/scala/scala-functions.html 2：https://blog.csdn.net/qq_35180983/article/details/83279013
