Scala入门学习

Scala入门学习

1.Scala安装

1）安装JDK版本

安装JDK1.8，并完成相应的环境变量的配置。

2)安装scala

下载Scala：官网链接：https://www.scala-lang.org/download/all.html

可以选择自己适用的版本，选择msi版本的话，直接next直接安装即可。

安装之后，环境变量会自动给配置好

cmd命令下测试Scala环境，会进入scala的命令行。

scala退出命令行的命令：：quit

3) IDEA中scala插件安装

在线安装scala插件：IDEA -->进入settings -->Plugins 搜索scala安装

离线安装scala插件：先去IDEA插件官网https://plugins.jetbrains.com/ 搜索scala，进入scala 页面，选择对应IDEA适用的scala版本下载即可。

我使用的IDEA2020.1 下载了scala-intellij-bin-2020.1.43.zip

2. scala 初识

2.1 scala简介

Scala运行于Java平台（JVM，Java 虚拟机）上，并兼容现有的Java程序，Scala代码可以调用Java方法，访问Java字段，继承Java类和实现Java接口。

在面向对象方面，Scala是一门非常纯粹的面向对象编程语言，也就是说，在Scala中，每个值都是对象，每个操作都是方法调用。

Scala具有以下突出的优点：

◇ Scala具备强大的并发性，支持函数式编程，可以更好地支持分布式系统；

◇ Scala语法简洁，Scala程序保守估计是同样Java程序的一半左右；并且能提供优雅的API；

◇ Scala兼容Java，运行速度快，现有的很多大数据框架使用Scala开发，比如spark，kafka，flink；

什么是函数式编程？

函数式编程中的函数,是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。

函数式编程有如下特点：

1）函数是一等公民。可以把函数当做参数传给另一个函数。也可以把函数当做返回值返回出来，也可以在一个函数体里定义一个函数。

2）纯函数式编程，没有副作用。即变量一经赋值，就不可变。

3）引用透明性。指的是函数的运行不依赖于外部变量或"状态"，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。

如：sqrt(2) 永远等于 4。

2.2 创建第一个Scala程序

可以参考

https://zhuanlan.zhihu.com/p/379938959 scala 系列之 01scala 概述和开发环境搭建

https://blog.csdn.net/qq_41544550/article/details/88736930 在Intellij IDEA搭建Scala开发环境，以及使用Intellij IDEA开发Scala程序

3. 数据类型、变量、操作符、语句

3.1 数据类型

scala 的基本类型有 8 种：

Byte、Char、Short、Int、Long、Float、Double、Boolean

Scala中没有基本数据类型的概念，所有的类型都是对象。

如上图所示：

**Anyval：**代表所有基本类型。

**AnyRef：**代表所有引用类型，包括 Scala class 和 Java class。

**Any：**是所有类的超类。如果不知道表达式的结果是什么类型可以用Any。

**Unit：**只有一个实例值 ()，方法返回Unit 相当于返回了Java中的void。

scala> val a:Int = 10
a: Int = 10
scala> val b:String = "hehe"
b: String = hehe
scala> val c:Any = "hainiu"
c: Any = hainiu
scala> val d:Unit = ()
d: Unit = ()

3.2 变量声明

**val：**变量的引用不可变，底层相当于final 修饰

**var：**变量的引用可变,如果给变量指定具体类型，会校验数据类型和指定类型是否一致

scala推荐用val，val就是value的缩写。

scala语言结尾不用分号和Python语言比较相似。

scala不指定变量类型是会根据值进行自动推断，当然也可以在初始化的时候明确指定变量的类型；

3.3 操作符

Scala 为它的基本类型提供了丰富的操作符集，包括：

算数运算符：加(+)、减(-) 、乘(*) 、除(/) 、余数（%）；

关系运算符：大于（>）、小于（<）、等于（=）、不等于（!=）、大于等于（>=）、小于等于（<=）；

逻辑运算符：逻辑与（&&）、逻辑或（||）、逻辑非（!）；

位运算符：按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）、无符号右移（>>>）；

赋值运算符：“=” 及其与其他运算符结合的扩展赋值运算符，例如 +=、-=；

注意：

1）与java不同的是这些运算符的操作，都是方法的调用；

