一.Scala 概述

1.1 什么是Scala

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种个性。

Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。

Scala 源代码被编译成 Java 字节码，所以它能够运行于 JVM 之上，并能够调用现有的 Java 类库。

Scala官网 https://www.scala-lang.org/

1.2 装置

1.2.1 装置jdk(1.8以上版本)

略

1.2.2 装置Scala

在官网上下载，我这里是Ubuntu零碎，抉择版本为scala-2.12.11.tgz
装置很简略
1）解压文件
2）将解压后的目录搁置在指定目录

# 我这里是/usr/local 目录mv scala-2.12.11 /usr/local/

3）配置环境变量
/etc/profile 追加如下内容

# set scalaexport SCALA_HOME=/usr/local/scala-2.12.11export PATH=${PATH}:${SCALA_HOME}/bin

执行source /etc/profile

4）测试下
如下显示，示意装置胜利

(base) zhaow@zhaow-610:~$ scalaWelcome to Scala 2.12.11 (Java HotSpot(TM) 64-Bit Server VM, Java 11.0.1).Type in expressions for evaluation. Or try :help.scala> 

二.Scala 根本语法

2.1 第一个Scala程序 HelloWorld

学习编程语言，第一个入门程序，必然是HelloWorld.scala

object HelloWorld {  def main(args: Array[String]): Unit = {   // 打印HelloWorld    println("Hello World!")  }}

而后进行编译

scalac HelloWorld.scala

编译之后生成两个文件,

HelloWorld.classHelloWorld$.class

运行HelloWorld.class

scala HelloWorld

输入后果HelloWorld

2.2 正文

Scala正文与Java正文齐全一样

/** * 文档正文 */object HelloWorld {  def main(args: Array[String]): Unit = {    // 单行正文    /*     多行正文1     多行正文2     */    println("Hello World!")  }}

2.3 标识符

Scala应用的标识符有两种模式：字符数字和符号

• 字符数字应用字母或是下划线结尾，前面能够接字母或是数字，符号"$"在 Scala 中也看作为字母。然而以"$"结尾的标识符为保留的 Scala 编译器产生的标志符应用，应用程序应该防止应用"$"开始的标识符，免得造成抵触。
• Scala 的命名规定采纳和 Java 相似的 camel 命名标准，首字符小写，比方 toString。类名的首字符还是应用大写。此外也应该防止应用以下划线结尾的标志符以防止抵触。
• Scala 外部实现时会应用本义的标志符，比方:-> 应用 $colon$minus$greater 来示意这个符号。

代码示例

object Scala_Indentifier {  def main(args: Array[String]): Unit = {    // 默认状况下，scala标识符申明形式和java统一    val name = "张三"    val user_age = 14    val address1 = "BJ"    val _sex = "男"    val $emain = "123@123.com"//    val 1name = "张三" //谬误示范//    val class = "张三" // 谬误示范    // Scala 标识符能够应用符号进行申明，但常见语法操作的符号是不能应用的    // 例如(),[],"",''    val + = "张三"    val - = "张三"    val * = "张三"    val / = "张三"//    val ( = "张三" // error      }}

2.4 数据类型与类型转换

2.4.1 数据类型

Scala是齐全面向对象的语言，所以不存在根本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意援用对象类型(AnyRef)
如下图所示

2.4.2 类型转换

1）主动类型转换

object ScalaDataType {  def main(args: Array[String]): Unit = {    // Scala 主动类型转换    // 例如Byte类型和Short类型的主动转换    val byte_num = 11    val short_num = byte_num    val i_num:Int = short_num   }}

2）强制类型转换

object ScalaDataType {  def main(args: Array[String]): Unit = {    // 将精度打的类型转换为精度小的类型    // Scala中应用办法进行转换    val i_num = 12    val b_num = i_num.toByte    // 基本上Scala的AnyVal类型之间都提供了相应转换的办法  }}

3）字符串类型转换
scala是齐全面向对象的语言，所有的类型都提供了toString办法，能够间接转换为字符串

2.5 变量

1）语法申明

object ScalaVariable {  def main(args: Array[String]): Unit = {    // 申明形式1 var 变量名:变量类型 = 变量值    var name1:String = "张三"    // 申明形式2 val 变量名:变量类型 = 变量值    val name2:String = "张三"    // var 和 val 申明形式不同之处    // var 申明形式 变量能够批改，为可变变量    name1 = "王五"    // val 申明形式 变量不能够批改，为不可变变量    name2 = "王五" // 谬误  }}

2）精简书写

object ScalaVariable {  def main(args: Array[String]): Unit = {    // 残缺申明规定    val name1:String = "张三"    // 其中数据类型能够不指定，这时候，则会进行数据类型的推断    val name2 = "张三"    println(name2.getClass.getSimpleName) // 输入后果为String  }}

3）总结

• 申明变量时，数据类型能够指定，也能够不指定，如果不指定，那么就会进行数据类型的推断。
• 如果指定数据类型，数据类型的执行 形式是 在变量名前面写一个冒号，而后写上数据类型。

• scala外面变量的修饰符有两个，var和val。

  • 如果是var润饰的变量，那么这个变量的值是能够批改的。
  • 如果是val润饰的变量，那么这个变量的值是不能够批改的。

2.5 字符串

Scala中，字符串的类型实际上就是Java中的String
咱们从String的源码能够看到这一点

type String        = java.lang.String

String是不可变的字符串对象，不可被批改，这与Java统一，批改时，会产生一个新的字符串对象。

2.5.1 字符串连贯

object Scala_string {  def main(args: Array[String]): Unit = {    val name:String = "张三"    val sex:String = "男"    println(name+":"+sex)  }}

2.5.2 字符串传值

代码示例

object Scala_string {  def main(args: Array[String]): Unit = {    val name = "张三"    // 应用printf格式化字符串    printf("name=%s",name)  }}

2.5.3 字符串插值和多行字符串

代码示例

object Scala_string {  def main(args: Array[String]): Unit = {    // 字符串插值    val name = "张三"    println(s"name=$name")        // 多行字符串格局，在封装SQL或者JSON比拟罕用    // | 默认顶格符    println(      s"""         |select         |*         |from         |demo_tb         |""".stripMargin)          }}

2.6 运算符

scala运算符的应用和Java运算符的应用基本相同，只是Scala中运算符实际上是办法。
示例

object ScalaOper {  def main(args: Array[String]): Unit = {    val i = 10    // val j = i + 10 // 实际上执行的是办法    val j = i.+(10)    println(j)  }}

2.7 流程管制

2.7.1 分支语句

代码示例

object Scala_Flow {  def main(args: Array[String]): Unit = {    // 单分支    val num = 91    if(num>100){      println("num 大于 100")    }    // 双分支    if(num>100){      println("num 大于 100")    }else{      println("num 不大于 100")    }    // 多分支    if(num>100){      println("num 大于 100")    }else if(num > 90){      println("num 大于 90 ，且小于等于100")    }else{      println("num....")    }  }}

另外if条件表达式是有返回值的，返回值会依据条件表达式的状况主动进行数据类型推断
代码示例

object Scala_Flow {  def main(args: Array[String]): Unit = {    val age = 20    val res = if(age > 20) 1 else 0    println(res)  }}

2.7.2 循环语句

1）for循环

• 根本语法

for ( 循环变量 <- 数据集 ) { // 这里的数据集能够是任意类型的数据汇合，如字符串，汇合，数组等    循环体}

代码示例

object Scala_Loop {  def main(args: Array[String]): Unit = {    // 示例1    for(i <- Range(1,5)){ // 左闭右开，不蕴含5      println("i========="+i)    }    // 示例2    for(i <- 1 to 5){ // 蕴含5      println("i=========="+i)    }    // 示例3    for(i <- 1 until 5){ // 不蕴含5      println("i======="+i)    }  }}

• 循环时减少条件判断

代码示例

object Scala_Loop {  def main(args: Array[String]): Unit = {    for(i <- Range(1,30) if (i%2)==0){      println("i========"+i)    }  }}

• 循环步长

object Scala_Loop {  def main(args: Array[String]): Unit = {    for(i <- Range(1,10,2)){      println("i=========="+i)    }    for(i <- 1 to 10 by 2){      println("i========="+i)    }  }}

• for 循环推导

object Scala_Loop {  def main(args: Array[String]): Unit = {    // for 循环推导式:    // 如果for训话中的循环体以yield开始，则该循环会构建一个汇合，每次迭代会生成汇合中的一个值    val value = for(i <- 1 to 5) yield i * 20    println(value)  }}

2）while循环

• 根本语法

while( 循环条件表达式 ) {    循环体}

• 代码示例

object Scala_Loop {  def main(args: Array[String]): Unit = {    var i = 0    while (i < 5){      println("i========="+i)      i+=1    }  }}

3）中断循环
Scala是齐全面向对象的语言，无奈应用break、continue这样的关键字。
Scala采纳函数式编程的形式代替了循环语法中的break
示例

import scala.util.control.Breaksobject Scala_Loop {  def main(args: Array[String]): Unit = {    Breaks.breakable{      for(i <- 1 to 5){        if( i==3 ){          Breaks.break        }      }    }  }}

也能够这样导包，简化书写

import scala.util.control.Breaks._object Scala_Loop {  def main(args: Array[String]): Unit = {    breakable{      for(i <- 1 to 5){        if( i==3 ){          break        }      }    }  }}