Scala精华之处就在这里，拿去，面试也不怕

Scala精华之处就在这里，拿去，面试也不怕

作者： 左右 2021-10-11 07:46:50

云计算

虚拟化 Scala作为一门面向对象的函数式编程语言，把面向对象编程与函数式编程结合起来，使得代码更简洁高效易于理解。这就是Scala得到青睐的初衷。

10年积累的成都做网站、网站制作、成都外贸网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先建设网站后付款的网站建设流程，更有温江免费网站建设让你可以放心的选择与我们合作。

[[427956]]

本文转载自微信公众号「大数据左右手」，作者左右 。转载本文请联系大数据左右手公众号。

前言

Scala作为一门面向对象的函数式编程语言，把面向对象编程与函数式编程结合起来，使得代码更简洁高效易于理解。这就是Scala得到青睐的初衷。

Scala作为一门JVM的语言，大数据生态的大部分组件都是Java语言开发的，而Scala可以与Java无缝混编，因此可以很好地融合到大数据生态圈。

主要内容

一些基础东西不再罗列，比如开发环境，循环，异常，泛型等等，本篇只介绍独到，特殊的精华地方，注重概念理解与用法。

1.变量和数据类型

2.函数式编程

(a)高阶函数

(b)匿名函数

(c)闭包

(d)函数柯里化

3.面向对象

(a)类与对象

(b)伴生对象

(c)特质

4.模式匹配

5.隐式转换

变量和数据类型

变量(var声明变量，val声明常量)

var 修饰的变量可改变

val 修饰的变量不可改变

但真的如此吗?

对于以下的定义

  
 
 
 
    
   
  
  
  
  1. class A(a: Int) { 
    2. 
   
  
  
  
  2.   var value = a 
    3. 
   
  
  
  
  3. } 
    4. 
   
  
  
  
  4.  
    5. 
   
  
  
  
  5. class B(b: Int) { 
    6. 
   
  
  
  
  6.   val value = new A(b) 
    7. 
   
  
  
  
  7. } 
    8.

效果测试

  
 
 
 
    
   
  
  
  
  1. val x = new B(1) 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. x = new B(1) // 错误，因为 x 为 val 修饰的，引用不可改变 
    4. 
   
  
  
  
  4. x.value = new A(1) // 错误，因为 x.value 为 val 修饰的，引用不可改变 
    5. 
   
  
  
  
  5.  
    6. 
   
  
  
  
  6. x.value.value = 1 // 正确，x.value.value 为var 修饰的，可以重新赋值 
    7.

事实上，var 修饰的对象引用可以改变，val 修饰的则不可改变，但对象的状态却是可以改变的。

可变与不可变的理解

我们知道scala中的List是不可变的，Map是可变和不可变的。观察下面的例子

var可变和List不可变的组合

  
 
 
 
    
   
  
  
  
  1. var list = List("左","右") 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. list += "手" 
    4.

理解就是

var list指向的对象是 List("左","右")

后面修改list的指向，因为是可变的var修饰，list又可以指向新的 List("左","右","手")

如果是以下(会报错的)

  
 
 
 
    
   
  
  
  
  1. val list = List("左","右") 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. list += "手" 
    4.

val var与Map可变和不可变

  
 
 
 
    
   
  
  
  
  1. var map = Map( 
    2. 
   
  
  
  
  2.       "左" -> 1, 
    3. 
   
  
  
  
  3.       "右" ->1, 
    4. 
   
  
  
  
  4.     ) 
    5. 
   
  
  
  
  5. map+=("手"->1) 
    6. 
  
 
 
 
  
 
 
 
    
   
  
  
  
  1. val map=scala.collection.mutable.Map( 
    2. 
   
  
  
  
  2.   "左" -> 1, 
    3. 
   
  
  
  
  3.   "右" ->1, 
    4. 
   
  
  
  
  4. ) 
    5. 
   
  
  
  
  5.  
    6. 
   
  
  
  
  6. map+=("手"->1) 
    7.

理解

不可变的Map在添加元素的时候，原来的Map不变，生成一个新的Map来保存原来的map+添加的元素。

可变的Map在添加元素的时候，并不用新生成一个Map，而是直接将元素添加到原来的Map中。

val不可变的只是指针，跟对象map没有关系。

数据类型

数据类型 描述
Byte8位有符号补码整数。数值区间为 -128 到 127
Short16位有符号补码整数。数值区间为 -32768 到 32767
Int32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float32 位, IEEE 754 标准的单精度浮点数
Double64 位 IEEE 754 标准的双精度浮点数
Char16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String字符序列
Booleantrue或false
Unit表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Nullnull 或空引用
NothingNothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。
AnyAny是所有其他类的超类
AnyRefAnyRef类是Scala里所有引用类(reference class)的基类

