scala学习笔记一

scala基础语法：

scala 程序是对象的集合，通过调用彼此的方法来实现消息传递。
对象：有具体的属性和行为，是一个类的实例。
类：是对象的抽象。
方法：描述的是基本的行为，一个类可以包含多个方法。
字段：每个对象都有它唯一的实例变量集合，即字段。对象的属性通过给字段赋值来创建。

脚本形式：

先scalac编译，然后scala执行

$ scalac HelloWorld.scala $ lsHelloWorld$.class  HelloWorld.scalaHelloWorld.class    $ scala HelloWorldHello, world!

大小写问题：

区分大小写 - Scala是大小写敏感的
如果若干单词被用于构成类或者方法的名称，每个单词的第一个字母应大写。但是对于所有的类名的第一个字母要大写，对于所有的方法名第一个字母要小写。
示例：class MyFirstScalaClass
示例：def myMethodName()
程序文件名 - 程序文件的名称应该与对象名称完全匹配。
保存文件时，应该保存它使用的对象名称（记住Scala是区分大小写），并追加”.scala”为文件扩展名。
示例: 假设”HelloWorld”是对象的名称。那么该文件应保存为’HelloWorld.scala”
def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。

注释：

//或者/* */

换行符：

scala是面向行的语言，语句可以用分号（;）结束或换行符。若一行里仅有一个语句可以不写，如果有多个语句那么分号是需要的。

scala 包

定义包
scala 使用 package 关键字定义包，在scala将代码定义到某个包中有两种方式：
第一种方法和 Java 一样，在文件的头定义包名，这种方法就后续所有代码都放在该包中。 比如：
package com.runoob
class HelloWorld
第二种方法有些类似 C#，如：
package com.runoob {
class HelloWorld
}
第二种方法，可以在一个文件中定义多个包。
引用
scala 使用 import 关键字引用包。

import java.awt.Color  // 引入Colorimport java.awt._  // 引入包内所有成员def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent  ...  // 因为引入了java.awt，所以可以省去前面的部分}

import语句可以出现在任何地方，而不是只能在文件顶部。import的效果从开始延伸到语句块的结束。这可以大幅减少名称冲突的可能性。
如果想要引入包中的几个成员，可以使用selector（选取器）：

import java.awt.{Color, Font}// 重命名成员import java.util.{HashMap => JavaHashMap}// 隐藏成员import java.util.{HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了

注意：默认情况下，Scala 总会引入 java.lang._ 、 scala._ 和 Predef._，这里也能解释，为什么以scala开头的包，在使用时都是省去scala.的。

scala变量：

scala使用使用关键词 “var” 声明变量，使用关键词 “val” 声明常量。
变量的类型在变量名之后等号之前声明。定义变量的类型的语法格式如下：

var/val VariableName : DataType [=  Initial Value]var myVar : Int;

在 scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

var myVar = 10;val myVal = "Hello, Scala!";

支持对多个变量的声明：

val x, y = 100  // x, y都声明为100

scala访问修饰符：
scala访问修饰符分为：private,protected,public

scala控制语句：

scala的条件语句：

object Test {   def main(args: Array[String]) {      var x = 30;      if( x < 20 ){         println("x 小于 20");      }else{         println("x 大于 20");      }   }}

scala循环语句：
while循环\do…while循环\for循环