2）在 scala中各种赋值表达式的值都是Unit类型；

scala> var b = 1
b: Int = 1
// b = 2 的结果是Unit，所以c的类型是Unit
scala> val c = b = 2
c: Unit = ()
// b 的值改变了
scala> println(b)
2

3.4 语句

scala 语句行尾的位置建议不加分号；

scala 代码可以自动格式化

4 控制结构

4.1 if 条件表达式

if 语句用来实现两个分支的选择结构，语法如下：

if(表达式1){
   
    语句块1
}else if(表达式2){
   
    语句块2
}else{
   
    语句块3
}

运行逻辑和java相同，这块内容省略。

与java 不同的是， scala 可以通过if 语句实现 java 三目运算符的逻辑；

if(表达式)true的结果 else false的结果

当有多个情况的类型返回时，向上找公共的类型返回

scala> val a=10
a: Int = 10

scala> val b=20
b: Int = 20

scala> val macNum = if(a>b) a else b
macNum: Int = 20

scala> val macNum = if(a>b) "10" else b
macNum: Any = 20

4.2 while 循环

scala 拥有与java相同的while、do while 循环。

4.3 for 循环

但scala没有与java相同的for循环，它的for循环语法

//跟java一样，只不过生成器里面的语法不一样，可以嵌套使用
for(生成器) 循环体
//高级for，for的推导式
for(生成器 [守卫] [;生成器 守卫]...) 循环体

其中：

1）生成器：是 变量 <- 表达式 的形式

1 to 3 : 返回 1 到 3 的序列

1 until 3：返回 1 到 2 的序列

scala> 1 to 3
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3)
scala> 1 until 3
res1: scala.collection.immutable.Range = Range(1, 2)

单层循环

scala> for(i <- 1 to 3) println("i=" + i)
i=1
i=2
i=3
// 在字符串中替换变量
scala> for(i <- 1 to 3) println(s"i=${i}")
i=1
i=2
i=3

输出双层循环中，外循环1到3， 内循环1到2

一般写法:
scala> for(i<- 1 to 3) {
     | for(j<- 1 to 2) {
     | println("i="+i+";j="+j)
     | }
     | }
i=1;j=1
i=1;j=2
i=2;j=1
i=2;j=2
i=3;j=1
i=3;j=2

高级写法:
scala> for(i<- 1 to 3;j<- 1 to 2) println(s"i=${i},j=${j}")
i=1,j=1
i=1,j=2
i=2,j=1
i=2,j=2
i=3,j=1
i=3,j=2

2）守卫：是以if开头的boolean表达式，每个生成器后面都可以跟一个

如：双层循环中，外循环1到3， 内循环1到2，输出外层循环1到2，内层循环1 的值

一般写法：
scala> for(i<- 1 to 3) {
     | for(j<- 1 to 2) {
     | if(i<2 && j<=1){
     | println("i="+i+";j="+j)
     | }
     | }
     | }
i=1;j=1

高级写法：
scala> for(i<- 1 to 3 if(i<=2);j<- 1 to 2 if(j<=1)) println(s"i=${i},j=${j}")
i=1,j=1
i=2,j=1

3）yield关键字结合for循环使用

val c = for(i <- 1 until 10) yield i

yield 的作用是把每次迭代生成的值封装到一个集合中，当然也可以理解成yield会自动创建一个集合

如果把yield去掉那返回给C的值就为Unit

yield 可以把序列中的每个元素通过算法，得到新的元素，并组成新的序列

scala> 1 to 5
res5: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)

scala> for(i<- 1 to 5) yield i
res6: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4, 5)

scala> for(i<- 1 to 5) yield i*10
res7: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50)

scala> for(i<- 1 to 5) yield if(i%2==0)i*5 else i*10
res8: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 10, 30, 20, 50)

4.4 循环控制语句

Scala 不支持 break 或 continue 语句，但从 2.8 版本后使用另外一种方式来实现 break 语句。当在循环中使用 break 语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。

语法格式：

// 导入以下包
import scala.util.control.Breaks
// 创建 Breaks 对象
val loop = new Breaks
// 在 breakable 中循环
loop.breakable(
    // 循环
    for(...){
   
       ....
       // 循环中断
       loop.break
   }
)

