Scala基础语法学习笔记

scala学习笔记

脚本模式编程

object HelloWorld {
   def main(args: Array[String]) {
      println("Hello, world!") // prints Hello World
   }
}

基础语法
区分大小写 - Scala是大小写敏感的，这意味着标识Hello 和 hello在Scala中会有不同的含义。

类名 - 对于所有的类名的第一个字母要大写。

如果需要使用几个单词来构成一个类的名称，每个单词的第一个字母要大写。
示例：class MyFirstScalaClass
方法名称 - 所有的方法名称的第一个字母用小写。
如果若干单词被用于构成方法的名称，则每个单词的第一个字母应大写。
示例：def myMethodName()
程序文件名 - 程序文件的名称应该与对象名称完全匹配。
保存文件时，应该保存它使用的对象名称（记住Scala是区分大小写），并追加“.scala”为文件扩展名。 （如果文件名和对象名称不匹配，程序将无法编译）。
示例: 假设“HelloWorld”是对象的名称。那么该文件应保存为’HelloWorld.scala“
def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。
换行符：
语句可以用分号（;）结束或换行符。分号在声明的结尾通常是可选的。

变量声明

var myVar : String = "Foo"
var myVar = 10;
val myVal = "Hello, Scala!";
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")

函数定义：

def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}
def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
void函数
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
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 );
   }
def main(args: Array[String]) {
        printStrings("Hello", "Scala", "Python");
   }
   def printStrings( args:String* ) = {
      var i : Int = 0;
      for( arg <- args ){
         println("Arg value[" + i + "] = " + arg );
         i = i + 1;
      }
   }

匿名函数

var inc = (x:Int) => x+1
var x = inc(7)-1
var mul = (x: Int, y: Int) => x*y
println(mul(3, 4))

柯里函数

def strcat(s1: String)(s2: String) = s1 + s2
def strcat(s1: String) = (s2: String) => s1 + s2
strcat("foo")("bar")
对于date使用不同的message的值
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)
   }

定义数组

var z = Array("Zara", "Nuha", "Ayan")
concat()方法来连接两个数组的例子
var myList1 = Array(1.9, 2.9, 3.4, 3.5)
var myList2 = Array(8.9, 7.9, 0.4, 1.5)
var myList3 =  concat( myList1, myList2)

集合

// Define List of integers.链表
val x = List(1,2,3,4)
val fruit: List[String] = List("apples", "oranges", "pears")
val nums: List[Int] = List(1, 2, 3, 4)
// Define a set.不同元素的集合
var x = Set(1,3,5,7)
// Define a map.键/值对
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
// Create a tuple of two elements.元组可以容纳不同类型的对象
val x = (10, "Scala")
val t = (1, "hello", Console)
// Define an option  Option[T] 提供了一种容器，用于给定类型的零个或一个元素
val x:Option[Int] = Some(5)
使用:::运算符或列表List.:::()方法或List.concat()方法来添加两个或多个列表
val fruit1 = "apples" :: ("oranges" :: ("pears" :: Nil))
val fruit2 = "mangoes" :: ("banana" :: Nil)
 var fruit = fruit1 ::: fruit2
 fruit = List.concat(fruit1, fruit2)
 创建统一列表包括相同的元素如下的零个或更多个拷贝的列表
 val fruit = List.fill(3)("apples") // Repeats apples three times.
 串联集合：
 val fruit1 = Set("apples", "oranges", "pears")
      val fruit2 = Set("mangoes", "banana")
      // use two or more sets with ++ as operator
      var fruit = fruit1 ++ fruit2
      println( "fruit1 ++ fruit2 : " + fruit )
      // use two sets with ++ as method
      fruit = fruit1.++(fruit2)
查找集合的共同值：
val num1 = Set(5,6,9,20,30,45)
      val num2 = Set(50,60,9,20,35,55)
      // find common elements between two sets
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )

键值对添加到映射

A += ('I' -> 1)
A += ('J' -> 5)
映射的基本操作：
val colors = Map("red" -> "#FF0000","azure" -> "#F0FFFF","peru" -> "#CD853F")
      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
串联映射
val colors1 = Map("red" -> "#FF0000",
                        "azure" -> "#F0FFFF",
                        "peru" -> "#CD853F")
      val colors2 = Map("blue" -> "#0033FF",
                        "yellow" -> "#FFFF00",
                        "red" -> "#FF0000")
      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )


      // use two maps with ++ as method
      colors = colors1.++(colors2)
打印映射的键和值：
colors.keys.foreach{ i =>
                           print( "Key = " + i )
                           println(" Value = " + colors(i) )}
检查映射中的键：
colors.contains( "red" )
访问的元组 t 的元素
val t = (4,3,2,1)
val sum = t._1 + t._2 + t._3 + t._4

遍历元组：

val t = (4,3,2,1)
      t.productIterator.foreach{ i =>println("Value = " + i )}
