Scala基础语法学习（一）

1. val和var的区别

val定义的是一个常量，无法改变其内容

scala> val s = 0
s: Int = 0

scala> s = 2
<console>:12: error: reassignment to val
       s = 2
         ^

如果要声明其值可变的变量，可以使用var

scala> var s = 0
s: Int = 0

scala> s = 5
s: Int = 5

在scala中建议使用val，除非你真的想改变他的内容。

2. 基本类型

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

3.字符串

3.1 测试字符串是否相等

object Demo{
  def main(args: Array[String]): Unit = {
    val s = "hello world";
    println(s)
    val s1 = "Hello";
    val s2 = "Hello";
    val s3 = "H"+"ello";
    println(s1.equals(s2))
    println(s1.eq(s3))
    println(s1 == s2)
  }
}

结果：
hello world
true
true
true

Process finished with exit code 0

在Scala中，可以用＝＝方法测试对象的相等性。这与Java中用equals方法比较两个对象不同。

3.2 多行字符串

在Scala中可以使用三个引号创建多行字符串：

object Demo{
  def main(args: Array[String]): Unit = {
    val s =
      """ohh
        haha
            nonono
      """;
    println(s)
  }
}

输出结果：

ohh
        haha
            nonono
      

Process finished with exit code 0

结果中可以看到每从第二行起每一行都是以空格开头的，要解决这个问题可以这样做：在多行字符串结尾添加stripMargin方法，并且在第一行后面的所有行以管道符"|"开头：

object Demo{
  def main(args: Array[String]): Unit = {
    val s =
      """ohh
        |haha
            |nonono
      """.stripMargin;
    println(s)
  }
}

结果：
ohh
haha
nonono
      

Process finished with exit code 0

如果你不想用"|",你也可以用任意字符：

val s =
	      """ohh
	        /haha
	            /nonono
	      """.stripMargin("/");

也会有同样的输出效果。

3.3 字符串中的变量替换

Scala支持在字符串中代换变量。

如果某个字符串需要插入变量，需要在该字符串的前面加上字母"s"标志，然后再字符串中放入变量，每个变量都应该以"$"开头。

object Demo{
  def main(args: Array[String]): Unit = {
    val name = "xiaoming"
    val age = 12
    var s = s"$name is a man and he is $age years old"
    println(s)
  }
}

结果：
xiaoming is a man and he is 12 years old

Process finished with exit code 0

在字符串前面添加"s"，其实是在创建一个处理字符串字面量。

在字符串字面量中使用表达式

除了把变量放到字符串中外，还可以用花括号把表达式包起来再放到字符串中。根据官方文档，"${}"内可嵌入任何表达式。

val age = 12
println(s"are you kidding me,I always thought you were only ${age + 1} years old")

字符串插值f

如果有一个需求是不改变原变量的前提下给该值添加两位小数，该如何实现呢？

val weight = 111
println(f"ohh dear,I never realized that you have $weight%.2f kilograms")

结果：
ohh dear,I never realized that you have 111.00 kilograms

这个简单的需求繁盛了“f字符串插值”。一个可以通过printf个时候内部字符串的方法。

用这种方法只需要如下两步即可：

1.在字符串前面加上字母f。

2.在变量之后使用printf的格式化操作符。

raw插入符

raw插入符“不会对字符串中的字符进行转义”。

scala> s"hello
you"
res0: String =
hello
you

scala> raw"hello
you"
res1: String = hello
you

printf格式化常用字符：

格式化符号	描述
%c	字符
%d	十进制数字
%e	指数浮点数
%f	浮点数
%i	整数
%o	八进制
%s	字符串
%u	无符号十进制
%x	十六进制
%%	打印一个百分号
\%	打印一个百分号

3.4 遍历字符串中的字符

Scala提供了很多方式遍历字符串以及对字符串进行操作，常用的有map，foreach，for，filter。

scala> val s = "you are a kid".map(c => c.toUpper)
s: String = YOU ARE A KID

scala> val s = "you are a kid".map(_.toUpper)
s: String = YOU ARE A KID

