一文速通Scala

文章目录

• 一
• • 1.1
  • • Scala和Java对比【理解】
    • scala环境搭建【掌握】
    • • • 3.4.1 下载指定版本IDEA scala插件.
        • 3.4.2 IDEA配置scala插件
    • scala解释器【掌握】
    • scala小案例【掌握】
  • 1.2
  • • 常量【掌握】
    • 输出语句和分号【掌握】
    • 打招呼【掌握】
    • 变量【掌握】
    • • 语法格式
    • 字符串【掌握】
    • 惰性赋值【掌握】
    • 标识符【掌握】
    • 数据类型【掌握】
    • 类型转换【掌握】
    • 值类型和String类型之间的相互转换【掌握】
    • 键盘录入
  • 1.3

一 1.1

scala相关概述；
scala环境搭建
scala小案例

Scala和Java对比【理解】

1. Java程序编译执行流程
   
   编写java源代码，通过javac将源代码编译为后缀名为.class的字节码文件，然后被类加载器加载到JVM（java虚拟机）中，由它将后缀名为.class的字节码文件转化为 *** 作系统能够直接识别的指令，然后把这些指令交给 *** 作系统来执行。

2. Scala程序编译执行流程
   
   scala源代码，通过scalac编译器将其编译为字节码文件。不同点（两个点），scala通过scalac来编译，scala程序的执行，除了要依赖java类库，还要依赖scala类库。后面的内容都一样，把这些内容加载到类加载器JVM虚拟机中。由它转化为 *** 作系统直接识别的指令，并交给 *** 作系统来执行。

java程序和scala程序的执行流程对比。

代码对比：
定义个学生类，属性为姓名和年龄。

//定义学生类
public class Student{
    private String name;		//姓名
    private int age;			//年龄
    
    //空参和全参构造
    public Student(){}
    
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    //getXxx()和setXxx()方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

//测试类
public class StudentDemo {
     public static void main(String[] args) {
        Student s1 = new Student("张三", 23);	//创建Student类型的对象s1, 并赋值
        System.out.println(s1);				 //打印对象, 查看结果.
    }
}

scala代码：

case class Student(var name:String, var age:Int)		//定义一个Student类
// 这里可以省去new的动作
val s1 = Student("张三", 23)							  //创建Student类型的对象s1, 并赋值
println(s1)											   //打印对象, 查看结果.

scala环境搭建【掌握】

scala程序运行需要依赖于Java类库，那么必须要有Java运行环境，scala才能正确执行. 所以要编译运行scala程序，需要:

• JDK（JDK包含JVM）
• Scala编译器（Scala SDK）

1. 依次安装JDK
2. 安装scala sdk
3. 在idea中安装scala插件

安装JDK 1.8 64位版本，并配置好环境变量, 此过程略.

Scala SDK是scala语言的编译器，要开发scala程序，必须要先安装Scala SDK。本次安装的版本是: 2.11.12

步骤

1. 下载Scala SDK.