函数式编程

高阶函数

高阶函数是指使用其他函数作为参数、或者返回一个函数作为结果的函数。在Scala中函数是"一等公民"。

简单例子

  
 
 
 
    
   
  
  
  
  1. val list=List(1,2,3,4) 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. val function= (x:Int) => x*2 
    4. 
   
  
  
  
  4.  
    5. 
   
  
  
  
  5. val value=list.map(function) 
    6.

方法为函数

  
 
 
 
    
   
  
  
  
  1. def main(args: Array[String]): Unit = { 
    2. 
   
  
  
  
  2.     val list=List(1,2,3,4) 
    3. 
   
  
  
  
  3.     val value=list.map(function) 
    4. 
   
  
  
  
  4. } 
    5. 
   
  
  
  
  5.  
    6. 
   
  
  
  
  6. def function   (x:Int)=x*2 
    7.

返回函数的函数

  
 
 
 
    
   
  
  
  
  1. def calculate(symbol:String): (String,String)=>String ={ 
    2. 
   
  
  
  
  2.     symbol match { 
    3. 
   
  
  
  
  3.       case "拼接方式1" => (a:String,b:String)=> s"拼接方式1:$a , $b" 
    4. 
   
  
  
  
  4.       case "拼接方式2" => (a:String,b:String)=> s"拼接方式2: $b , $a" 
    5. 
   
  
  
  
  5.     } 
    6. 
   
  
  
  
  6.   } 
    7. 
  
 
 
 
  
 
 
 
    
   
  
  
  
  1. val function: (String, String) => String = calculate("拼接方式2") 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. println(function("大数据", "左右手")) 
    4.

匿名函数

Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。

使用匿名函数后，我们的代码变得更简洁了。

  
 
 
 
    
   
  
  
  
  1. var inc = (x:Int) => x+1 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. var x = inc(7)-1 
    4.

也可无参数

  
 
 
 
    
   
  
  
  
  1. var user = () => println("大数据左右手")  
    2.

闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

简单理解就是：函数内部的变量不在其作用域时，仍然可以从外部进行访问。

  
 
 
 
    
   
  
  
  
  1. val function= (x:Int) => x*2 
    2.

闭包的实质就是代码与用到的非局部变量的混合

闭包 = 代码 + 用到的非局部变量

  
 
 
 
    
   
  
  
  
  1. val fact=2 
    2. 
   
  
  
  
  2. val function= (x:Int) => x*fact 
    3.

函数柯里化

柯里化指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

先定义一个简单的

  
 
 
 
    
   
  
  
  
  1. def add(x:Int,y:Int)=x+y 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. 使用 
    4. 
   
  
  
  
  4.  
    5. 
   
  
  
  
  5. add(1,2) 
    6.

函数变形(这种方式就叫柯里化)

  
 
 
 
    
   
  
  
  
  1. def add(x:Int,y:Int)=x+y 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. 使用 
    4. 
   
  
  
  
  4.  
    5. 
   
  
  
  
  5. add(1,2) 
    6.

实现过程

add(1)(2) 实际上是依次调用两个普通函数(非柯里化函数)

第一次调用使用一个参数 x，返回一个函数类型的值。

第二次使用参数y调用这个函数类型的值。

  
 
 
 
    
   
  
  
  
  1. 接收一个x为参数，返回一个匿名函数 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. 接收一个Int型参数y，函数体为x+y。 
    4. 
   
  
  
  
  4.  
    5. 
   
  
  
  
  5. def add(x:Int)=(y:Int)=>x+y 
    6. 
   
  
  
  
  6.  
    7. 
   
  
  
  
  7. (1) 
    8. 
   
  
  
  
  8. val result = add(1)  // result= (y:Int)=>1+y 
    9. 
   
  
  
  
  9.  
    10. 
   
  
  
  
  10. (2) 
    11. 
   
  
  
  
  11. val sum = result(2) 
    12. 
   
  
  
  
  12.  
    13. 
   
  
  
  
  13. (3) 
    14. 
   
  
  
  
  14. sum=3 
    15.

面向对象

类和对象

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

类可以带有类参数

类参数可以直接在类的主体中使用。类参数同样可以使用var作前缀，还可以使用private、protected、override修饰。scala编译器会收集类参数并创造出带同样的参数的类的主构造器。，并将类内部任何既不是字段也不是方法定义的代码编译至主构造器中。

  
 
 
 
    
   
  
  
  
  1. class Test(val a: Int, val b: Int) { 
    2. 
   
  
  
  
  2.     //  
    3. 
   
  
  
  
  3. } 
    4.

