Scala学习笔记一之基础语法，条件控制，循环控制，函数，数组，集合

前言：Scala的安装教程：http://www.cnblogs.com/biehongli/p/8065679.html

1：Scala之基础语法学习笔记：

1:声明val变量:可以使用val来声明变量，用来存放表达式的计算结果，但是常量声明后是无法改变它的值的，建议使用val来声明常量；
声明var变量:如果要声明可以改变的引用，可以使用var变量，声明的常量的值可以改变。
3:指定类型:无论声明val变量还是声明var变量。都可以手动指定其类型，如果不指定，scala会自动根据值，进行类型的推断；
4:声明多个变量:可以将多个变量放到一起进行声明,如val id,age :Int = 0;val num1,num2=100;
5:基础数据类型:Byte,Char,Short,Int,Long,Float,Double,Boolean;记住，Scala没有包装数据类型；
6:基本操作符:scala的算术操作符和Java的算术操作符没有什么区别，比如+ - * / %等等，以及其他操作符，& | >> << 等等，但是在scala中，这些操作符其实是数据类型的函数，比如1+1,可以写作1.+(1),1 to 10可以写作1.to(10)等等。
　　  注意，在scala中没有提供++,--操作，我们只可以使用+=和-=操作符；
7:apply函数:在scala中apply函数是非常特殊的一种函数，在Scala的object中，可以声明apply函数。而使用"类名()"的形式，其实就是"类名.apply()"的一种缩写。通常使用这种方式来构造类的对象，而不是使用"new 类名()"的方式。
　　 比如"hello world"(6)可以写成"hello world".apply(6)；

2：Scala之条件控制学习笔记：

1:if表达式的定义:在scala中，if表达式是有值的，就是if或者else中最后一行就是返回的值。
比如var age = 18; if(age >18) 1 else 0;
可以将if表达式赋予一个变量，比如var result = if(age >18) 1 else 0;
2:if表达式的类型推断，由于if表达式是有值的，而if和else子句的值类型可能是不同的。此时if表达式的值是什么类型的呢，scala可以自动进行推断，取两个类型的公共父类型。
比如：var age =18;if(age > 18) "成年人" else 0;此时if和else的值分别是String和Int,则表达式的值就是Any,因为Any是String和Int的公共父类型。
3:如果if后面没有跟else，则默认else的值是Unit，也可以用()表示，类似于Java中的void或者null。
4:语句终结符:默认情况下，scala不需要语句终结符即;这个分号,默认每一行作为一个语句。
但是如果一行放多条语句，则必须使用语句终结符。
5:块表达式。指的就是{}中的值，其中可以包含多条语句，最后一个语句的值就是块表达式的返回值。
6:输出:print()和println(),其中print()打印的时候不会加换行，但是println()打印的时候会加一个换行符。
7:输入:readLine：允许我们从控制台读取用户输入的数据，类似于Java中的System.in和Scanner的作用。
注意:readInt()输入是数值类型的。readDouble()是输入小数类型的。

3：Scala之循环控制学习笔记：

1:while do循环，scala中的while do循环，基本和Java相同。
2:for循环，比如:for(i <- 1 to 10) println(i);注意for循环的使用，多加揣摩和练习。
3:跳出循环语句:scala中没有提供如Java中的跳出循环语句。但是可以使用boolean类型变量，return或者使用Breaks的break函数来替换使用。
比如：var flag : Boolean = false;for(i <- 1.to(10)) if(i%2==0){ flag = true; return flag;}
4:scala的九九乘法表:
for(i <- 1.to(9); j <- 1.to(9)){
if(j == 9){
println(i + "*" + j + " = " + i*j);
}else{
print(i + "*" + j + " = " + i*j + " ");
}

}
5:scala的取偶数
for(i <- 1 to 100 if i % 2 ==0) println(i)
6:for推导式，构造集合:
var a = for(i <- 1 to 10) yield i;
println(a)

4：Scala之函数学习笔记，面向对象和面向函数编程：

