Scala编程快速入门系列（一）详解编程语言

1. Scala简介

Scala是一种针对JVM将函数和面向对象技术组合在一起的编程语言。所以Scala必须要有JVM才能运行，和Python一样，Scala也是可以面向对象和面向函数的。Scala编程语言近来抓住了很多开发者的眼球。它看起来像是一种纯粹的面向对象编程语言，而又无缝地结合了命令式和函数式的编程风格。Scala的名称表明，它还是一种高度可伸缩的语言。Scala的设计始终贯穿着一个理念：创造一种更好地支持组件的语言。Scala融汇了许多前所未有的特性，而同时又运行于JVM之上。随着开发者对Scala的兴趣日增，以及越来越多的工具支持，无疑Scala语言将成为你手上一件必不可少的工具。Spark最最源生支持的语言是Scala。Spark主要支持java、Scala、Python和R。Scala的底层协议是akka（异步消息传递）。

2. Scala安装与开发工具

Scala版本使用Scala-2.10.x。

JDK使用jdk-1.8。

开发工具使用Intellij IDEA-2017.3.5。

二、Scala数据类型 1. 数据类型

 

scala拥有和java一样的数据类型，和java的数据类型的内存布局完全一致，精度也完全一致。其中比较特殊的类型有Unit，表示没有返回值；Nothing表示没有值，是所有类型的子类型，创建一个类就一定有一个子类是Nothing；Any是所有类型的超类；AnyRef是所有引用类型的超类；注意最大的类是Object。

上表中列出的数据类型都是对象，也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法的。例如数字1可以调方法，使用1.方法名。

 

 

如上两图所示，可见所有类型的基类与Any。Any之后分为两个AnyVal与AnyRef。其中AnyVal是所有数值类型的父类型，AnyRef是所有引用类型的父类型。

与其他语言稍微有点不同的是，Scala还定义了底类型。其中Null类型是所有引用类型的底类型，及所有AnyRef的类型的空值都是Null；而Nothing是所有类型的底类型，对应Any类型；Null与Nothing都表示空。

在基础类型中只有String是继承自AnyRef的，与Java，Scala中的String也是内存不可变对象，这就意味着，所有的字符串操作都会产生新的字符串。其他的基础类型如Int等都是Scala包装的类型，例如Int类型对应的是Scala.Int只是Scala包会被每个源文件自动引用。

标准类库中的Option类型用样例类来表示拿着可能存在、也可能不存在的值。样例子类Some包装了某个值，例如：Some(“Fred”)；而样例对象None表示没有值；这比使用空字符串的意图更加清晰，比使用null来表示缺少某值的做法更加安全（避免了空指针异常）。

2. 声明与定义

字段/变量的定义Scala中使用var/val 变量/不变量名称: 类型的方式进行定义，例如

var index1 : Int= 1 

val index2 : Int= 1

在Scala中声明变量也可以不声明变量的类型。 

常量的声明 val

使用val来声明一个常量。与java一样，常量一次赋值不可修改。

val name : String="Yang"//这是完整的写法，可以省略类型，如下所示: 

val name="Yang"

var name : String = "Yang" //这是完整的写法，可以省略类型，如下所示: 

//var name = "Yang" //变量或常量声明时，类型可以省略，Scala内部机制会推断。 

name = "Yang2"//变量的值可以修改

def f=a*b;//只是定义a*b表达式的名字，并不求值，在使用的时候求值。这里Scala已经推断出了f函数的返回值类型了，因为a和b都是Int，所以f也是Int。从控制台可以看出这个效果：

def f=a*b//如果写成val f，这时会直接算出结果。这是定义函数和定义常量的区别。

3. 字符串

单行注释：//

单行字符串

同Java

多行字符串/多行注释

scala中还有类似于python的多行字符串表示方式（三个单引号），用三个双引号表示分隔符，如下：

val strs=”””
 多行字符串的第一行 

 多行字符串的第二行 

 多行字符串的第三行”””

S字符串，可以往字符串中传变量。

S字符串可以调用变量/常量，在字符串前面加s，在字符串中使用${变量/常量名的数学表达式}，来调用变量。如图所示，字符串之前不写s，则原样输出。${变量/常量的数学表达式}，如上图所示对常量age进行计算。

传入的参数可以进行相应的格式的转化。例如：

先val height = 1.7//声明了一个一位小数的常量身高。

println(f $name%s is $height%.2f meters tall )//在字符串前加f使用f字符串的功能，包含了s字符串的调用变量的功能，并且在变量名后面跟%格式来格式化变量。例如%s是表示字符串，%.2f是精确到百分位。

