1.会将方法体的最后一行代码，看成返回值返回。java
2.scala每行后面不须要加“;”，数组
3.若是一行中须要多条语句，则须要用“;”隔开。安全
4.若是scala的方法体只有一行代码，则方法体能够省略。多线程
5.若是scala调用的方法只有一个参数，则.()能够省略。并发
6.若是函数的方法体只有一行代码，则方法体{}能够省略。函数
7.若是函数的参数类型能够被推断出来，则类型能够省略。高并发
8.若是函数的参数列表只有一个参数，则参数的括号能够省略。spa
var：用来声明一个变量，变量声明后，在程序执行过程当中能够被修改。.net
示例：线程
def main(args: Array[String]): Unit = {
//三种变量赋值方式
var var1 = 100;
var var2: Int = 100;
var var3: java.lang.String = "hello";
//变量修改
var2 = 200;
var3 = "world";
}
注：scala能够自动根据值的类型推断变量/常量的类型，因此不写类型声明也能够。
val：用来声明一个常量，一旦被赋值就不能再进行修改。
注：java中变量使用较多，但在scala里，常量使用较多，由于在线程并发时能够减小甚至杜绝多线程并发安全问题，因此scala特别适合于应用在处理高并发场景。
//声明常量 val v2=200
当val被声明为lazy时，它的初始化将被推迟，直到咱们首次对它取值。懒值对于开销较大的初始化语句而言十分有用。
lazy只能用于常量（val），不能用于变量（var）。
正常状况下经过val和var定义的量都会直接分配空间，即便这个量要在好久之后才使用，这样就会形成内存空间白白被占用。
这种状况下能够加上lazy关键字，延后变量/常量赋值的位置。这样直到后续真正用到这个量时才真正开辟空间赋值，减小了内存的浪费。
val name = "zhang"//直接分配空间 即便一时半会用不到 lazy val name = "zhang"//并不会当即分配空间 直到后续用到了才会分配
示例：
lazy val v2=100 //> v2: => Int println(v2) //> 100
Scala的数据类型有如下9种：
Byte、Short、Int、Long、Char、String、Float、Double、Boolean。
其中String处于java.lang包，其余的则处在scala包下。
因为scala会自动导入java.lang和scala包因此这些类型能够在程序中直接使用。
其实能够认为scala中并无真正意义上的基本类型(如java中的基本类型)，以上的九种基本类型其实也出在包下是一个类。
在scala中以上基本数据类型区别于其余类的地方在于，他们的对象都已直接量的形式体现。
以上基本数据类型的直接量和java中基本彻底相同，再也不复述。
这九个类的直接量在须要时能够自动被转换为其对应的富包装类来调用，富包装类提供的额外方法。
每种数据类型都提供了不少方法供调用，因此scala的数据类型不一样于java的基本类型。
scala.runtime.RichByte
scala.runtime.RichShort
scala.runtime.RichInt
scala.runtime.RichLong
scala.runtime.RichChar
scala.runtime.RichString
scala.runtime.RichFloat
scala.runtime.RichDouble
scala.runtime.RichBoolean
事实上Scala的String类就是Java的String类，因此能够直接调用Java里String的全部方法。
因为Scala提供了隐式转换的方法，String类也拥有StringOps类中全部方法的访问权限，因此能够用这些方法作许多事情
示例：
val v3="hello"
//针对字符串作了repeat操做
v3.*(2)
v3.split("l")
//去重
v3.distinct
//去除头n个元素
v3.drop(1)
//去除尾部n个元素
v3.dropRight(2)
//提取头n个元素
v3.take(1)
//提取尾部n个元素
v3.takeRight(2)
//filter 根据指定的原则作过滤，其余类型都适用
v3.filter{x=>x!='l'}
v3.contains("l")
v3.exists { x => x=='l' }
//返回头1个元素。至关于take（1）
v3.head
v3.last
//以指定字符分割
v3.mkString(",")
//反转
v3.reverse
Scala中存在一个特殊的符号——三引号，在三引号中的字符都是普通字符，不须要转义。
当你在不肯定这个字符是否须要转义的时候，均可以使用三引号来标注，这样就能够省去转义的麻烦。
val v14="hello\t1711" //> v14 : String = hello 1711 //三引号的使用：三引号中没有转义都是普通字符 val v15="""hello\t1711""" //> v15 : String = hello\t1711
针对大数的操做，Scala专门提供了一个BigInt对象。
val v3:BigInt=2 //> v3 : BigInt = 2 v3.pow(10) //> res10: scala.math.BigInt = 1024
scala中操做符即方法，方法即操做符。
scala中的操做符实际上是普通方法调用的另外一种表现形式。对以上基本的运算符的使用其实就是隐含的在调用对应的方法。因此，能够认为scala中并无传统意义上的操做符，全部的操做符都是方法，全部的方法也均可以像操做符同样去使用。
scala在作运算时，若是以方法形式调用，则以方法顺序来执行。若是以操做符的形式来调用，则以操做符优先级的顺序调用，优先级同Java。
算数运算：+、-、*、/。
关系运算：>、<、>=、<=。
逻辑运算：&&、||、!。
位运算：>>、>>>、<<、~、&、|、^。
比较运算：==、!=。
示例：
val v4=2.+(3).*(5) //> v4 : Int = 25 val v5=2+3*5 //> v5 : Int = 17
scala中，符号优先级从高到底：（*、/、%）、（+、-）、:、=!、（<、>）、&、^、|。
前缀操做符一共有4种，分别是：+（正）、-（负）、!（非）、~（反）。
①直接使用
在须要是用前缀操做符的直接量前面加(空格)(符号)便可。
示例：
//使用时须要前面加空格 val v6= -2 //> v6 : Int = -2 val v7= +2 //> v7 : Int = 2 val v8= !false //> v8 : Boolean = true val v9= ~0XFF //> v9 : Int = -256
②调用方法
为了不产生歧义，能够经过unary方法来使用。
示例：
//为了不歧义能够经过如下形式来使用 val v10=2.unary_- //> v10 : Int = -2 val v11=2.unary_+ //> v11 : Int = 2 val v12=false.unary_! //> v12 : Boolean = true val v13=0XFF.unary_~ //> v13 : Int = -256
if……else 判断
if是具备返回值的，if判断后，将执行代码的最后一个表达式的值返回做为整个if执行后的结果。
示例：
val a=5
//> a : Int = 5
if(a>5){
//println("big")
"big"
}else{
//println("small")
"small"
}
//> res0: String = small
if(a>5)
"big"
else
"small"
//> res1: String = small
val r2=if(a>5)"big"else"small"
//> r2 : String = small
scala中的match相似于其余语言的switch。
match case语句是有返回值。
示例：
val v1="bbb"
v1 match{
case "aaa"=>{println("1")}
case "bbb"=>{println("2")}
case _=>{println("3")}
}
val result=v1 match{
case "aaa"=>{println("1");"1"}
case "bbb"=>{println("2");"2"}
case _=>{println("3");"3"}
}
和java中用法相同，while没法控制返回值，或者说返回值是Unit，写成()，在scala中while比较少使用。
示例：
val a1=Array(1,2,3,4,5)
var index=0
while(index<a1.length){
println(a1(index))
index+=1
}
scala中的for要比java的for强大，使用很频繁，须要熟练掌握。
for同while同样，没法控制返回值，或者说返回值是Unit，写成()。可是for()能够和yield{}配合使用，将for()每次循环结果存到一个Vector()中。
示例：
for(i<-a1){
println(i)
}
for(i<-a1)println(i)
1.to(5)
for(i<-1.to(5)){
println(i)
}
for(i<-1.to(5))println(i)
1 to 5
for(i<-1 to 5)println(i)
for(i<-1 to 5 by 2)println(i)
//scala的for循环里能够写条件判断语句
for(i<-1 to 5;if i>3)println(i)
//多个条件之间用;隔开
for(i<-1 to 5;if i>3;if i%2==0)println(i)
//打印99乘法表
for(i<-1 to 9){
for(j<-1 to i)print(i+"*"+j+"="+i*j+"\t")
println()
}
for(a<-1 to 9;b<-1 to a;val s=if(b==a)"\r\n"else"\t")print(b+"*"+a+"="+a*b+s)
//s函数搭配$能够实现拼接打印的效果
for(a<-1 to 9;b<-1 to a;val s=if(b==a)"\r\n"else"\t")print(s"$b*$a=${b*a}$s")
//for yield能够返回一个新的集合
//scala的集合类型涵盖数组、链表、set、Map、Range、Tuple等
//for yield for循环遍历的是什么类型，返回的就是什么类型
val a2=for(i<-a1)yield{i*2}
val l1=List(1,2,3)
val l2=for(i<-l1)yield{i+1}
val m1=Map("k1"->1,"k2"->2)
for(i<-m1)println(i)
for((k,v)<-m1)println(v)
for((m,n)<-m1)println(m)
for((k,v)<-m1)println(s"$k:$v")
for(i<-Array(1,2,3))yield i*2
Array(1,2,3).map(_*2) val nums=List(1,2,3,4).filter(_<4)
scala中没有break和continue语句，须要经过另外的形式来实现。想要使用break，须要先导包。
import util.control.Breaks._
示例：
import util.control.Breaks._
//实现break效果，须要将for循环体写到breakable()里
breakable(
for(i<-1 to 10){
if(i>8)break
println(i)
}
)
//实现continue
for(i<-1 to 10){
breakable(
if(i==8)break
else println(i)
)
}
scala中继承了java的异常机制。
示例：
try{
throw new RuntimeException("error")
}catch{
case t: NullPointerException =>{t.printStackTrace();println("null")}
case t: Exception=>{t.printStackTrace();println("other")}
}finally{
println("end")
}
上一篇：Scala简介和安装
下一篇：Scala的函数