object Test {   def main(args: Array[String]) {      // 局部变量      var a = 10;      // while 循环执行      while( a < 20 ){         println( "Value of a: " + a );         a = a + 1;      }   }}

for循环是用来编写一个指定次数的循环结构，语法结构如下：

for( var x <- Range ){   statement(s);}Range可以表达为：i to j 或者 i util j(不包含j)object Test {   def main(args: Array[String]) {      var a = 0;      // for 循环      for( a <- 1 to 10){         println( "Value of a: " + a );      }   }}可以用分号来设置多个区间，这样会迭代给定区间的所有值：object Test {   def main(args: Array[String]) {      var a = 0;      var b = 0;      // for 循环      for( a <- 1 to 3; b <- 1 to 3){         println( "Value of a: " + a );         println( "Value of b: " + b );      }   }}

for循环集合：
for在集合中循环：

for( var x <- List ){   statement(s);}object Test {   def main(args: Array[String]) {      var a = 0;      val numList = List(1,2,3,4,5,6);      // for 循环      for( a <- numList ){         println( "Value of a: " + a );      }   }}

for使用if条件来过滤循环：
语法结构如下：

for( var x <- List      if condition1; if condition2...   ){   statement(s);object Test {   def main(args: Array[String]) {      var a = 0;      val numList = List(1,2,3,4,5,6,7,8,9,10);      // for 循环      for( a <- numList           if a != 3; if a < 8 ){         println( "Value of a: " + a );      }   }}

for 使用 yield可以把for循环的返回值作为一个变量存储：

var retVal = for{ var x <- List     if condition1; if condition2...}yield xobject Test {   def main(args: Array[String]) {      var a = 0;      val numList = List(1,2,3,4,5,6,7,8,9,10);      // for 循环      var retVal = for{ a <- numList                         if a != 3; if a < 8                      }yield a      // 输出返回值      for( a <- retVal){         println( "Value of a: " + a );      }   }}

scala函数

函数声明和定义：

//函数声明：def funcName ([参数列表])：[return type]//函数定义：return type 可以是任意合法的 Scala 数据类型。参数列表中的参数可以使用逗号分隔def funcName ([参数列表])：[return type] = {    function body    return [expr]}//举例：object add{   def addInt( a:Int, b:Int ) : Int = {      var sum:Int = 0      sum = a + b      return sum   }}//如果函数没有返回值，可以返回为 Unit，这个类似于 Java 的 voidobject Hello{   def printMe( ) : Unit = {      println("Hello, Scala!")   }}

函数调用的方式：通过函数名或者实例对象来调用

object Test {   def main(args: Array[String]) {        println( "Returned Value : " + addInt(5,7) );   }   def addInt( a:Int, b:Int ) : Int = {      var sum:Int = 0      sum = a + b      return sum   }}

函数指定函数参数名
一般情况下函数调用参数，就按照函数定义时的参数顺序一个个传递。但是我们也可以通过指定函数参数名，并且不需要按照顺序向函数传递参数，实例如下：

object Test {   def main(args: Array[String]) {        printInt(b=5, a=7);   }   def printInt( a:Int, b:Int ) = {      println("Value of a : " + a );      println("Value of b : " + b );   }}

函数使用可变的参数列表：
Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。
Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。

object Test {   def main(args: Array[String]) {        printStrings("Runoob", "Scala", "Python");   }   def printStrings( args:String* ) = {      var i : Int = 0;      for( arg <- args ){         println("Arg value[" + i + "] = " + arg );         i = i + 1;      }   }}

scala函数使用默认参数：
scala 可以为函数参数指定默认参数值

object Test {   def main(args: Array[String]) {        println( "返回值 : " + addInt() );   }   def addInt( a:Int=5, b:Int=7 ) : Int = {      var sum:Int = 0      sum = a + b      return sum   }}

scala函数匿名函数的定义：
scala中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。注意的是=>

var inc = (x:Int) => x+1var mul = (x:Int, y:Int) => x*yvar userDir = () => { System.getProperty("user.dir") }object Demo {   def main(args: Array[String]) {      println( "multiplier(1) value = " +  multiplier(1) )      println( "multiplier(2) value = " +  multiplier(2) )   }   var factor = 3   val multiplier = (i:Int) => i * factor}

scala 偏应用函数
cala 偏应用函数是一种表达式，你不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。

//打印日志信息import java.util.Dateobject Test {   def main(args: Array[String]) {      val date = new Date      log(date, "message1" )      Thread.sleep(1000)      log(date, "message2" )      Thread.sleep(1000)      log(date, "message3" )   }   def log(date: Date, message: String)  = {     println(date + "----" + message)   }}//log() 方法接收两个参数：date 和 message。我们在程序执行时调用了三次，参数 date 值都相同，message 不同。我们可以使用偏应用函数优化以上方法，绑定第一个 date 参数，第二个参数使用下划线(_)替换缺失的参数列表，并把这个新的函数值的索引的赋给变量。import java.util.Dateobject Test {   def main(args: Array[String]) {      val date = new Date      val logWithDateBound = log(date, _ : String)      logWithDateBound("message1" )      Thread.sleep(1000)      logWithDateBound("message2" )      Thread.sleep(1000)      logWithDateBound("message3" )   }   def log(date: Date, message: String)  = {     println(date + "----" + message)   }}

scala函数柯里化
柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

//定义一个普通的函数def add(a:Int, b:Int) = a + badd(1,2)//柯里化def add(a:Int)(b:Int) = a + badd(1)(2)//分析：add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。

object Test {   def main(args: Array[String]) {      val str1:String = "Hello, "      val str2:String = "Scala!"      println( "str1 + str2 = " +  strcat(str1)(str2) )   }   def strcat(s1: String)(s2: String) = {      s1 + s2   }}

scala闭包
闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

object Test {     def main(args: Array[String]) {        println( "muliplier(1) value = " +  multiplier(1) )        println( "muliplier(2) value = " +  multiplier(2) )     }     var factor = 3     val multiplier = (i:Int) => i * factor  }