样例类

case class一般被翻译成样例类，它是一种特殊的类，能够被优化以用于模式匹配。

当一个类被声名为case class的时候。具有以下功能：

  1. 构造器中的参数如果不被声明为var的话，它默认的是val类型的。
  2. 自动创建伴生对象，同时在里面给我们实现子apply方法，使我们在使用的时候可以不直接使用new创建对象。
  3. 伴生对象中同样会帮我们实现unapply方法，从而可以将case class应用于模式匹配。
  4. 实现自己的toString、hashCode、copy、equals方法
  
 
 
 
    
   
  
  
  
  1. case class person( 
    2. 
   
  
  
  
  2.     name:String, 
    3. 
   
  
  
  
  3.     age:Int 
    4. 
   
  
  
  
  4. ) 
    5.

对象与伴生对象

Scala单例对象是十分重要的，没有像在Java一样，有静态类、静态成员、静态方法，但是Scala提供了object对象，这个object对象类似于Java的静态类,它的成员、它的方法都默认是静态的。

定义单例对象并不代表定义了类，因此你不可以使用它来new对象。当单例对象与某个类共享同一个名称时，它就被称为这个类的伴生对象。

类和它的伴生对象必须定义在同一个源文件里。类被称为这个单例对象的伴生类。

类和它的伴生对象可以互相访问其私有成员。

  
 
 
 
    
   
  
  
  
  1. object Test { 
    2. 
   
  
  
  
  2.   private var name="大数据" 
    3. 
   
  
  
  
  3.  
    4. 
   
  
  
  
  4.   def main(args: Array[String]): Unit = { 
    5. 
   
  
  
  
  5.     val test = new Test() 
    6. 
   
  
  
  
  6.     println(test.update_name()) 
    7. 
   
  
  
  
  7.   } 
    8. 
   
  
  
  
  8. } 
    9. 
   
  
  
  
  9.  
    10. 
   
  
  
  
  10. class Test{ 
    11. 
   
  
  
  
  11.   def update_name(): String ={ 
    12. 
   
  
  
  
  12.     Test.name="左右手" 
    13. 
   
  
  
  
  13.     Test.name 
    14. 
   
  
  
  
  14.   } 
    15. 
   
  
  
  
  15.  
    16. 
   
  
  
  
  16. } 
    17.

特质(trait)

scala trait相当于java 的接口，实际上它比接口还功能强大。与接口不同的是，它还可以定义属性和方法的实现。

一般情况下scala的类只能够继承单一父类，但是如果是trait 的话就可以继承多个，从结果来看就是实现了多重继承(关键字with)。其实scala trait更像java的抽象类。

  
 
 
 
    
   
  
  
  
  1. object Test extends UserImp with AddressImp { 
    2. 
   
  
  
  
  2.   override def getUserName(): String = ??? 
    3. 
   
  
  
  
  3.  
    4. 
   
  
  
  
  4.   override def getAddress(): String = ??? 
    5. 
   
  
  
  
  5. } 
    6. 
   
  
  
  
  6.  
    7. 
   
  
  
  
  7. trait UserImp{ 
    8. 
   
  
  
  
  8.   def getUserName():String  
    9. 
   
  
  
  
  9. } 
    10. 
   
  
  
  
  10.  
    11. 
   
  
  
  
  11. trait AddressImp{ 
    12. 
   
  
  
  
  12.   def getAddress():String 
    13. 
   
  
  
  
  13. } 
    14.

模式匹配

以java 的 switch 为例，java 的 switch 仅仅会做一些基本类型的匹配，然后执行一些动作，并且是没有返回值的。

而 scala 的 pattern matching match 则要强大得多，除了可以匹配数值，同时它还能匹配类型。

  
 
 
 
    
   
  
  
  
  1. def calculate(symbol:String): (String,String)=>String ={ 
    2. 
   
  
  
  
  2.     symbol match { 
    3. 
   
  
  
  
  3.       case "拼接方式1" => (a:String,b:String)=> s"拼接方式1:$a , $b" 
    4. 
   
  
  
  
  4.       case "拼接方式2" => (a:String,b:String)=> s"拼接方式2: $b , $a" 
    5. 
   
  
  
  
  5.     } 
    6. 
   
  
  
  
  6.   } 
    7.