   官方下载地址: scala-lang.org/download/
   输入这个地址，
   

首先要确保电脑上已经安装了jdk1.8。

scala两种类型：一种是ide，一种是sbt控制台版本。这里我们选择的是sbt。

msi是安装版，zip是压缩版。使用安装版。

更改安装路径。

不要直接安装到盘副目录下。

2. 安装Scala SDK.

2.1 双击scala-2.11.12.msi，将scala安装在指定目录, 傻瓜式安装, 下一步下一步即可.
2.2 安装路径要合法, 不要出现中文, 空格等特殊符号.

3. 测试是否安装成功

打开控制台，输入: scala -version

安装idea scala插件。IDEA默认是不支持scala程序开发的，所以需要在IDEA中安装scala插件, 让它来支持scala语言。

坑点：下载的idea插件，必须和安装scala的版本一致。

3.4.1 下载指定版本IDEA scala插件.

​ 1. 下载的Scala插件必须和你安装的IDEA版本一致

​ 2. 官方下载地址: http://plugins.jetbrains.com/plugin/1347-scala

下载的scala插件一定要和idea版本一致。

3.4.2 IDEA配置scala插件

1. 选择配置 > 选择插件
   

2. 点击小齿轮 > 选择从本地安装插件

3. 找到下载的插件位置，直接加载zip，点击OK

4. 重新启动IDEA

scala解释器【掌握】

概述，启动，执行，退出

scala解释器，编译和执行scala的代码，实时的进行交互，比较方便测试。

启动scala解释器，Win+R输入scala。

java的输出是：System.out.println()

scala的输出为：println("hello world")

输入一个:quit来退出。

scala小案例【掌握】

​提示用户录入他/她最想对自己说的一句话, 然后将这句话打印到控制台上.

scala可以兼容Java，来访问java库。

步骤：

1. 因为涉及到键盘录入了, 所以先导包.
2. 提示用户录入他/她最想对自己说的一句话.
3. 接收用户录入的内容, 并打印.

//1. 导入Java中的Scanner类.							引入Java类库
import java.util.Scanner
//2. 提示用户录入他/她最想对自己说的一句话.			   Scala代码
println("请录入一句您最想对自己说的一句话: ")
//3. 打印用户录入的内容.								 Scala代码 + Java类库
//不忘初心, 方得始终, 做最好的自己!
// 因为接受的是字符串，所以用nextLine的方法来进行调用
println("我最想对自己说: " + new Scanner(System.in).nextLine())

1.2

1. 掌握变量, 字符串的定义和使用
2. 掌握数据类型的划分和数据类型转换的内容
3. 掌握键盘录入功能
4. 理解Scala中的常量, 标识符相关内容

常量【掌握】

常量指的是: 在程序的运行过程中, 其值不能发生改变的量。
常量分为两类：

• 字面值常量(常用的有以下几种) – 数值本身就是一个常量（和java相同）
  • 整型常量
  • 浮点型常量
  • 字符常量
  • 字符串常量
  • 布尔常量
  • 空常量
• 自定义常量 – 通过特定关键字来人为制造的量

//整型常量
println(10)
//浮点型常量
println(10.3)
//字符常量, 值要用单引号括起来
println('a')
//字符串常量, 值要用双引号括起来
println("abc")
//布尔常量, 值只有true和false
println(true)
//空常量
println(null)

输出语句和分号【掌握】

输出语句分为：换行输出和不换行输出。换行输出通过println来实现，不换行输出通过print来实现。

scala的print或println都是可以来输出多个值，输出语句的小括号直接写多个值，通过英文半角的逗号隔开。
注意: 不管是println(), 还是print()语句, 都可以同时打印多个值.格式为: println(值1, 值2, 值3...)

Scala语句中, 单行代码最后的分号可写可不写. 如果是多行代码写在一行, 则中间的分号不能省略, 最后一条代码的分号可省略不写.

println("Hello, Scala!")			//最后的分号可写可不写
//如果多行代码写在一行, 则前边语句的分号必须写, 最后一条语句的分号可以省略不写.
println("Hello"); println("Scala")

不管是哪种输出，都可以打印出多个值，scala中的分号。单行代码分号可写可不写。

打招呼【掌握】

提示用户录入他/她的姓名和年龄, 接收并打印.

//1. 提示用户录入姓名.
println("请录入您的姓名: ")
//2. 接收用户录入的姓名.
val name = StdIn.readLine()
//3. 提示用户录入年龄.
println("请录入您的年龄: ")
//4. 接收用户录入的年龄.
val age = StdIn.readInt()
//5. 将用户录入的数据(姓名和年龄)打印到控制台上.
println(s"大家好, 我叫${name}, 我今年${age}岁了, 很高兴和大家一起学习Scala!")

导包，提示用户录入信息，并接受，最后把信息输出到控制台

变量【掌握】

变量, 指的就是在程序的执行过程中, 其值可以发生改变的量。定义格式如下：

语法格式

Java变量定义

int a = 0;

在scala中，可以使用val或者var来定义变量，语法格式如下:

val/var 变量名:变量类型 = 初始值

其中

• val定义的是不可重新赋值的变量，也就是自定义常量.
• var定义的是可重新赋值的变量

注意: scala中定义变量时, 类型写在变量名后面
java定义变量时，数据类型写在前面。scala数据类型写在变量名后面，中间用冒号连接。

**需求：**定义一个变量保存一个人的名字"tom"

步骤

1. 打开scala解释器
2. 定义一个字符串类型的变量用来保存名字

scala> val name:String = "tom"
name: String = tom

给名字变量进行重新赋值为Jim，会报出error，因为值只能赋值一次，不可以重新赋值。

scala> name = "Jim"
<console>:12: error: reassignment to val
       name = "Jim"

使用var重新定义变量来保存名字"tom"，并尝试重新赋值为Jim，观察其运行结果。

scala> var name:String = "tom"
name: String = tom

scala> name = "Jim"
name: String = Jim

val和var都可以用来修饰变量，应该来用谁比较好？

注意: 优先使用val定义变量，如果变量需要被重新赋值，才使用var

使用类型推断来定义变量

scala的语法要比Java简洁，我们可以使用一种更简洁的方式来定义变量。变量名的类型不写，由scala直接进行类型推断。

示例

使用更简洁的语法定义一个变量保存一个人的名字"tom"

参考代码

scala> val name = "tom"
name: String = tom

scala可以自动根据变量的值来自动推断变量的类型，这样编写代码更加简洁。自动根据变量的值来推断字段类型，让编写更加的简洁。

字符串【掌握】

scala字符串的方式有三种：

• 使用双引号
• 使用插值表达式
• 使用三引号

双引号，和java相似，包裹的是字符串值：

val/var 变量名 = “hadoop”

有一个人的名字叫"hadoop"，请打印他的名字以及名字的长度。

scala> println(name + name.length)
hadoop6

插值表达式：scala中，使用插值表达式来定义字符串，避免大量字符串的拼接。

val/var 变量名 = s"${变量/表达式}字符串"

注意:

• 在定义字符串之前添加s
• 在字符串中，可以使用${}来引用变量或者编写表达式

定义若干个变量，分别保存：“zhangsan”、23、“male”，定义一个字符串，保存这些信息。

打印输出：name=zhangsan, age=23, sex=male

scala> val name = "zhangsan"
name: String = zhangsan

scala> val age = 23
age: Int = 23

scala> val sex = "male"
sex: String = male

scala> val result = s"name=${name}, age=${age}, sex=${sex}"
result: String = name=zhangsan, age=23, sex=male

scala> println(result)
name=zhangsan, age=23, sex=male

这个和python中的f-string的 *** 作很是相似。

使用三引号：

如果有大段的文本需要保存，就可以使用三引号来定义字符串。例如：保存一大段的SQL语句，三个引号中间的所有内容都将作为字符串的值。

语法：

val/var 变量名 = """字符串1
字符串2"""

定义一个字符串，保存以下SQL语句，

select
	*
from
    t_user
where
    name = "zhangsan"

打印该SQL语句：

val sql = """select
     | *
     | from
     |     t_user
     | where
     |     name = "zhangsan""""

println(sql)

惰性赋值【掌握】

很长的SQL语句如果直接加载到JVM中，会有很大的内存开销, 如何解决这个问题呢？

当有一些变量保存的数据较大时，而这些数据又不需要马上加载到JVM内存中。就可以使用惰性赋值来提高效率。

语法格式：

lazy val/var 变量名 = 表达式

示例

在程序中需要执行一条以下复杂的SQL语句，我们希望只有用到这个SQL语句才加载它。

加载到JVM内存中了，此时又不需要立马用到SQL内容，就会占用内存资源。在定义变量的前面加上lazy，再和刚才的写法一样，就是普通的定义变量的写法。

"""insert overwrite table adm.itcast_adm_personas
    select
    a.user_id,
    a.user_name,
    a.user_sex,
    a.user_birthday,
    a.user_age,
    a.constellation,
    a.province,
    a.city,
    a.city_level,
    a.hex_mail,
    a.op_mail,
    a.hex_phone,
    a.fore_phone,
    a.figure_model,
    a.stature_model,
    b.first_order_time,
    b.last_order_time,
      ...
    d.month1_hour025_cnt,
    d.month1_hour627_cnt,
    d.month1_hour829_cnt,
    d.month1_hour10212_cnt,
    d.month1_hour13214_cnt,
    d.month1_hour15217_cnt,
    d.month1_hour18219_cnt,
    d.month1_hour20221_cnt,
    d.month1_hour22223_cnt
    from gdm.itcast_gdm_user_basic a
      left join gdm.itcast_gdm_user_consume_order b on a.user_id=b.user_id
    left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
    left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""

只有当使用到这个内容的时候，才会去加载它。

scala> lazy val sql = """insert overwrite table adm.itcast_adm_personas
     |     select
     |     a.user_id,
	....
     |     left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
     |     left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""
sql: String = <lazy>

标识符【掌握】

概述，

标识符就是用来给变量, 方法, 类等起名字的. Scala中的标识符和Java中的标识符非常相似.
规范：

• 变量或方法: 从第二个单词开始, 每个单词的首字母都大写, 其他字母全部小写(小驼峰命名法).