Option[T]是容器对于给定的类型的零个或一个元件
模式匹配
def main(args: Array[String]) {
      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
      println("show(capitals.get( "Japan")) : " +
                                          show(capitals.get( "Japan")) )
      println("show(capitals.get( "India")) : " +
                                          show(capitals.get( "India")) )
   }
     def show(x: Option[String]) = x match {
      case Some(s) => s
      case None => "?"
   }
使用getOrElse()来访问值或使用默认值
迭代器不是集合，而是一种由一个访问的集合之一的元素
next和hasNext
类
class Yiibai(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
   }
}
class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Yiibai(xc, yc){
   var z: Int = zc


   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Yiibai x location : " + x);
      println ("Yiibai y location : " + y);
      println ("Yiibai z location : " + z);
   }
}
object Test {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);


      // Move to a new location
      loc.move(10, 10, 5);
   }
}

判断与循环

def main (args: Array[String]) {
    println("Hello, world!")
    var x = 30;
    if( x < 20 ){
      println("This is if statement");
    }else{
      println("This is else statement");
    }
    println(addInt(1,2));
    while( x < 32 ){//while循环的关键点是循环可能不会永远运行
      println( "Value of x: " + x );
      x += 1;
    }
    do{
      println( "Value of xx: " + x );
      x = x + 1;
    }while( x < 33 )


    var a = 0;
    // for loop execution with a range
    for( a <- 1 to 10){
      println( "Value of a: " + a );
    }
    for( a <- 1 until 10){
      println( "Value of a: " + a );
    }


    var b = 0;
    // for loop execution with a range
    for( a <- 1 to 3; b <- 1 to 3){
      println( "Value of a: " + a );
      println( "Value of b: " + b );
    }


    val numList = List(1,2,3,4,5,6);
    // for loop execution with a collection
    for( a <- numList ){
      println( "Value of a: " + a );
    }
    for( a <- numList
         if a != 3; if a < 8 ){
      println( "Value of a: " + a );
    }


    // for loop execution with a yield
    val retVal = for{ a <- numList
                      if a != 3; if a < 8
    }yield a
    // Now print returned values using another loop.
    for( a <- retVal){
      println( "Value of a: " + a );
    }
  }
  def addInt( a:Int, b:Int ) : Int = {
    var sum:Int = 0
    sum = a + b
    return sum
  }

模式匹配包括替代的序列，每个开始使用关键字case

 def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
   }
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
正则表达式
val pattern = "Scala".r   //调用r()方法 字符串隐式转换为一个RichString并调用该方法来获得正则表达式的一个实例

val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
val pattern = new Regex("(S|s)cala")  //a|b  匹配a或b。
val str = "Scala is scalable and cool"
println((pattern findAllIn str).mkString(","))
更换匹配的文本，可以使用replaceFirstIn()以取代第一个匹配项或replaceAllIn()
val pattern = "(S|s)cala".r
val str = "Scala is scalable and cool"
println(pattern replaceFirstIn(str, "Java"))
. 匹配除了换行符的任何字符
[Rr]uby 匹配 "Ruby" 或"ruby"    [...]
匹配括号内任何单个字符。
rub[ye] 匹配"ruby" 或 "rube"
[aeiou] 匹配任何一个小写元音
[0-9] 匹配任何数字;同 [0123456789]
[a-z] 匹配任意小写ASCII字母
[A-Z] 匹配任意大写ASCII字母
[a-zA-Z0-9] 匹配任何上述
[^aeiou] 匹配元音以外的任何一个小写字符   [^...]
匹配任何单个字符不是在括号中
[^0-9] 匹配数字以外的任何其他
d 匹配一个数字: [0-9]
D 匹配一个非数字: [^0-9]
s 匹配一个空白字符: [ f]
S 匹配非空白: [^ f]
w 匹配一个字符: [A-Za-z0-9_]
W 匹配 一个非单词字符: [^A-Za-z0-9_]
ruby? 匹配 "rub" or "ruby": the y is optional  re?
匹配0或1发生前表达式。
ruby* 匹配 "rub" plus 0 or more ys
ruby+ 匹配 "rub" plus 1 or more ys
d{3} 匹配只有 3 个数字   d
匹配数字。相当于 [0-9]. re{ n} 精确匹配n个前面表达式的数量。
d{3,} 匹配 3 个或多个数字  re{ n,}
匹配n或多次出现前面的表达。
d{3,5} 匹配3, 4, 或5 个数字  re{ n, m}
至少匹配n和在前面的表现最为m次出现。
Dd+ 不分组: + repeats d   re+
匹配1个或多个的先前东西
(Dd)+/ 分组: + repeats Dd 对  D
匹配非数字。(re) 组正则表达式并记住匹配的文本
([Rr]uby(, )?)+ 匹配 "Ruby", "Ruby, ruby, ruby", 等

抛出异常

throw new IllegalArgumentException
try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }

文件I/O

写入文件
val writer = new PrintWriter(new File("test.txt" ))
writer.write("Hello Scala")
writer.close()
从屏幕读取一行：
print("Please enter your input : " )
val line = Console.readLine
println("Thanks, you just typed: " + line)
读取文件内容
Source.fromFile("test.txt" ).foreach{
         print
      }