代码：

import scala.util.control.Breaks
// 单例对象
object HelloWorld {
   
  def main(args: Array[String]): Unit = {
   
//    println("hello world")
    // 创建breaks对象
    val breaks = new Breaks
    println("实现break")
    // 实现 i == 3 退出循环
    breaks.breakable(
      // catch 异常
      for(i <- 1 to 5){
   
        // 抛异常
        if(i == 3) breaks.break()
        println(s"i=${i}")
      }
    )
    println("实现continue")
    for(i <- 1 to 5){
   
      breaks.breakable(
        if(i == 3){
   
          breaks.break()
        } else{
   
//          val n = 1 / 0
          println(s"i=${i}")
        }
      )
    }
  }
}

5 方法与函数

5.1 方法

在scala中的操作符都被当成方法存在，比如说+、-、*、/

1+2就是1.+(2)的调用，

2.0 是doule类型，强调用Int类型的写法为1.+(2:Int)

可以在idea中搜索Int类查看支持的方法

方法声明与使用

定义方法的语法：

def 方法名([变量：变量类型，变量：变量类型]):返回值类型={
   方法体}

其中：

在scala 中，方法里面的最后一个表达式的值就是方法的返回值，不需要return 返回；

示例：

定义无参无返回值的方法：

// 定义无参无返回值的方法
scala> def say():Unit = {
   println("say hello")}
say: ()Unit
scala> say()
say hello
// 简化过程
scala> def say():Unit = {
   println("say hello")}
say: ()Unit
// 方法体有一个语句，省略{}
scala> def say():Unit = println("say hello")
say: ()Unit
// 方法返回值可以由方法体返回结果类型推测
scala> def say() = println("say hello")
say: ()Unit
// 方法形参列表是空， 可省略()
scala> def say = println("say hello")
say: Unit
scala> say
say hello
scala> say()
<console>:13: error: Unit does not take parameters
       say()
// 带有返回值的方法
def add(a:Int, b:Int):Int={
   val c = a + b; return c}

定义带有有参有返回值方法：

// 定义带有有参有返回值方法
scala> def add(a:Int, b:Int):Int={
   val c = a + b; return c}
add: (a: Int, b: Int)Int
scala> add(4,5)
res8: Int = 9
// 简化流程
scala> def add(a:Int, b:Int):Int={
   val c = a + b; return c}
add: (a: Int, b: Int)Int
// scala 不建议用return返回方法结果，默认最后一个就是方法的返回值
scala> def add(a:Int, b:Int):Int={
   val c = a + b; c}
add: (a: Int, b: Int)Int
// 去掉中间变量c
scala> def add(a:Int, b:Int):Int={
   a + b}
add: (a: Int, b: Int)Int
// 方法体有一个语句，省略{}
scala> def add(a:Int, b:Int):Int=a + b
add: (a: Int, b: Int)Int
// 方法返回值可以由方法体返回结果类型推测
scala> def add(a:Int, b:Int)=a + b
add: (a: Int, b: Int)Int
scala> add(4,5)
res9: Int = 9

方法的调用：

object M1 {
   
  def say(name:String) = {
   
    println(s"say ${name}")
  }

  def add(a:Int, b:Int) = a + b
  def main(args: Array[String]): Unit = {
   
    // 普通调用
    M1.say("hainiu")
    // 中缀方法调用
    M1 say "hainiu"
    // 大括号调用，当只有一个入参时才能用
    M1 say {
   "hainiu"}

    M1.add(4,5)
    // 中缀方法调用
    M1 add (4,5)
  }
}

5.2 函数

在 java 中方法和函数是一个意思，在 scala 中方法和函数是两种含义。

在 scala 中，函数是一等公民。可以在任何地方定义，在函数内或函数外，可以作为函数的参数和返回值；函数还可以赋给变量。

函数声明：

val 变量名:[变量类型1,变量类型2 => 函数体返回类型 ] = ([变量：变量类型，变量：变量类型]) => 函数体

示例：

// 函数本身是没有名字的--匿名函数
// function2 是 函数有 两个输入参数 和 一个输出， 本例是 两个Int输入，一个Int输出
scala