1:函数的定义:需要定义函数的函数名，参数，函数体；Scala要求必须给出所有参数的类型，但是不一定给出函数返回值的类型，只要右侧的函数体中不包含递归的语句，Scala就可以根据自己右侧的表达式推断出返回类型。
比如：
def helloScala(name : String,age : Int): Unit ={
if(age > 18){
println("恭喜您:" + name + "您已经:" + age+"岁了，您已经成年了");
}else{
println("恭喜您:" + name + "您已经:" + age+"岁了，您还是未成年哦");
}
}
helloScala("张三",20);
2:如果在函数体递归调用函数自身，则必须手动给出函数的返回值类型。
3:默认参数，在Scala中，有时候在调用某些函数的时候，不希望给出参数的具体指，而希望使用参数自身默认的值，此时就在定义函数时使用默认参数。如果给出的参数不够，则会从左往右依次应用参数。
比如:
def hello(name :String="张三",age : Int=20): Unit ={
println(name+ " "  + age)
}
hello()
4:带名参数:在调用函数的时候，也可以不按照函数定义的参数顺序来传递参数，而是使用带名参数的方式来传递；
还可以混合使用未命名参数和带名参数，但是未命名参数必须在带名参数前面。
比如：
def hello(name :String="张三",age : Int=20): Unit ={
println(name+ " "  + age)
}
hello(age=24,name="李四")
hello("王五",age=26)
5:函数之变长参数:在Scala中，有时候我们需要将函数定义为参数个数可变的形式，则此时可以使用变长参数定义函数:
比如:
def add(nums : Int*): Int ={
var sum : Int= 0;
for(num <- nums){
sum += num;
}
return sum;
}
var result = add(1,2,3,4);
println(result)
注意:如果想要将一个已有的序列直接调用变长参数，是不可以的。此时需要使用Scala特殊的语法将参数定义为序列，让Scala解释器能够识别:比如:var s = sum(1 to 5:_*)
比如:
def add(nums : Int*): Int ={
var sum : Int= 0;
for(num <- nums){
sum += num;
}
return sum;
}
println(add(1 to 4:_*))
6：函数之过程，定义函数的时候，如果函数体直接包裹在了花括号里面，而没有使用=连接，则函数的返回值就是Unit。这样的函数就被称之为过程。过程通常用于不需要返回值的函数。
注意:过程还有一种写法，就是将函数的返回值类型定义为Unit;
比如：
def hello(name : String) = "hello:" +name;
def hello(name : String) {println("hello:"+name);"hello:"+ name}
def hello(name : String) : Unit= "hello:" +name;
7：Scala的异常:在scala中，异常处理和捕获机制与Java类似。
比如：
try{
throw new IllegalArgumentException("算数异常");
}catch{
case _:IllegalArgumentException => println("算术异常");
}finally {
println("最后一定执行这句话。")
}

4：Scala之数组学习笔记：

1:Array,在Scala中，Array也是长度可变的数组，此外，由于Scala与Java都是运行在Jvm中，双方可以互相调用，因此，Scala数组的底层实际上就是Java数组。
比如:数组初始化以后，长度就固定下来了，而且元素全部根据其类型初始化:
var arr = new Array[Int](10)
var arr2 = new Array[String](10)
可以直接使用Array()创建数组，元素类型自动推断:
var arr = Array("张三","李四");
println(arr(0))
2:ArrayBuffer,在Scala中，如果需要类似于Java中ArrayList这种长度可变的集合类，则可以使用ArrayBuffer;
如果不想每次都使用全限定名，则可以预先导入ArrayBuffer类:
import scala.collection.mutable.ArrayBuffer
使用ArrayBuffer()方式可以创建一个空的ArrayBuffer:
var arr = ArrayBuffer[Int]();
println(arr.toBuffer)
使用+=操作符，可以添加一个元素或者多个元素:
arr += 1;
println(arr.toBuffer)
arr += (2,3,4,5,6);
println(arr.toBuffer)
使用++=操作符，可以添加其他集合中的所有元素:
arr ++= Array(8,9,5,6,3,66);
println(arr.toBuffer)
使用trimEnd()函数，可以从尾部截断指定个数的元素:
arr.trimEnd(5)
println(arr.toBuffer)
使用insert()函数可以在指定位置插入元素。但是这种操作效率很低，因为需要移动指定位置后的所有元素。
使用remove()函数可以移除指定位置的元素。
Array和ArrayBuffer可以互相进行转换:arr.toArray;arr.toBuffer
3:遍历Array和ArrayBuffer
使用for循环和until遍历Array和ArrayBuffer：
使用until是RichInt提供的函数:
var arr = Array(11,22,33,44,55,66,77,88);
for(i <- 0.until(arr.length)){
print(arr(i) + " ")
}
跳跃遍历Array/ArrayBuffer
var arr = Array(11,22,33,44,55,66,77,88);
for(i <- 0.until(arr.length,3)){
print(arr(i) + " ")
}
从尾部遍历Array/ArrayBuffer
var arr = Array(11,22,33,44,55,66,77,88);
for(i <- 0.until(arr.length).reverse){
print(arr(i) + " ")
}
使用增强for循环遍历Array/ArrayBuffer
var arr = Array(11,22,33,44,55,66,77,88);
for(i <- arr){
print(i + " ")
}
4：数组的常用函数：
数组元素求和:
var arr = Array(55,11,22,33,44,55,66,77,88);
println("求和：" + arr.sum)
获取数组的最大值和最小值:
println("最大值:"+ arr.max + " ,最小值:" + arr.min)
对数组进行排序:
quickSort(arr)
println("排序:"+ arr.toBuffer)
获取数组中所有的元素内容:
println("获取值："+ arr.mkString(","))
toString函数
println(arr.toString)
5:使用yield和函数式编程转换数组:
对数组Array进行转换，获取的还是Array：
var arr = Array(11,12,13,14,15,16,17,18,19);
var result = for(i <- arr) yield i * i;
for(i <- result){
print(i + " ")
}
对数组ArrayBuffer进行转换，获取的还是ArrayBuffer：
var arr = ArrayBuffer[Int]();
arr += (11,12,13,14,15,16,17,18,19);
var result = for(i <- arr) yield i * i;
for(i <- result){
print(i + " ")
}
结合if守卫，仅仅转换需要的元素:
var arr = ArrayBuffer[Int]();
arr += (11,12,13,14,15,16,17,18,19);
var result = for(i <- arr if i %2 == 0) yield i * i;
for(i <- result){
print(i + " ")
}
使用函数式编程转换数组,通常使用第一种方式:
var arr = ArrayBuffer[Int]();
arr += (11,12,13,14,15,16,17,18,19);
var result = arr.filter(_ % 2 == 0).map(2 * _)
print(result.toBuffer + " ")
var result2 = arr.filter(_ % 2 == 0) map{2 * _}
print(result2.toBuffer + " ")

