注： --------scala中的任何数据都是对象

--------Scala可以对数据类型进行自动推导，所以定义变量时可省去数据类型

==>数据类型

-->数值类型

--- Byte8位

--- Short16位

--- Int32位

--- long 64位

-->字符和字符串类型

---Char

--- String

-->Unit类型 相当于Java的 void

-->Nothing类型 般表示运行过程中出现了Exception

==>定义变量

-->格式： var | val 变量名：类型 =内容

-->var 定义值可变的变量

vara="hello"//vara:String="hello"varb=12345//varb:Int=12345

--> val定义值不可变的常量

vala="word"

==>函数

-->格式：def 函数名（变量名：类型 |变量名：=>类型）:函数返回值类型 = {}

-->函数参数：

---call by value: def demo(x:Int, y: Int): Int = x + x对函数的实参求值

demo(3+4, 8)

计算过程：

7 + （3+4）

7 + 7

14

--- call by name: def demo(x: => Int, y: => Int): Int = x + x函数的实参每次在函数体内部被调用的时候都会求值

demo(3+4, 8)

计算过程：

7 + 7

14

---默认参数： def func1(name: String = "Tom"): String = "Hello" + name

---代名参数 :

deffunc2(str:String="Myname",name:String="Marry",age:Int=18):String={str+"is"+name+",I'm"+age+"啦！"}func2(name="Tom")func2()

---可变参数 :求多个数字的和

defsum(args:Int*)={varresult=0for(arg<-args)result+=argresult}sum(1,2,3)

==>懒值（lazy）:如果一个变量是 lazy ，他的初始化会被推迟，直到第一次使用它的时候才会执行

-->正常的变量定义后会直接赋给变量，如:

var a = "hello"

定义变量后会返回： a : String = "hello"

-->使用 lazy定义变量时，不会执行，只有在第一次执行的时候才会执行赋值操作，如：

lazy var a = "hello"

定义变量后返回：a: String = <lazy>

只有使用变量时，才会进行赋值操作：

a

String = "hello"

==>异常: 异常的处理机制是什么？ 向上处理

-->采用 try{ …… }catch{ …… }finally{……}捕获和处理异常

try{valwords=scala.io.Source.fromFile("d:\\demo\\a.txt").mkString}catch{caseex:java.io.FileNotFoundException=>{println("FileNotFound!!!")}caseex:IllegalArgumentException=>{println("IllegalArgumentException!!!")}case_:Exception=>{println("otheException")}}finally{println("finallyblock")}

-->如果一个函数的返回类型是Nothing，表示在函数执行过程中产生异常

deffunc1()=thrownewIllegalArgumentException("SomeErrorHappened")

-->if else语句，如果在一个分支中产生了异常，则另一个分支的返回值，将作为if else返回值的类型

valx=10if(x>=0){scala.math.sqrt(x)}else{thrownewIllegalArgumentException("Thevalueshouldbenot")}

==>数组

-->定长数组：使用关键字 Array

vala=newArray[Int](10)valstr=newArray[String](5)valdemo_list=Array("Tom","Marry","Mike")

-->变长数组：使用关键字 ArrayBuffer

vallist1=ArrayBuffer[Int]()//向数组中插入元素list1+=1list1+=5//向数组中插入多个元素list1+=(20,55,47)//去掉最后三个值list1.trimEnd(3)//将ArrayBuffer转换为Arraylist1.toArray

-->遍历数组

//创建数组varnames=Array("Tom","Marry","Linda")//使用for循环遍历for(name<-names)println(name)//使用foreach遍历names.foreach(println)//对数组进行转换，生成一个新的数组valnewnames=for{name<-namesnew=name.toUpperCase}yeild(new)

-->数组常用操作

importscala.collection.mutable.ArrayBuffervaldemoArray=Array(6,8,4,,5,2,6,5,4)//最大值demoArray.max//最小值demoArray.min//求和demoArray.sum//定义一个变长数组demoArrayBuffer=ArrayBuffer(5,3,5,7,8,7,9,5,74)//降序排序demoArrayBuffer.sortWith(_>_)//升序排序demoArrayBuffer.sortWith(_<_)

==>映射：一个由key, value组成的集合

-->使用 ->符号创建

valdemoMap=Map("Tom"->11,"Marry"->44)

-->不可变Map

valtestMap=scala.collection.immutable.Map("Tom"->20,"Marry"->18)

-->可变Map

valtestMap=scala.collection.mutable.Map("Tom"->20,"Marry"->18)valtestMap1=scala.collection.mutable.Map(("Tom",20),("Marry",18))

-->映射操作

//获取映射中的值，如果不存在，会抛出ExceptiontestMap("Tom")//可通过Map.constains事先判断数据是否存在，然后再取值if(testMap.contains("Tom")){testMap("Tom")}else{-1}//简写testMap.getOrElse("Tom",-1)//更新值testMap("Tom")=25//添加新元素testMap+="lily"->18//移除元素testMap-="Tom"//迭代，使用for，或者foreachfor(m<-testMap)println(m)testMap.foreach(println)

==>元组：不同类型的值的聚集

-->创建元组：val 名称+个数 = （元素，元素）

valtu1=(1,2,3)valtu2=newTuple2("hello","world")

-->访问元组中的元素

tu1._1//点后面跟的是第几个元素1

-->遍历元组,使用foreach遍历元组，注意，元组遍历前首先需要生成对应的迭代器，不能直接使用for或者foreach进行遍历

tu1.productIterator.foreach(println)