从零开始学Scala

---

大数据学习路线，从零开始学大数据，学习不迷路

一、SCala入门

1.1 概述

1.1.1 为什么学习Scala

1. Spark – 新一代内存级大数据计算框架，是大数据的重要内容。
2. Spark是用Scala语言编写的。为了更好的学习spark，需要掌握Scala语言。
3. Spark的兴起，带动Scala语言的发展。

1.1.2 Scala 的发展历史

1.1.3 Scala与java之间的关系

1.1.4 Scala的语言特点

1.2 Scala环境搭建

1）安装步骤

（1） 首先安装JDK1.8安装成功

（2）下载对应的Scala安装文件Scala安装Scala-2.12.11zip

去官网下载对应的版本:

Scala官网

（3）解压Scala-2.12.11zip

（4）配置Scala环境变量

打开系统变量，新建

在path中添加：

1.3 Scala 插件安装

在IDEA软件上， 打开设置

搜索scala，点击下载

1.4 HelloWorld案例

1.4.1 创建IDEA工程

两种方法建立Scala项目：

第一种：

新建一个maven项目，然后在新建一个文件夹

设置为source root

然后就可以新建scala项目了

第二种：

新建一个项目

选择scala插件

输入文件名，完成即可

1.4.2 class和object说明

java：

scala：

---

二、变量和数据类型

2.1 注释

 Scala 注释使用和Java完成一样

单行注释快捷键 ： ctrl + /

多行注释快捷键 ： ctrl +shift + /

文档注释 ： / * * + 回车

代码规范 ：

2.2 变量和常量（重点）

常量：在程序执行的过程中，其值不会被改变的变量。

java变量和常量：

Scala变量和常量：

1） 基本语法：

2） 案例实操

2.3 标识符的命名规范

 Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以取名字的地方都叫标识符。

1） 命名规则：

2.4 字符串输出

1）基本语法：
（1） 字符串，通过+号连接
（2）printf用法：字符串，通过%传值
（3）字符串模板（插值字符串）：通过$获取变量值

2)案例

object Text04_String {

  def main(args: Array[String]): Unit = {
    //  （1） 字符串，通过+号连接
    val name: String = "刘德华"
    val name1: String = "郭富城"
    val age: Int = 19
    val age1: Int = 23
    println(name + "的年龄是：" + age + " ," + name1 + "的年龄是：" + age1)

    //  * 用于将一个字符串复制多次并拼接
    println(name * 3)

    //  （2）printf用法：字符串，通过%传值
    printf("%d岁的%s在打篮球", age, name)
    println()
    //  （3）字符串模板（插值字符串）：通过$获取变量值
    println(s"${age}岁的${name}还在打篮球")

	    val num:Double = 2.342354
    println(f"The num is ${num}%2.2f")  //  f 格式化模板字符串
    println(raw"the num is ${num}%2.2f")  //  raw  原样输出

    // 三引号 表示字符串，保持多行字符串的原格式输出
    val sql = s"""
         |selcet *
         |from
         |  student
         |where
         |  name = ${name}
         |and
         |  age > ${age}
         |""".stripMargin
    println()
  }
}

输出结果：

2.5 键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

1）基本语法：

	StdIn.readLine()、StdIn.readShot()、StdIn.readDouble()

import scala.io.StdIn

2)案例

import scala.io.StdIn

object  text05_input {
  def main(args: Array[String]): Unit = {
//    输入信息
    println("请输入你的名字：")
    val name : String = StdIn.readLine()
    println("请输入你的年龄：")
    val age : Int = StdIn.readInt()

    println(s"欢迎${age}岁的${name} ! ! !")
  }
}

运行结果：

对文件进行读写：

import java.io.{File, PrintWriter}

import scala.io.Source

object Text06_FileIO {
  def main(args: Array[String]): Unit = {
//    1. 从文件中读取数据
    Source.fromFile("src/main/resources/test").foreach(print)

//    2. 将数据写入文件
    val writer = new PrintWriter(new File("src/main/resources/output.txt"))

    writer.write("hello scala from java writer ")
    writer.close()
  }
}

结果：

2.6 数据类型（重点）

java数据类型：

Scala数据类型:

2.7 整数类型（Byte、Short、Int、Long）

Scala 的整数类型就是用于存放整数值的，比如12，30，3456等等。

1）整型分类

2） 案例

object  text07_data {
  def main(args: Array[String]): Unit = {
//    1 整数类型
    val a1 :Byte = 127
    val a2 :Byte = -128

//    整数默认类型为Int
    val a3 = 12
    val a4 = 12312451251251L  // 长整型数值定义

    val b1 :Byte = 10
    val b2 : Byte = 20+10
    println(b2)

    val b3 : Byte =(b2 + 30).toByte
    print(b3)
  }
}

2.8 浮点类型（Float、Double）

//    浮点类型
    val f1 :Float = 1.2324f
    val d1  = 34.3412  // 默认 Double 类型

2.9 字符类型（Char）

1） 基本说明

字符类型可以表示单个字符，字符串类型是Char。