scala> val s = "you are a kid".filter(_ != "
").map(v => v)                   ^
s: String = you are a kid

val name = "542352354"
for(c <- name){
  println(c)
}
name.foreach(println)

4. 数值

Scala内建数值类型包括：

• Char
• Byte
• Short
• Int
• Long
• Float
• Double

4.1 从字符串到数字

使用String的to*方法。

scala> "200".toInt
res0: Int = 200

如果需要转换的字符串不确定是几进制的，可以通过参数的形式来判断：

val a = Integer.parseInt("01101",2)
println(a)

结果：
13

Process finished with exit code 0

4.2 ++和- -

Scala中没有++ 和 - -这样的操作。所以要是想使用的话只能使用变形的方法：数值类型的可以使用 += 或者是 -= 来操作：

var a = 4
a += 3
println(a)
a -= 5
println(a)
结果：
7
2

4.3 处理大数

Scala提供了BigInt和BigDecimal类来创建一个大数：

var a = BigInt(987654321)
var b = BigDecimal(987654321.543433)
var c = a + a
var d = a * a
var e = b + b
var f = b * b
println(a,b,c,d,e,f)

结果为：
(987654321,987654321.543433,1975308642,975461057789971041,1975308643.086866,975461058863418942.543305425489)

我们看到和java中不一样的是：BigDecimal对象支持所有普通数值类型的操作符。

4.4 生成随机数

Scala中也提供了Random类，用于随机数生成。

var a = Random.nextDouble()

4.5 创建一个数值区间、列表或者数组

使用Int的to方法创建数值区间：

for(i <- 0 to 9){
  println(i)
}
结果：
0
1
2
3
4
5
6
7
8
9

Process finished with exit code 0

也可以使用by方法设置步长：

for(i <- 0 to 9 by(2)){
  println(i)
}
结果：
0
2
4
6
8

Process finished with exit code 0

不得不说，跟java比是简洁太多了。

5. 控制语句

Scala中的if/else语句和java中的一样使用。

5.1 for循环

Scala中的for循环也很简单，使用"<-"符号来获取循环指针。

var a = Array("liming","hanmeimei","xiaohong")
for(user <- a){
  println(user)
}

结果：
liming
hanmeimei
xiaohong

Process finished with exit code 0

for循环计数器：

for(i <- 0 to 5){
	println(i)
}

for(i <- until a.length){
	println(i)
}

遍历字符串和数组时，你通常需要使用 0 到 n-1 的区间，这个时候可以使用 until 方法而不是 to 方法。 until 方法返回一个并不包含上限的区间。

封装index和值：

var a = Array("liming","hanmeimei","xiaohong")
for((e,count) <- a.zipWithIndex){
  println(e,count)
}

结果：

(liming,0)
(hanmeimei,1)
(xiaohong,2)

Process finished with exit code 0

遍历Map：

val map = Map("name"->"xiaoming","age"->12,"sex"->1)
for((k,v) <- map){
  println(k,v)
}

结果：
(name,xiaoming)
(age,12)
(sex,1)

在for循环中使用多个计数器：

Scala允许在一个for循环中使用多个计数器，这个有点高端：

var i = 1
var j = 1
var k = 1
for(i <- 1 to 3;j <- 1 to 4;k <- 1 to 5){
  println(i,j,k)
}

结果：

(1,1,1)
(1,1,2)
(1,1,3)
(1,1,4)
(1,1,5)
(1,2,1)
...
(3,4,2)
(3,4,3)
(3,4,4)
(3,4,5)

当我们创建二维数组或者三维数组，就再也不用像java中那样需要三个for循环了。

for循环中嵌入if：

for(i <- 1 to 10 if i % 2 == 0){
	println(i)
}

过滤循环条件。

实现break和continue：

Scala中没有break和continue关键字。但是提供了另外的方式来实现该功能,scala.util.control.Breaks类提供了类似的方法：

import util.control.Breaks._

object Demo{
  def main(args: Array[String]): Unit = {
    breakable{
      for( i <- 1 to 10){
        println(i)
        if(i == 5)
          break
      }
    }
  }

}

结果：

1
2
3
4
5

Process finished with exit code 0

注意：break和breakable不是关键字而是util.control.Breaks类中的方法。

再来看一下continue是如何执行的：

import util.control.Breaks._

object Demo{
  def main(args: Array[String]): Unit = {
      for( i <- 1 to 10){
          breakable{
            if(i == 5){
              break
            }else{
              println(i)
            }
          }
      }
  }
}

结果：
1
2
3
4
6
7
8
9
10

Process finished with exit code 0

其实就是换了一种方式使用breakable哈。

Scala中的switch/case：

var i = 0
i match {
  case 1 => println(1)
  case 2 => println(2)
}

在Scala中使用match函数来表示switch。

在Scala中一个case语句可以匹配多个条件，你可以这样用：

var i = 0
i match {
  case 1 | 3 | 5 => println(1)
  case 2 | 4 | 6=> println(2)
}

使用"|"分割。对于字符串和其他类型使用的语法是一样的。

Scala中的try/catch

使用方式和java基本一样，只是异常的表达形式与java有区别：

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

异常使用case子句的方式来抛出。