println(s $name%s is $height%.2f meters tall )//如果这里使用s字符串则只能包含s字符串调用变量的功能，不能使用f字符串格式化的功能。

println( $name%s is $height%.2f meters tall )//如果不加s也不加f则原样输出。 

  R字符串和Python中的raw字符串是一样的，在java中要原样输出一些带/的字符，如/t、/n等需要在前面再加一个/转义，不然就会输出制表符、回车。比如/n就要写成//n，才能原样输出/n，但是加上raw则不需要。例如：

 

注意r字符串的使用是在字符串前面加raw，而不是r。

4. 懒加载

在Scala的底层有一个延迟执行功能，其核心是利用懒加载。如下图懒加载常量：

对比上面两条命令的差异，可以发现没有lazy的命令立即执行，并将1赋给常量x。而带有lazy的命令没有立即执行方法体，而是在后面val a=xl时才执行了方法体的内容。

其中lazy是一个符号，表示懒加载；{println( I mtoolazy );1}，花括号是方法体，花括号中的分号是隔开符，用于隔开两句话，方法体的最后一行作为方法的返回值。

如上图所示，定义函数的效果和懒加载方式的效果一样，只有在调用的时候才会执行方法体。

三、Scala 函数 1. 函数的定义 函数定义的一般形式

如上图所示，其中def关键字表示开始一个函数的定义；max是函数名；小括号中的x和y表示参数列表，用逗号隔开；小括号中的参数后面的:类型表示参数的类型；参数列表之后的:类型是函数的返回值类型；等号表示要返回值，如果没有等号和返回值类型就表示不需要返回值，或返回值类型改为Unit也表示不需要返回值；花括号中的内容是方法体，方法体的最后一行将作为函数的返回值，这里的最后一行是x或者y。

函数定义的简化形式

省略return（实际已经简化）。Scala中，可以不写return，如果不写return则自动将最后一行作为返回值，如果没有返回值，则函数的返回类型为Unit，类似于Java中void。

函数和变量一样，可以推断返回类型。所以上述函数可以简写成：

def max( x : Int, y : Int) = {if(x y) x else y}

这里还可以进一步把方法体的花括号也省略，所以函数可以进一步简化为：

def max(x : Int, y : Int) = if(x y) x else y

object HelloScala { 

 // 定义sayMyName方法，方法需要一个参数，类型是String，默认值是Jack。方法体前面没有等号，就相当于没有返回值，Unit 