2） 案例实操

    val c1: Char = 'a'
    println(c1)

    val c2: Char = '9'
    println(c2)

    //    控制字符
    val c3: Char = '\t' // 制表符
    val c4: Char = '\n' // 换行符
    println("abc" + c3 + "def")
    println("abc" + c4 + "def")

    //    转义字符
    val c5 = '\\' // 表示 \ 自身
    val c6 = '\"' // 表示 ”
    println("abc" + c5 + "def")
    println("abc" + c6 + "def")

    //    字符变量底层保存ASCII码
    val i1: Int = c1
    val i2: Int = c2
    println("i1:" + i1)
    println("i2:" + i2)

    val c7: Char = (i1 + 1).toChar
    println(c7)
    val c8: Char = (i2 + 1).toChar
    println(c8)

2.10 布尔类型：Boolean

1）基本说明

（1） 布尔类型也叫Boolean类型，Boolean类型数据只允许取值true和ffalse
（2)    boolean 类型占1个字节。

2）案例实例

    // 布尔类型
    val isTrue:Boolean = true
    println(isTrue)

2.11 Unit类型、Null类型和Nothing类型（重点）

1） 基本说明

    //    空值Unit
    def m1(): Unit = {
      println("m1被调用执行")
    }

    val a: Unit = m1()
    println("a" + a)

    //    空引用 Null
    //    val n : Int = null  // 值类型不能接收空引用  error
    var student: Student = new Student("alice", 20)
    student = null
    println(student)

    //    nothing
    def m2(n: Int): Nothing = {
      throw new NullPointerException
    }
    //    def m2(n: Int): Int = {
    //      if (n == 0)
    //        throw new NullPointerException
    //      else
    //        return n
    //    }

    val b = m2(0)
    println("b" + b)
  }
}

2.12 类型转换

2.12.1 数值类型自动转换

（1） 自动提升原则：有多种类型的数据进行混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后计算。

（2）把精度大的数据类型赋值给精度小的数据类型时，就会报错，反之就会进行自动类型转换。

（3）（byte，short）和char之间不会相互自动转换。

（4）byte ， short，char 他们三者可以计算，在计算时首先转换成int类型。

2.12.2 强制类型转换

1)基本说明

	自动类型转换的逆过程，将精度大的数值转换成精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。

	Java ： int num= (int) 2.5
	Scala :  var num:Int = 2.7.toInt

(1) 将数据由高精度转换成低精度，就需要使用到强制转换。

(2)强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级。

    val a1: Char= '9'
    val a2: Int = a1.toInt
    println(a2)

    val n1 :Int = -2.9.toInt
    println(n1)

    val n2 : Int = 2.6.toInt +3.7.toInt
    val n3 : Int = (2.6+3.7).toInt
    println(n2)
    println(n3)

2.12.3 数值类型和String类型间转换

（1）数值转String
（2）String转数值

//    (1)数值转String
    val n:Int = 27
    val s :String = n+ ""
    println(s)

//    （2）String转数值
    val m :Int = "12".toInt
    val f :Float = "12.3".toFloat
    val f2 : Int = "12.3".toDouble.toInt
    println(f2)

强制类型转换时超出类型的值范围：

（1）
* 128 : Int 类型， 占据4个字节 32位
* 原码 0000 0000 0000 0000 0000 0000 1000 0000
* 补码 0000 0000 0000 0000 0000 0000 1000 0000
*
* 截取最后一个字节 Byte
* 得到补码 1000 0000
* 表示最大负数 -128

    val n:Int = 128
    val b : Byte = n.toByte
    println(b)

(2）
* 130 : Int 类型， 占据4个字节 32位
* 原码 0000 0000 0000 0000 0000 0000 100 0010
* 补码 0000 0000 0000 0000 0000 0000 1000 0010
* 截取最后一个字节 Byte
* 得到补码 1000 0010
* 对应原码 1111 1110
-126

    val n2:Int = 130
    val b2 : Byte = n2.toByte
    println(b2)

---

三、运算符

Scala 运算符和Java运算符的使用基本相同，只有个别细节上不同。

3.1 算术运算符

1. 基本语法

3.2 关系运算符

1） 基本语法：

比较运算符

    val s1 :String = "hello"
    val s2 :String =new String("hello")

    //    判断值是否相等。没有判断引用地址
    println(s1 == s2)
    println(s1.equals(s2))

	println(s1.eq(s2))  // 判断引用地址是否相等
	

3.3 逻辑运算符

1） 基本语法：
用于连接多个条件（一般来说就是关系表达式），最终的结果也是一个Boolean值

假定：变量A为true ，B为false

    //    逻辑运算
    def m(n: Int): Int = {
      println("m()调用")
      return n
    }

    //   && 逻辑与， 前面判断出结果后，发生短路，后面不再判断
    val n = 1
    println((4 > 5) && m(n) > 0)

3.4 赋值运算符

3.5 位运算符

3.6 Scala运算符本质

---

四、流程控制

4.1 分支控制 if -else