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\nyou"

res0: String =

hello

you

scala> raw"hello\nyou"

res1: String = hello\nyou

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(_ != "\n").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子句的方式来抛出。

巴特西