 def sayMyName(name : String = "张三"){ 

 println(name) 

 //函数的调用需要main函数 

 def main(args: Array[String]) { 

 sayMyName("李四")//如果没有使用参数sayMyName()则使用默认值张三，如果使用参数"李四"，则输出李四 

}

多个相同类型的参数可以使用*表示，例如(k : Int*)表示多个Int类型的参数，具体数量不确定，类似于java中的可变参数。

object HelloScala { 

 def sumMoreParameter(k : Int*)={ 

 var sum=0 

 for(i - k){//使用foreach( -)来遍历元素k 

 println(i) 

 sum += i 

 sum 

 def main(args: Array[String]) { 

 println(sumMoreParameter(3,5,4,6))//这里传递的参数个数可变 

}

当然也可以定义参数个数确定的函数，如下：

object HelloScala { 

 def add(a:Int,b:Int) = a+b//省略了方法体的花括号和方法返回值类型 

 def main(args: Array[String]) { 

 println(add(3,6)) 

} 

def add(a:Int,b:Int) = a+b def add2 = add(_:Int,3)//调用add方法，使用下划线是一个符号，可以不取变量名，参数的类型是Int def main(args: Array[String]) { println(add2(5))//这里的结果和add(2,5)=7是一样的。 } 2. 递归函数

递归实际上就是方法自己调自己，也可以看成是递推公式。以阶乘为例：

案例四（递归函数）

object HelloScala { 

 def fact(n: Int): Int = if (n = 0) 1 else n * fact(n - 1)//注意这里需要写方法的返回值类型Int，因为递归的方法体里面还有这个函数，所以无法对结果的类型进行推断。 

 def main(args: Array[String]) { 

 println(fac(6)) 

}

3. 柯里化函数

在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。有时需要允许他人一会在你的函数上应用一些参数，然后又应用另外的一些参数。例如一个乘法函数，在一个场景需要选择乘数，而另一个场景需要选择被乘数。所以柯里化函数就是将多个参数分开写，写在不同的小括号里，而不是在一个小括号中用逗号隔开。例如：

案例五（柯里化函数）
def mulitply(x:Int)(y:Int) = x*y def mulitply2 = mulitply(2)_;//柯里化就是把参数可以分开来，把部分函数参数可以用下划线来代替 def main(args: Array[String]) { println(mulitply2(3)) } 4. 匿名函数 匿名函数的概念

匿名函数就是没有名字的函数。例如 (x : Int, y : Int) = x * y 。这里有一点要注意，如果在“= ”前加上了这个函数的返回类型，如：(x:Int, y : Int) : Int= x * y，反而会报错。原因是在一般情况下，Scala编译器会自动推断匿名函数参数的类型，所以可以省略返回类型，因为返回类型对于编译器而言是多余的。

案例六（匿名函数，声明方式）

匿名函数的标识就是= ，没有方法名，只有一个小括号（这里也没有参数），方法体就是直接返回的123（是{123}的简写）。val t是将声明的这个匿名函数对象付给了常量t。这里看上去像是多此一举，但是因为匿名函数往往是作为参数传给一个函数的，所以匿名函数这样的形式很有必要。

案例七（匿名函数，做函数的参数）

定义testfunc方法中需要一个参数c，其类型是()= Int，而()= Int是匿名函数类型的定义。这个表达式是指传进来参数需要是一个匿名函数，该匿名函数没有参数，返回值是Int，比如t就是这样的匿名函数。

在testfunc中是打印，在方法体里面才真正的调用传进来的函数；传进来的时候只是传进来了一个方法体，并没有正真的调用。只有在里面有了()时才真正的调用。

println(testfunc(t))打印的结果有两行，第一行是123、第二行是()，因为testfunc这个方法没有返回值。如果将函数testfunc方法体前面加个等号就能打印出方法体最后一行（返回值）333。

案例八（匿名函数，有参匿名函数的声明）

object HelloScala { 

 val b = (a:Int)= a*2;//把一个能将传进来的参数乘以2的匿名函数对象赋给b 

 def main(args: Array[String]) { 

 println(b(8))//打印的结果为16 

}

def main(args: Array[String]) { testf1((a:Int,b:Int)= {println(a*b);a*b})//打印的结果为两行225 }

定义的一个以有参匿名函数作为参数的函数testf1，其参数名是t，参数类型是(Int,Int)= Int这样的匿名函数，它需要两个Int类型的参数经过相应的转化，转为一个Int类型的返回值。

t(15,15)这方法体里才真正的调用匿名函数t，这里的参数是写死的，即在testf1方法里才有真正的数据。但是真正对数据的操作是交给匿名函数的，这就体现了函数式编程的特点。

5. 嵌套函数

嵌套函数可以认为是复合函数，是def了的一个函数中又def了一个函数。 例如：

案例十（嵌套函数）
def f(x:Int, y:Int ,z:Int) : Int = { //针对需求，要定义个两个数相乘的函数g=a*b，相当于复合函数。 def g(a:Int, b:Int):Int = { a*b g((x+y),z) def main(args: Array[String]) { println(f(2,3,5)) } 6. 循环函数

和Java的类似，Scala有foreach循环。

案例十一（foreach循环）
def for_test1() : Unit = { //" -"这个符号表示foreach，使用"to"则包含末尾（闭区间），如果是until则不包含（左闭右开）。这里的to是Scala内建的一个方法。 for(i - 1 to 50 ){ //可以从源码看到to是RichInt类型的方法 println(i) def main(args: Array[String]): Unit = { for_test1() }
def for_test2() = { //可以直接在for括号里面添加if过滤条件，比Java更简洁。多个条件使用分号隔开 for(i - 0 until 1000 if (i % 2) == 0 ; if (i % 3) == 0 ){ println("I: "+i) def main(args: Array[String]) { for_test2() } 7. 分支函数

和Java的switch…case…default分支类似，Scala有match…case…case_结构。

object HelloScala { 

 def testmatch(n:Int)={ 

 n match { 

 case 1 = {println("是1") ;n}//"= "表示有匿名函数，如果与1匹配上就走这个方法体 

 // break;在Scala中不需要写break，也不能写break，Scala中没有break关键字。 

 case 2 = println("是2") ;n//方法体的花括号可以省略。 

 case _ = println("其他") ; "others" //case _：default 

 def main(args: Array[String]) { 

 println(testmatch(1))//结果为是1 /n 1 

 println(testmatch(0))//结果为其他 /n others 

}

原创文章，作者：Maggie-Hunter，如若转载，请注明出处：https://blog.ytso.com/12989.html

cjavapythonwindows