Scala基础学习

• 官网

1. 什么是Scala

• Scala(Scalable Language)是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。
• Scala运行在JVM（Java虚拟机）上面，并且可以兼容Java程序，可以调用Java SDK，我们可以在日常编程中使用Scala、Java混合编程。

2. 为什么要学习Scala

• Scala这门语言比较优雅，编写起来比较舒适
• 当前Spark、Flink计算框架比较火，Spark 中大部分开发语言使用的是Scala，Flink中也有一部分使用的是Scala开发的，因此要想更好的使用和掌握Spark、Flink，需要学习Scala这门语言

3. Scala 环境搭建

• Scala 下载地址
• 这里我们选用的是Scala 2.12.12

3.1 Scala Linux环境搭建

• 由于Scala依赖于JVM来运行，在安装Scala之前需要安装JDK1.8

3.1.1 Scala下载以及安装

[root@bigdatatest01 software]# pwd
/root/software
[root@bigdatatest01 software]# wget https://downloads.lightbend.com/scala/2.12.12/scala-2.12.12.tgz
[root@bigdatatest01 software]# tar -xzvf scala-2.12.12.tgz -C ~/app/

3.1.2 Scala环境变量

[root@bigdatatest01 software]# cd ~
[root@bigdatatest01 ~]# vim .bashrc
export SCALA_HOME=/root/app/scala-2.12.12
export PATH=${SCALA_HOME}/bin:${PATH}
[root@bigdatatest01 ~]# source .bashrc

3.1.3 检查环境变量是否生效

[root@bigdatatest01 ~]# scala
Welcome to Scala 2.12.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_151).
Type in expressions for evaluation. Or try :help.

scala> 

4. Scala基础语法

4.1 数据类型

• 常用数据类型：
• Byte：8位有符号补码整数。数值区间为 -128 到 127
• Short：16位有符号补码整数。数值区间为 -32768 到 32767
• Int：32位有符号补码整数。数值区间为 -2147483648 到 2147483647
• Long：64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
• Float：32 位, IEEE 754 标准的单精度浮点数
• Double：64 位 IEEE 754 标准的双精度浮点数
• Boolean：true或false
• String：字符序列
• Char：16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF

package com.xk.bigdata.scala.basic

object DataTypeApp {
  def main(args: Array[String]): Unit = {
    // 判断数据类型
    val a: String = "hadoop"
    println(a.isInstanceOf[String])
    // 强转数据类型
    val b :Int = 111
    val c = b.asInstanceOf[Double]
    println(c)
    println(c.isInstanceOf[Double])
  }
}

4.2 声明变量

• val/var $变量名:$变量类型 = $变量数据
• val：使用val定义变量之后，后面此变量的数据无法修改
• var：使用var定义变量之后，后面此变量的数据可以修改
• 变量刚开始定义的时候，建议使用val来定义变量，如果后面报错，需要修改，再改成var

4.3 IF判断

package com.xk.bigdata.scala.basic

object IfApp {

  def main(args: Array[String]): Unit = {
    val a = "spark"
    if (a == "hadoop") {
      println(s"$a==hadoop")
    } else if (a == "spark") {
      println(s"$a==spark")
    } else {
      println(s"$a==other")
    }

    val b = if (a == "hadoop") 1 else 2
    println(b)
  }
  
}

4.4 FOR循环

• for 循环里面有个词大家可能比较陌生==>循环守卫，其实就是在for循环的里面再加一层IF判度，只有在这个循环并且符合这个条件的数据，才会进入到For循环的代码里面，我下面有具体的的案例来演示。
• Scala的for循环里面可以有两个循环一齐使用，两个循环只要用分号隔开就OK了，下面也有具体的案例来说明。
• Scala的break使用和Java不太一样，需要导入scala.util.control.Breaks.{break, breakable}这个包之后才可以使用。
• Scala yield关键字可以在for表达式中生成新的集合。

package com.xk.bigdata.scala.basic

import scala.util.control.Breaks.{break, breakable}

/**
 * for循环使用
 * 需求1： 打印一个九九乘法表
 * 需求2： 打印10以内的奇数
 * 需求3：判度是否为质数，如果为质数则推出循环
 * 需求4： 把数组里面的数据通过for循环全部求平方并用另一个数组接收
 */
object ForApp {

  def main(args: Array[String]): Unit = {
    // for循环的基础使用
    val a = "abcd"
    for (els <- a) {
      println(els)
    }

    // 需求1： 打印一个九九乘法表
    for (i <- 1 to 9; j <- 1 to i) {
      print(s"$i*$j=${i * j}\t")
      if (i == j) {
        print("\n")
      }
    }

    // 需求2： 打印10以内的奇数
    for (i <- 1 to 10) {
      if (i % 2 != 0) {
        println(i)
      }
    }
    // 使用循环守卫
    for (i <- 1 to 10 if i % 2 != 0) {
      println(i)
    }

    // 需求3：判度是否为质数，如果为质数则推出循环
    // 使用break关键字
    val b = 7
    var flag = true
    breakable {
      for (i <- 2 until b) {
        if (b % i == 0) {
          flag = false
          break()
        }
      }
    }
    println(flag)

    // 需求4： 把数组里面的数据通过for循环全部求平方并用另一个数组接收
    val arry = (1 to 9).toArray[Int]
    val arryNew = for (els <- arry) yield els * els
    for (els <- arryNew) {
      println(els)
    }

  }

}

4.5 While循环

• While 经常使用的有：While循环、Do While循环

package com.xk.bigdata.scala.basic

object WhileApp {

  def main(args: Array[String]): Unit = {

    var i = 1
    // While 循环
    while (i <= 100) {
      println(i)
      i += 1
    }
    // do While 循环
    do {
      println(i)
      i += 1
    } while (i <= 100)

  }

}

4.6 方法

• 如何定义一个方法
• def $方法名($入参名称:$入参类型,$入参名称:$入参类型): $返回值类型 = { // 方法体}
• 对于一个没有入参的方法，在调用方法的时候可以省略方法名称后面的括号。
• 入参默认参数：默认参数没有传参数的时候会使用默认值，调用该函数的时候，无法省略方法名后面的括号。
• 入参命名参数可：以通过参数名称来指定入参数据，但是工作里面不建议用，后期维护成本比较大。
• 入参变长参数：不确定有多少个入参

package com.xk.bigdata.scala.basic

/**
 * 方法的基本使用
 */
object FunctionApp {

  /**
   * 需求： 定义一个两个数相加的方法
   */
  def add1(a: Int, b: Int): Int = {
    a + b
  }

  /**
   * 需求： 定义一个两个数相加的方法（简写）
   */
  def add2(a: Int, b: Int) = a + b

  def printHello(): Unit = {
    println("Hello World")
  }

  /**
   * 默认参数
   */
  def max(a: Int = 10, b: Int = 10) = {
    if (a > b) {
      a
    } else {
      b
    }
  }

  /**
   * 命名参数：求速率：路程/时间
   */
  def speed(distance: Float, time: Float) = distance / time

  /**
   * 变长参数-可变参数： 不确定有多少个入参
   */
  def add(nums: Int*) = {
    var result = 0
    for (num <- nums) {
      result += num
    }
    result
  }

  def main(args: Array[String]): Unit = {
    // 需求： 定义一个两个数相加的方法
    println(add1(1, 2))
    println(add2(2, 3))
    printHello
    // 默认参数
    println(max())
    // 命名参数
    println(speed(time = 10F, distance = 100F))
    // 变长参数
    println(add(1, 2, 3, 4))
  }

}