Scala学习笔记：01-Scala的基础语法和基本数据类型

数据类型

数据类型	描述
Byte	8位有符号补码整数。数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float	32 位, IEEE 754 标准的单精度浮点数
Double	64 位 IEEE 754 标准的双精度浮点数
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列
Boolean	true或false
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类

基本语法

变量

Scala 使用var 声明变量,val 声明常量
eg.

• 声明单个变量:

val name:String = "zhangsan";
var name:String = "list";

• 声明多个变量

val name,age = "zhangsan";

流程控制IF ELSE

Scala的流程控制语句的语法和java以及C语言的语法一样

def test(a:Int):Unit = {
    if(a==5){
      println("a is 5");
    }
    else if ( a == 6){
      println("a is 6")
    }
    else{
      println("a is not 5 and a is not 6")
    }
}

循环

FOR循环

语法

for( var x <- Range ){
   statement(s);
}

Range 可以是一个数字区间，表示i to j 或者 i until j；

• i to j，前闭后闭，包括j

for (i <- 1 to 3){
    print(i);
}

输出:1 2 3

• i until j, 前闭后开,不包括j

for (i <- 1 until 3){
    print(i);
}

输出:1 2

• For多重循环

for (i <- 1 until 3; j <- 1 until 3){
    print((i,j));
}

输出:(1,1) (1,2) (2,1) (2,2)

上述写法同下：

    for (i <- 1 until 3){
      for( j <- 1 until 3){
        print((i,j));
      }
    }

• For循环使用条件过滤，多个条件之间是“且”的关系

    for (i <- 1 until 6; if i !=3; if i<4){
      println(i);
    }

输出：1, 2

• For 循环迭代Collection

var nameList: Set[String] = Set("1","2","3");
for (item <- nameList) {
    println(item);
}

• For + yield

For + yield 可以构造成一个新的可迭代对象，类似于python中的生成器。

    val nameList: Set[String] = Set("1","2","3");
    var name = for{
      item <- nameList
    }yield item

    for( a <- name){
      println(a)
    }

While 循环

while (true){
    statement(=================);
}

do … while 循环

do{
    
}while(true)

函数声明

• 无返回值的函数声明(Unit 相当于void)

def test(a:Int,b:String): Unit ={
    println(a);
}

• 带返回值的函数声明
  eg. 定一个函数，函数有两个参数，类型都为Int，函数的返回值也为Int。

  def sum(a: Int,b: Int): Int ={
    return a+b;
  }

• 多个返回参数的函数声明

  def sum(a: Int,b: Int): (Int,Int) ={
    return (a,b);
  }

• 匿名函数的声明

语法:(参数) => 函数体;

object HelloWorld{

  def main(args:Array[String]): Unit ={
    var factor = 3;
    var multiLine = (i:Int) => i* factor;

    println(multiLine(3))
  }
  
}

异常处理

Scala 的异常处理和其它语言比如 Java 类似。

Scala 的方法可以通过抛出异常的方法的方式来终止相关代码的运行，不必通过返回值。

捕获异常

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Test {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      }
   }
}

抛出异常

Scala 抛出异常的方法和 Java一样，使用 throw 方法，例如，抛出一个新的参数异常：

throw new IllegalArgumentException

finally语句

finally 语句用于执行不管是正常处理还是有异常发生时都需要执行的步骤

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Test {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }
}

模式匹配

Scala 提供了强大的模式匹配机制，应用也非常广泛。

一个模式匹配包含了一系列备选项，每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

• match 对应 Java 里的 switch，但是写在选择器表达式之后。即： 选择器 match {备选项}。

• match 表达式通过以代码编写的先后次序尝试每个模式来完成计算，只要发现有一个匹配的case，剩下的case不会继续匹配，所以无需break

object Test{

  def matchCase(name: String): String = name match{
    case "zhangsan" => {return "hello,zhangsan"}
    case "lisi" => {return "hello,lisi"}
  }
  def main(args: Array[String]): Unit = {

    val rt = matchCase("zhangsan")
    println(rt)
  }
}

match 在函数体内

object Test {
   def main(args: Array[String]) {
     
      val x = Test(5)
      println(x)

      x match
      {
         case Test(num) => println(x + " 是 " + num + " 的两倍！")
         //unapply 被调用
         case _ => println("无法计算")
      }

   }
   def apply(x: Int) = x*2
   def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}

Scala 提取器(Extractor)

提取器是从传递给它的对象中提取出构造该对象的参数。

Scala 标准库包含了一些预定义的提取器，我们会大致的了解一下它们。

Scala 提取器是一个带有unapply方法的对象。unapply方法算是apply方法的反向操作：unapply接受一个对象，然后从对象中提取值，提取的值通常是用来构造该对象的值。

object Test {
   def main(args: Array[String]) {
     
      println ("Apply 方法 : " + apply("Zara", "gmail.com"));
      println ("Unapply 方法 : " + unapply("Zara@gmail.com"));
      println ("Unapply 方法 : " + unapply("Zara Ali"));

   }
   // 注入方法 (可选)
   def apply(user: String, domain: String) = {
      user +"@"+ domain
   }

   // 提取方法（必选）
   def unapply(str: String): Option[(String, String)] = {
      val parts = str split "@"
      if (parts.length == 2){
         Some(parts(0), parts(1))
      }else{
         None
      }
   }
}