  zhangSanAge, student_Country, getSum
  

• 类或特质(Trait): 每个单词的首字母都大写, 其他所有字母全部小写(大驼峰命名法)

  Person, StudentDemo, OrderItems
  

• 包: 全部小写, 一般是公司的域名反写, 多级包之间用.隔开.

  com.itheima.add,  cn.itcast.update
  

数据类型【掌握】

强类型语言和弱类型语言的区别在于，语言对数据类型的划分是否精细。精细–>强类型语言，java，scala。

数据类型是用来约束变量(常量)的取值范围的. Scala也是一门强类型语言, 它里边的数据类型绝大多数和Java一样.我们主要来学习

• 与Java不一样的一些用法
• scala中数据类型的继承体系

数据类型

基础类型	类型说明
Byte	8位带符号整数
Short	16位带符号整数
Int	32位带符号整数
Long	64位带符号整数
Char	16位无符号Unicode字符
String	Char类型的序列（字符串）
Float	32位单精度浮点数
Double	64位双精度浮点数
Boolean	true或false

注意下 scala类型与Java的区别

[!NOTE]

1. scala中所有的类型都使用大写字母开头
2. 整形使用Int而不是Integer
3. scala中定义变量可以不写类型，让scala编译器自动推断
4. Scala中默认的整型是Int, 默认的浮点型是: Double

Scala类型层次结构

Unit类似java的关键字void。一般用于方法中，当方法没有返回值时，用unit作为scala返回值的类型。

Null类型是所有引用类型的子类。它的值只有一个：null

nothing是所有数据类型的子类。不需要创建Nothing类型的对象，一般它是结合异常来进行使用。

类型	说明
Any	所有类型的父类，它有两个子类AnyRef与AnyVal ，相当于java的object
AnyVal	所有数值类型的父类
AnyRef	**所有对象类型（引用类型）**的父类
Unit	表示空，Unit是AnyVal的子类，它只有一个的实例{% em %}() {% endem %} 它类似于Java中的void，但scala要比Java更加面向对象
Null	Null是AnyRef的子类，也就是说它是所有引用类型的子类。它的实例是{% em %}null{% endem %} 可以将null赋值给任何对象类型
Nothing	所有类型的子类, 不能直接创建该类型实例，某个方法抛出异常时，返回的就是Nothing类型，因为Nothing是所有类的子类，那么它可以赋值为任何类型

以下代码是否有问题？这样作会报错，null是所有引用类型的子类，int是数值型类型，所以这样作会出错。

val b:Int = null

Scala会解释报错： Null类型并不能转换为Int类型，说明Null类型并不是Int类型的子类

类型转换【掌握】

当Scala程序在进行运算或者赋值动作时, 范围小的数据类型值会自动转换为范围大的数据类型值, 然后再进行计算.例如: 1 + 1.1的运算结果就是一个Double类型的2.1. 而有些时候, 我们会涉及到一些类似于"四舍五入"的动作, 要把一个小数转换成整数再来计算. 这些内容就是Scala中的类型转换.

Scala中的类型转换分为值类型的类型转换和引用类型的类型转换, 这里我们先重点介绍:值类型的类型转换.
值类型的类型转换分为:

• 自动类型转换
• 强制类型转换

自动类型转换

1. 解释