让我吃惊的是(就短短几行)

  
 
 
 
    
   
  
  
  
  1. 快排 
    2. 
   
  
  
  
  2.  
    3. 
   
  
  
  
  3. def quickSort(list: List[Int]): List[Int] = list match { 
    4. 
   
  
  
  
  4.     case Nil => Nil 
    5. 
   
  
  
  
  5.     case List() => List() 
    6. 
   
  
  
  
  6.     case head :: tail => 
    7. 
   
  
  
  
  7.       val (left, right) = tail.partition(_ < head) 
    8. 
   
  
  
  
  8.       quickSort(left) ::: head :: quickSort(right) 
    9. 
   
  
  
  
  9.   } 
    10. 
   
  
  
  
  10.    
    11. 
   
  
  
  
  11. 归并 
    12. 
   
  
  
  
  12.  
    13. 
   
  
  
  
  13. def merge(left: List[Int], right: List[Int]): List[Int] = (left, right) match { 
    14. 
   
  
  
  
  14.     case (Nil, _) => right 
    15. 
   
  
  
  
  15.     case (_, Nil) => left 
    16. 
   
  
  
  
  16.     case (x :: xTail, y :: yTail) => 
    17. 
   
  
  
  
  17.       if (x <= y) x :: merge(xTail, right) 
    18. 
   
  
  
  
  18.       else y :: merge(left, yTail) 
    19. 
   
  
  
  
  19. } 
    20.

隐式转换

Scala提供的隐式转换和隐式参数功能，是非常有特色的功能。是Java等编程语言所没有的功能。它可以允许你手动指定，将某种类型的对象转换成其他类型的对象。通过这些功能，可以实现非常强大，而且特殊的功能。

规则

(1)在使用隐式转换之前，需要用import把隐式转换引用到当前的作用域里或者就在作用域里定义隐式转换。

(2)隐式转换只能在无其他可用转换的前提下才能操作。如果在同一作用域里，对同一源类型定义一个以上的隐式转换函数，如果多种隐式转换函数都可以匹配，那么编译器将报错，所以在使用时请移除不必要的隐式定义。

数据类型的隐式转换

String类型是不能自动转换为Int类型的，所以当给一个Int类型的变量或常量赋予String类型的值时编译器将报错。但是.....

  
 
 
 
    
   
  
  
  
  1. implicit def strToInt(str: String) = str.toInt 
    2. 
   
  
  
  
  2. def main(args: Array[String]): Unit = { 
    3. 
   
  
  
  
  3.   val a:Int="100" 
    4. 
   
  
  
  
  4.    
    5. 
   
  
  
  
  5.   print(a) 
    6. 
   
  
  
  
  6. } 
    7.

参数的隐式转换

所谓的隐式参数，指的是在函数或者方法中，定义一个用implicit修饰的参数，此时Scala会尝试找到一个指定类型的，用implicit修饰的对象，即隐式值，并注入参数。

  
 
 
 
    
   
  
  
  
  1. object Test { 
    2. 
   
  
  
  
  2.   private var name="大数据" 
    3. 
   
  
  
  
  3.   implicit val test = new Test 
    4. 
   
  
  
  
  4.  
    5. 
   
  
  
  
  5.   def getName(implicit test:Test): Unit ={ 
    6. 
   
  
  
  
  6.     println(test.update_name()) 
    7. 
   
  
  
  
  7.   } 
    8. 
   
  
  
  
  8.   def main(args: Array[String]): Unit = { 
    9. 
   
  
  
  
  9.     getName 
    10. 
   
  
  
  
  10.   } 
    11. 
   
  
  
  
  11. } 
    12. 
   
  
  
  
  12.  
    13. 
   
  
  
  
  13. class Test{ 
    14. 
   
  
  
  
  14.   def update_name(): String ={ 
    15. 
   
  
  
  
  15.     Test.name="左右手" 
    16. 
   
  
  
  
  16.     Test.name 
    17. 
   
  
  
  
  17.   } 
    18. 
   
  
  
  
  18.  
    19. 
   
  
  
  
  19. } 
    20.

分享文章：Scala精华之处就在这里，拿去，面试也不怕
本文地址：http://www.shufengxianlan.com/qtweb/news16/521516.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

云服务器知识

分类信息网站

香港四川國際商會　　 　成都网站建设哪家好　　 　绵竹网站建设　　 　成都塑料加工　　 　微信小程序开发　　 　成都服务器机柜租用　　 　成都托管服务器　　 　研学实践　　 　光华服务器托管　　 　自适应网站　　 　雕琢时光茶叶　　 　广告吸塑字　　 　联通机房服务器托管　　 　成都网络营销　　 　消防工程　　 　升施印刷　　 　香港主机　　 　官网SEO排名　　 　成都展柜设计　　 　微信网站开发