5：Scala之集合中的Map，以及tuple的学习笔记：

1:创建Map:
创建一个不可变的Map:
import scala.collection.immutable.Map
var map = Map("张三" ->26,"李思思" -> 23);
println(map("张三"))
创建一个可变的Map:
import scala.collection.mutable.Map
var map = Map("张三" -> 23,"李思思" -> 24);
println(map("张三"))
map("王五") = 25;
println(map("王五"))
使用另外一种方式定义Map元素:
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
println(map.toBuffer)
创建一个空的HashMap:
var map = new mutable.HashMap[String,Int]()
获取指定key对应的value，如果key不存在，会报错的:
println(map("张三"))
使用contains函数检查key是否存在:
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
if(map.contains("张三")){
println("张三存在");
}else{
println("张三不存在");
}
使用getOrElse函数用来判断是否存在，不存在返回一个默认值:
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
var result = map.getOrElse("张三三",20)
println(result)
更新Map的元素:
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
map("张三") = 26;
println(map("张三"))
增加多个元素：
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
map += ("小明" -> 22,"小红" -> 26);
println(map.toBuffer)
移除元素:
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
map -= "张三";
println(map.toBuffer);
更新不可变的map：
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
map -= "张三";//而不是map不可以添加和减少对应的key-value
//map("李四") = 20;//注意不可更改是key对应的value不可以改变。
println(map.toBuffer);
map += ("张三" -> 26);
println(map.toBuffer)
移除不可变的map的元素:
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
var map2 = map + ("小红" -> 20,"小明" -> 21);
println(map2.toBuffer)
var map3 = map2 - ("小红","小明");
println(map3.toBuffer)
2:Scala遍历Map的操作：
scala遍历map的entrySet：
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
for((key,value) <- map){
println(key + " " + value)
}
scala遍历map的key：
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
for(key <- map.keySet){
println(key + " " + map(key))
}
scala遍历map的value：
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
for(value <- map.values){
println(value)
}
scala生成新的map，反转key和value：
var map = Map(("张三",22),("李四",23),("王五",24),("赵六",26));
var result = for((key,value) <- map) yield (value,key)
for((key,value) <- result){
println(key + " " + value)
}
SortedMap可以自动对Map的key进行排序:
var map = SortedMap("张三" -> 26, "别先生" -> 24 ,"小明" ->20);
println(map.toBuffer)
LinkedHashMap可以记住插入的entry的顺序:
var map = new mutable.LinkedHashMap[String ,Int]();
map("张三") = 20;
map("别先生") = 24;
map("小明") = 22;
println(map.toBuffer)
for((key,value) <- map){
println(key + " " + value)
}
3:scala的tuple：
简单Tuple和访问Tuple：
var tuple = ("张三",26,20,true,"李四");
println(tuple._1)
println(tuple._2)
println(tuple._3)
println(tuple._4)
println(tuple._5)
zip操作:
var names = Array("张三","李四","王五");
var ages = Array(24,25,26);
var result = names.zip(ages);
println(result.toBuffer)
for((name,age) <- result){
println(name+ "  " + age)
}

待续......