   范围小的数据类型值会自动转换为范围大的数据类型值, 这个动作就叫：自动类型转换.

   自动类型转换从小到大分别为:Byte, Short, Char -> Int -> Long -> Float -> Double

2. 示例代码

   val a:Int = 3
   val b:Double = 3 + 2.21	//因为是int类型和double类型的值进行计算, 所以最终结果为: Double类型
   val c:Byte = a + 1	//这样写会报错, 因为最终计算结果是Int类型的数据, 将其赋值Byte类型肯定不行.
   

强制类型转换

1. 解释

   范围大的数据类型值通过一定的格式(强制转换函数)可以将其转换成范围小的数据类型值, 这个动作就叫: 强制类型转换.

   注意: 使用强制类型转换的时候可能会造成精度缺失问题!

2. 格式

val/var 变量名:数据类型 = 具体的值.toXxx		//Xxx表示你要转换到的数据类型

3. 参考代码

val a:Double = 5.21
val b:Int = a.toInt
// 小数部分造成丢失，造成精度缺失问题

小的放进大的，叫自动类型转换。大的放小的，叫强制类型转换。

值类型和String类型之间的相互转换【掌握】

有两种方法，在值类型数据后，拼接一个空串来实现；值类型数据.toString方法来实现。

1. 值类型的数据转换成String类型

格式一:

val/var 变量名:String = 值类型数据 + ""

格式二:

val/var 变量名:String = 值类型数据.toString

将Int, Double, Boolean类型的数据转换成其对应的字符串形式。

参考代码:

val a1:Int = 10
val b1:Double = 2.1
val c1:Boolean = true

//方式一: 通过和空字符串拼接的形式实现
val a2:String = a1 + ""
val b2:String = b1 + ""
val c2:String = c1 + ""

//方式二: 通过toString函数实现
val a3:String = a1.toString
val b3:String = b1.toString
val c3:String = c1.toString

2. String类型的数据转换成其对应的值类型

格式:

val/var 变量名:值类型 = 字符串值.toXxx	//Xxx表示你要转换到的数据类型

注意:

• String类型的数据转成Char类型的数据, 方式有点特殊, 并不是调用toChar, 而是toCharArray
• 这点目前先了解即可, 后续我们详细解释

需求:

​ 将字符串类型的整数, 浮点数, 布尔数据转成其对应的值类型数据.

参考代码:

val s1:String = "100"
val s2:String = "2.3"
val s3:String = "false"

//将字符串类型的数据转成其对应的: Int类型
val a:Int = s1.toInt
//将字符串类型的数据转成其对应的: Double类型
val b:Double = s2.toDouble
//将字符串类型的数据转成其对应的: Boolean类型
val c:Boolean = s3.toBoolean

键盘录入

概述
前边我们涉及到的数据, 都是我们写"死"的, 固定的数据, 这样做用户体验并不是特别好. 那如果这些数据是由用户录入, 然后我们通过代码接收, 就非常好玩儿了. 这就是接下来我们要学习的Scala中的"键盘录入"功能.

使用步骤

1. 导包

格式: import scala.io.StdIn

2. 通过StdIn.readXxx()来接收用户键盘录入的数据

接收字符串数据: StdIn.readLine()
接收整数数据: StdIn.readInt()

• 提示用户录入字符串, 并接收打印.

println("请录入一个字符串: ")
val str = StdIn.readLine()
println("您录入的字符串内容为: " + str)

• 提示用户录入整数, 并接收打印.

println("请录入一个整数: ")
val num = StdIn.readInt()
println("您录入的数字为: " + num)

1.3

1. 理解运算符的相关概述
2. 掌握算术, 赋值, 关系, 逻辑运算符的用法
3. 掌握交换变量案例
4. 理解位运算符的用法