大数据开发之Scala

第 1 章：scala入门

1.1 概述

scala将面向对象和函数式编程结合成一种简洁的高级语言

特点

1、scala和java一样属于jvm语言，使用时都需要先编译为class字节码文件，并且scala能够直接调用java的类库

2、scala支持两种编程范式面向对象和函数式编程

3、scala语言更加简洁高效

第 2 章：变量和数据类型

2.1 注释

Scala注释使用和Java完全一样。

注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

1）基本语法

（1）单行注释：//

（2）多行注释：/* /
（3）文档注释：/ *

2）代码规范

（1）使用一次tab操作，实现缩进，默认整体向右边移动，用shift+tab整体向左移。

（2）或者使用ctrl + alt + L来进行格式化。

（3）运算符两边习惯性各加一个空格。比如：2 + 4 * 5。

（4）一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅。

2.2 变量和常量（重点）

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

0）回顾：Java变量和常量语法

变量类型变量名称 = 初始值 int a = 10

final常量类型常量名称 = 初始值 final int b = 20

注意：java中的final如果加static才会被存放在常量池中，否则作为不可修改的变量存在堆栈中。

1）基本语法

var 变量名 [: 变量类型] = 初始值 var i:Int = 10

val 常量名 [: 常量类型] = 初始值 val j:Int = 20

注意：能用常量的地方不用变量。

2）案例实操

（1）声明变量时，类型可以省略，编译器自动推导，即类型推导。

（2）类型确定后，就不能修改，说明Scala是强数据类型语言。

（3）变量声明时，必须要有初始值。

（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。

（5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）。

sql 复制代码

package com.atguigu.chapter02

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

    // 声明变量和常量
    val a: Int = 10
    var b: Int = 20


    // 常量值无法修改
    //    a = 20
    b = 30
    //    （1）声明变量时，类型可以省略，编译器自动推导，即类型推导
    val c = 30


    //    （2）类型确定后，就不能修改，说明Scala是强数据类型语言。

    //    b = "30"

    //    （3）变量声明时，必须要有初始值
    val d: Int = 0

//    var d1:Int = _
	
    val test02_Var = new Test02_Var()
    println(test02_Var.i)
    
    //    （4）var修饰的对象引用可以改变，val修饰的对象则不可改变，
    //    但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
    val person0 = new Person02()
    var person1 = new Person02()

    // 引用数据类型的常量和变量能否替换成别的对象
    // var 可以修改引用数据类型的地址值  val不行
    // 引用数据类型中的属性值能否发生变化  取决于内部的属性在定义的时候是var还是val
    //    person0.name = "lisi"
    person0.age = 11

  }
}

class Test01_Var {

  // scala中类的属性 如果是var变量也能使用默认值  但是必须要有等号
  var i: Int = _
}

class Person01 {
  val name: String = "zhangsan"
  var age: Int = 10
}

2.3 标识符的命名规范

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

1）命名规则

Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下三种规则：

（1）以字母或者下划线开头，后接字母、数字、下划线

（2）以操作符开头，且只包含操作符（+ - * / # !等）

（3）用反引号....包括的任意字符串，即使是Scala关键字（39个）也可以

• package, import, class, object, trait, extends, with, type, for

• private, protected, abstract, sealed, final, implicit, lazy, override

• try, catch, finally, throw

• if, else, match, case, do, while, for, return, yield

• def, val, var

• this, super

• new

• true, false, null

注意：正常使用不能只遵守规则，必须按照规范来写，即使用大小驼峰命名法。

sql 复制代码

package com.atguigu.chapter02

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

    //    （1）字符串，通过+号连接
    System.out.println()
    println("hello" + "world")

    //    （2）重复字符串拼接
    println("linhailinhai" * 200)

    //    （3）printf用法：字符串，通过%传值。
    printf("name: %s age: %d\n", "linhai", 8)

    //    （4）字符串模板（插值字符串）：通过$获取变量值
    val name = "linhai"
    val age = 8

    val s1 = s"name: $name,age:${age}"
    println(s1)

    val s2 = s"name: ${name + 1},age:${age + 2}"
    println(s2)


    //    （5）长字符串  原始字符串
    println("我" +
      "是" +
      "一首" +
      "诗")

    //多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。
    // 输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
    //应用scala的stripMargin方法，在scala中stripMargin默认是"|"作为连接符，
    // 在多行换行的行头前面加一个"|"符号即可。
    println(
      """我
        |是
        |一首
        |诗
        |""".stripMargin)

    """
      |select id,
      |       age
      |from  user_info
      |""".stripMargin


    s"""
       |${name}
       |${age}
       |""".stripMargin
  }
}

2.5 数据类型（重点）

java数据类型

scala数据类型

sql 复制代码

object Test03_Type {
  def main(args: Array[String]): Unit = {	
	// 所有的代码都是代码块
    // 表示运行一段代码  同时将最后一行的结果作为返回值
    // 千万不要写return
    val i: Int = {
      println("我是代码块")
      10 + 10
    }

    // 代码块为1行的时候  大括号可以省略
    val i1: Int = 10 + 10

    // 如果代码块没有计算结果  返回类型是unit
    val unit: Unit = {
      println("hello")
      println("我是代码块")
    }


    // 当代码块没办法完成计算的时候  返回值类型为nothing
    //    val value: Nothing = {
    //      println("hello")
    //      throw new RuntimeException
//    }
}
}

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

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

1）整型分类

2）案例实操

（1）Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。

sql 复制代码

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

    // 整数类型
    val i1 = 1

    val l = 1L

    // （1）Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。
    val b1: Byte = 2
//    val b0: Byte = 128
    
    val b2: Byte = 1 + 1
    println(b2)

    val i2 = 1

    //（2）编译器对于常量值的计算 能够直接使用结果进行编译
    // 但是如果是变量值 编译器是不知道变量的值的 所以判断不能将大类型的值赋值给小的类型
    //    val b3: Byte = i2 + 1
    //    println(b3)

    // （3）Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long
    val l1 = 2200000000L
  }
}

2.8 浮点类型（Float、Double）

Scala的浮点类型可以表示一个小数，比如123.4f，7.8，0.12等等。

1）浮点型分类

2）案例实操

Scala的浮点型常量默认为Double型，声明Float型常量，须后加'f'或'F'。

sql 复制代码

object Test03_Type{

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

    // 浮点数介绍
    // 默认使用double
    val d: Double = 3.14

    // 如果使用float 在末尾添加f
    val fl = 3.14f

    // 浮点数计算有误差
    println(0.1 / 3.3)
    }
}

//运行的结果

sql 复制代码

0.030303030303030307

2.9 字符类型（Char）

1）基本说明

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

2）案例实操

（1）字符常量是用单引号 ' ' 括起来的单个字符。

（2）\t ：一个制表位，实现对齐的功能

（3）\n ：换行符

（4）\ ：表示

（5）" ：表示"

sql 复制代码

object Test03_Type{

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

    //    （1）字符常量是用单引号 ' ' 括起来的单个字符。
    val c1: Char = 'a'
    val c2: Char = 65535

    //    （2）\t ：一个制表位，实现对齐的功能
    val c3: Char = '\t'

    //    （3）\n ：换行符
    val c4: Char = '\n'
    println(c3 + 0)
    println(c4 + 0)

    //    （4）\\ ：表示\
    val c5: Char = '\\'
    println(c5 + 0)

    //    （5）\" ：表示"
    val c6: Char = '\"'
    println(c6 + 0)
  }
}

2.10 布尔类型：Boolean

1）基本说明

（1）布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false

（2）boolean类型占1个字节。

2）案例实操

sql 复制代码

object Test03_Type{

    def main(args: Array[String]): Unit = {
        
        val bo1: Boolean = true
        val bo2: Boolean = false
    }
}

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

1）基本说明

2）案例实操

（1）Unit类型用来标识过程，也就是没有明确返回值的函数。

由此可见，Unit类似于Java里的void。Unit只有一个实例------( )，这个实例也没有实质意义。

sql 复制代码

object Test03_Type{

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


    // unit
    val unit1: Unit = {
      10
      println("1")
    }
    println(unit1)

    // 如果标记对象的类型是unit的话  后面有返回值也没法接收
    // unit虽然是数值类型  但是可以接收引用数据类型   因为都是表示不接收返回值
    val i3: Unit = "aa"
	println(i3)
  }
}

（2）Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）。

sql 复制代码

object Test03_Type {

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

	// scala当中使用的字符串就是java中的string
    val aa: String = "aa"

    // null
    var aa1: String = "aa"

    aa1 = "bb"
    aa1 = null
    if (aa1 != null) {
      val strings: Array[String] = aa1.split(",")
    }

    // 值类型不能等于null,idea不会识别报错  编译器会报错
    var i4 = 10
    //    i4 = null
    }
}

（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。

sql 复制代码

object Test03_Type {

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

    val value: Nothing = {
      println("hello")
      1 + 1
      throw new RuntimeException()
	}    
	}
}

2.12 类型转换

Java的隐式转换规则：

sql 复制代码

public class TestCast {
    public static void main(String[] args) {
        byte n = 23;
        test(n);
    }

    public static void test(byte b) {
        System.out.println("bbbb");
    }

    public static void test(short b) {
        System.out.println("ssss");
    }

    public static void test(char b) {
        System.out.println("cccc");
    }

    public static void test(int b) {
        System.out.println("iiii");
    }
}

2.12.1 数值类型自动转换

当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：

1）基本说明

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

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

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

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

2）案例实操

sql 复制代码

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

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

    val fl: Float = 1 + 1L + 3.14f
    val d: Double = 1 + 1L + 3.14f + 3.14

    //    （2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
    val i = 10
    val b: Double = i

    //    （3）（byte，short）和char之间不会相互自动转换。
    // 因为byte和short是有符号的数值,而char是无符号的
    val b1: Byte = 10
    val c1: Char = 20

    //    （4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
    val b2: Byte = 20
    //    val i1: Byte = b1 + b2
    val i1: Int = 1100000000
    val i2: Int = 1200000000
    // 超出范围的int值计算会造成结果错误
    val i3: Int = i1 + i2
    println(i3)

    }
}

注意：Scala还提供了非常强大的隐式转换机制（隐式函数，隐式类等），我们放在高级部分专门用一个章节来讲解。

2.12.2 强制类型转换

1）基本说明

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

sql 复制代码

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

2）案例实操

（1）将数据由高精度转换为低精度，就需要使用到强制转换。

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

sql 复制代码

object Test04_TypeCast {

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

    // 强制类型转换
    val d1 = 2.999
    //    （1）将数据由高精度转换为低精度，就需要使用到强制转换
    println((d1 + 0.5).toInt)


    //    （2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    println((10 * 3.5 + 6 * 1.5).toInt)    
    }
}

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

1）基本说明

在程序开发中，我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。

2）案例实操

（1）基本类型转String类型（语法：将基本类型的值+"" 即可）。

（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）。

sql 复制代码

bject Test04_TypeCast {

    def main(args: Array[String]): Unit = {
    //    （1）基本类型转String类型（语法：将基本类型的值+"" 即可）
    val string: String = 10.0.toString
    println(string)

    val str: String = 1 + ""

    //    （2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
    val double: Double = "3.14".toDouble

    println(double + 1)
    println(double.toInt)

    // 不能直接将小数类型的字符串转换为整数  需要先转换为double再转换int
    //    println("3.14".toInt)

	// 标记为f的float数能够识别
//    println("12.6f".toFloat)    
}
}

扩展面试题数值存储机制介绍：

sql 复制代码

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

		// 将int值130强转为byte  值为多少
		// 0000 0000 ..16.. 1000 0010   => 表示int的130
		val i4 = 130

		// 1000 0010
		println(i4.toByte)
	}

第3章运算符

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

3.1 算术运算符

1）基本语法

3.2 关系运算符（比较运算符）

1）基本语法

2）案例实操

（1）需求1

sql 复制代码

object Test01_Operation{

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

        // 测试：>、>=、<=、<、==、!=
        var a: Int = 2
        var b: Int = 1

        println(a > b)      // true
        println(a >= b)     // true
        println(a <= b)     // false
        println(a < b)      // false
        println("a==b" + (a == b))    // false
        println(a != b)     // true
    }
}

（2）需求2：Java和Scala中关于==的区别

Java：

==比较两个变量本身的值，即两个对象在内存中的首地址；

equals比较字符串中所包含的内容是否相同。

sql 复制代码

public static void main(String[] args) {
    
    String s1 = "abc";
    String s2 = new String("abc");

    System.out.println(s1 == s2);

    System.out.println(s1.equals(s2));
}
输出结果：
false
true

Scala：==更加类似于Java中的equals，参照jd工具

sql 复制代码

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

    val s1 = "abc"

    val s2 = new String("abc")

    println(s1 == s2)
    println(s1.eq(s2))
}

输出结果：
true
false

3.3 逻辑运算符

1）基本语法

用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个Boolean值。

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

2）案例实操

sql 复制代码

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

        // 测试：&&、||、!
        var a = true
        var b = false

        println("a&&b=" + (a && b))     // a&&b=false
        println("a||b=" + (a || b))     // a||b=true
        println("!(a&&b)=" + (!(a && b))) // !(a&&b)=true
    }
}

扩展避免逻辑与空指针异常
def isNotEmpty(String s){
	//如果按位与，s为空，会发生空指针
	return s!=null && !"".equals(s.trim());
}

3.4 赋值运算符

1）基本语法

赋值运算符就是将某个运算后的值，赋给指定的变量。

注意：Scala中没有++、--操作符，可以通过+=、-=来实现同样的效果；

2）案例实操

sql 复制代码

object Test01_Operation {
    
    def main(args: Array[String]): Unit = {
        
        var r1 = 10
        
        r1 += 1 // 没有++
        r1 -= 2 // 没有--
    }
}

3.5 位运算符

1）基本语法

下表中变量 a 为 60，b 为 13。

2）案例实操

sql 复制代码

object Test01_Operation {

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

        // 测试：1000 << 1 =>10000
        var n1 :Int =8

        n1 = n1 << 1
        println(n1)
    }
}

3.6 Scala运算符本质

在Scala中其实是没有运算符的，所有运算符都是方法。

（1）当调用对象的方法时，点.可以省略

（2）如果函数参数只有一个，或者没有参数，()可以省略

sql 复制代码

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

        // 标准的加法运算
        val i:Int = 1.+(1)

        // （1）当调用对象的方法时，.可以省略
        val j:Int = 1 + (1)

        // （2）如果函数参数只有一个，或者没有参数，()可以省略
        val k:Int = 1 + 1
        
        println(1.toString())
        println(1 toString())
        println(1 toString)
    }
}

第4章流程控制（没有Switch）

4.1 分支控制if-else

让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支

1）案例实操

（1）需求1：需求：输入年龄，如果年龄小于18岁，则输出"童年"。如果年龄大于等于18且小于等于60，则输出"中年"，否则，输出"老年"。

sql 复制代码

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

        println("input age")
        var age = StdIn.readInt()

        if (age < 18){
            println("童年")
        }else if(age>=18 && age<60){
            println("中年")
        }else{
            println("老年")
        }
    }
}

（2）需求2：Scala中if else表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。

sql 复制代码

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

        println("input age")
        var age = StdIn.readInt()

        val res :String = if (age < 18){
            "童年"
        }else if(age>=18 && age<60){
            "中年"
        }else{
            "老年"
        }

        println(res)
    }

（3）需求3：Scala中返回值类型不一致，取它们共同的祖先类型。

sql 复制代码

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

        println("input age")
        var age = StdIn.readInt()

        val res:Any = if (age < 18){
            "童年"
        }else if(age>=18 && age<60){
            "中年"
        }else{
            100
        }

        println(res)
    }
}

（4）需求4：Java中的三元运算符可以用if else实现

如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if只对最近的一行逻辑代码起作用。

sql 复制代码

object Test01_If {

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

        // Java
        // int result = flag?1:0

        // Scala
        println("input age")
        var age = StdIn.readInt()
        val res:Any = if (age < 18)  "童年" else "成年"
"不起作用"

        println(res)
    }
}

4.2 Switch分支结构

在Scala中没有Switch，而是使用模式匹配来处理。

模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。

4.3 For循环控制

Scala也为for循环这一常见的控制结构提供了非常多的特性，这些for循环的特性被称为for推导式或for表达式。

4.3.1 基本语法

1）基本语法

sql 复制代码

object Test02_ForLoop {
  def main(args: Array[String]): Unit = {
    // scala中的for循环基础语法
    for (i <- 0 to 5) {
      println(i)
    }

    for (i <- 0 until 5) {
      println(i)
    }

    // for循环的本质
    // to是整数的方法  返回结果是一个集合
    // 使用变量i 循环遍历一遍 后面集合的内容
    val inclusive: Range.Inclusive = 0.to(5)

}

4.3.1 补充语法

补充语法有：

（1）循环守卫

（2）循环返回值

sql 复制代码

object Test02_ForLoop {
  def main(args: Array[String]): Unit = {
    
    // 循环守卫
    for (i <- 0 to 10) {
      if (i > 5) {
        println(i)
      }
    }

    for (i <- 0 to 10 if i > 5) {
      println(i)
    }

    // 循环返回值
    val ints: immutable.IndexedSeq[Int] = for (i <- 0 to 3) yield {
      10
    }
  }
}

4.5 While和do...While循环控制

While和do...While的使用和Java语言中用法相同。

4.5.1 While循环控制

1）基本语法

循环变量初始化

while (循环条件) {

循环体(语句)

循环变量迭代

}

说明：

（1）循环条件是返回一个布尔值的表达式

（2）while循环是先判断再执行语句

（3）与for语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()

（4）因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。

2）案例实操

sql 复制代码

object Test03_While {

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

    var i = 0
    while (i < 5) {
      println(i)
      i += 1
    }

    while (i < 5) {
      println(i)
      i += 1
}
}

4.5.2 do...while循环控制

1）基本语法

循环变量初始化;

do{

循环体(语句)

循环变量迭代

} while(循环条件)

说明

（1）循环条件是返回一个布尔值的表达式

（2）do...while循环是先执行，再判断

2）案例实操

sql 复制代码

object Test03_While {
  def main(args: Array[String]): Unit = {
    var i = 0
    // do while 一定会执行一次  不管条件是否成立
    do {
      println(i)
}while(i > 100)
  }

}

4.6 循环中断

1）基本说明

Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用breakable控制结构来实现break和continue功能。

2）案例实操

需求1：采用异常的方式退出循环

sql 复制代码

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

    try {
        for (elem <- 1 to 10) {
            println(elem)
            if (elem == 5) throw new RuntimeException
        }
    }catch {
        case e =>
    }

    println("正常结束循环")
}

需求2：采用Scala自带的函数，退出循环

sql 复制代码

import scala.util.control.Breaks

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

    Breaks.breakable(
        for (elem <- 1 to 10) {
            println(elem)
            if (elem == 5) Breaks.break()
        }
    )

    println("正常结束循环")
}

需求3：对break进行省略

sql 复制代码

import scala.util.control.Breaks._

object TestBreak {

    def main(args: Array[String]): Unit = {
    
        breakable {
            for (elem <- 1 to 10) {
                println(elem)
                if (elem == 5) break
            }
        }
    
        println("正常结束循环")
    }
}

第5章函数式编程

1）面向对象编程

解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。

对象：用户；

行为：登录、连接jdbc、读取数据库

属性：用户名、密码

Scala语言是一个完全面向对象编程语言。万物皆对象

2）函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装(函数)，通过调用这些封装好的步骤，解决问题。

例如：请求->用户名、密码->连接jdbc->读取数据库

Scala语言是一个完全函数式编程语言。万物皆函数

3）在Scala中函数式编程和面向对象编程融合在一起了。

5.1 方法基本语法

1）基本语法

2）案例实操

需求：定义一个方法，实现将传入的名称打印出来。

sql 复制代码

object TestFunction {

    def main(args: Array[String]): Unit = {
        // 1 方法声明
        def f(arg: String): Unit = {
            println(arg)
        }

        // 2 方法调用
        // 方法名（参数）
        f("hello world")
    }
}

5.2 方法声明

1）方法声明

（1）方法1：无参，无返回值

（2）方法2：无参，有返回值

（3）方法3：有参，无返回值

（4）方法4：有参，有返回值

（5）方法5：多参，无返回值

2）案例实操

sql 复制代码

package com.atguigu.chapter06

object TestFunctionDeclare {

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

        // 方法1：无参，无返回值
        def test(): Unit ={
            println("无参，无返回值")
        }
        test()

        // 方法2：无参，有返回值
        def test2():String={
            return "无参，有返回值"
        }
        println(test2())

        // 方法3：有参，无返回值
        def test3(s:String):Unit={
            println(s)
        }
        test3("jinlian")

        // 方法4：有参，有返回值
        def test4(s:String):String={
            return s+"有参，有返回值"
        }
        println(test4("hello "))


        // 方法5：多参，无返回值
        def test5(name:String, age:Int):Unit={
            println(s"$name, $age")
        }
        test5("dalang",40)
    }
}

5.3 方法参数

1）案例实操

（1）可变参数

（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后，（不能和默认值一起用，和带名参数用时，不能改变带名参数的顺序）

（3）参数默认值，一般将有默认值的参数放置在参数列表的后面

（4）带名参数

sql 复制代码

object Test03_FunArgs {

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

    // (1)可变参数
    def sayHi(names:String*):Unit = {
      println(s"hi $names")
      // 可变参数在函数值本质是一个数组
      for (elem <- names) {

      }
    }

    sayHi()
    sayHi("linhai")
    sayHi("linhai","jinlian")

    // 可变参数使用:
    // (2)可变参数必须在参数列表的最后
    def sayHi1(sex: String,names:String*):Unit = {
      println(s"hi $names")
    }

    // (3)参数默认值
    def sayHi2(name:String = "linhai"):Unit = {
      println(s"hi ${name}")
    }

    sayHi2("linhai")
    sayHi2()


    // 默认值参数在使用的时候 可以不在最后
    def sayHi3( name:String = "linhai" , age:Int):Unit = {
      println(s"hi ${name}")
}

    // (4)带名参数
    sayHi3(age = 10)
  }
}

5.4 方法至简原则

方法至简原则：能省则省

1）至简原则细节

常用化简写法：

（1）return可以省略，Scala会使用方法体的最后一行代码作为返回值

（2）如果方法体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

特别注意事项：

（4）如果有return，则不能省略返回值类型，必须指定

（5）如果方法明确声明unit，那么即使方法体中使用return关键字也不起作用

（6）Scala如果期望是无返回值类型，可以省略等号（=号和方法体大括号不能同时省略）

（7）如果方法无参，但是声明了参数列表，那么调用时，小括号，可加可不加（声明无括号调用时也没有括号）

（8）如果方法没有参数列表，那么小括号可以省略，调用时小括号必须省略

2）案例实操

sql 复制代码

object Test04_FuncSimply {

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

    // 定义一个原方法
    def func0(x: Int, y: Int): Int = {
      println("func0的调用")
      if (x < 20) {
        return x + y
      }
      2 * x + 3 * y
    }

    println(func0(10, 20))

    //    （1）return可以省略，Scala会使用方法体的最后一行代码作为返回值
    def func1(x: Int, y: Int): Int = {
      println("func1的调用")
      x + y
    }

    val i: Int = func1(10, 20)
    println(i)


    //    （2）如果方法体只有一行代码，可以省略花括号
    // 如果不写大括号 默认有效范围只有一行
    def func2(x: Int, y: Int): Int = x + y


    //    （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    def func3(x: Int, y: Int) = x + y


    //    （4）如果有return，则不能省略返回值类型，必须指定
    def func4(x: Int, y: Int): Int = {
      if (x < 20) {
        return x + y
      }
      2 * x + 3 * y
    }

    func4(10, 20)

    //    （5）如果方法明确声明unit，那么即使函数体中使用return关键字也不起作用
    def func5(x: Int, y: Int): Unit = return x + y

    val unit: Unit = func5(10, 20)

    //    （6）Scala如果期望是无返回值类型，可以省略等号
    def func6(x: Int, y: Int) {
      println(x + y)
    }


    //    （7）如果方法无参，但是声明了参数列表，那么调用时，小括号，可加可不加
    def func7(): Unit = {
      println("hello")
    }

    func7()
    func7

    //    （8）如果方法没有参数列表，那么小括号可以省略，调用时小括号必须省略
    def func8 {
      println("hello")
    }

    func8

  }
}

5.5 函数的基本语法

1）基本语法：

函数的返回值就是函数体中最后一个表达式的结果值/return语句的返回值

2）案例实操

需求：定义一个函数，实现将传入的两个整数相加。

sql 复制代码

object TestFunction {

    def main(args: Array[String]): Unit = {
        // 1 函数
        val add = (x:Int,y:Int) => { x + y }

        // 2 函数调用
        // 函数名（参数）
        val result = add(10,20)
        println(result)
    }
}

5.6 函数和方法的区别

1）方法定义在类中可以实现重载，函数不可以重载

2）方法是保存在方法区，函数是保存在堆中

3）定义在方法中的方法可以称之为函数，不可以重载

4）方法可以转成函数, 转换语法: 方法名 _

sql 复制代码

object TestFunction {

    //方法可以进行重载和重写，程序可以执行
    def main(): Unit = {

}
//定义一个方法
def add(x:Int,y:Int) = x+y

    def main(args: Array[String]): Unit = {
        //Scala语言的语法非常灵活，可以在任何的语法结构中声明任何的语法
        import java.util.Date
        new Date()

        //函数没有重载和重写的概念，程序报错
        val test =()=> {
            println("无参，无返回值")
        }
        test()

        val test = (name:String)=>{
            println()
        }

        //（3）scala中函数可以嵌套定义
        val test2 = ()=>{

            val test3 = (name:String)=>{
                println("函数可以嵌套定义")
            }
        }
		//(4) 方法可以转成函数
        val add2 = add _
    }
}

5.7 高阶函数

1）说明

定义：参数/返回值为函数的方法/函数称为高阶函数

2）案例实操

sql 复制代码

object TestFunction {

    def main(args: Array[String]): Unit = {
		//制作一个计算器
        //高阶函数------------函数作为参数
        def calculator(a: Int, b: Int, operater: (Int, Int) => Int): Int = {
            operater(a, b)
        }

        //函数------------求和
        def plus(x: Int, y: Int): Int = {
            x + y
        }

        //方法------------求积
        def multiply(x: Int, y: Int): Int = {
            x * y
        }

        //函数作为参数
        println(calculator(2, 3, plus))
        println(calculator(2, 3, multiply))
    }
}

5.8 匿名函数

1）说明

没有名字的函数/方法就是匿名函数。

(x:Int)=>{函数体}

x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

2）案例实操

需求1：传递的函数有一个参数

传递匿名函数至简原则：

（1）参数的类型可以省略，会根据形参进行自动的推导

（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。

（3）匿名函数如果只有一行，则大括号也可以省略

（4）如果参数只出现一次，且按照顺序出现则参数省略且后面参数可以用_代替

不能化简为下划线的情况： 1.化简之后只有一个下划线 2.化简后的函数存在嵌套

sql 复制代码

def main(args: Array[String]): Unit = {
    val f0: (Int, Int) => Int = (x: Int, y: Int) => x + y

    //    （1）参数的类型可以省略，会根据形参进行自动的推导
    val f1: (Int, Int) => Int = (x, y) => x + y

    //    （2）类型省略之后，发现只有一个参数，则圆括号可以省略；
    //    其他情况：没有参数和参数超过1的永远不能省略圆括号。
    val f2: (Int, Int) => Int = (x, y) => x + y
    val f3: Int => Int = x => x + 22

    val f4: () => Int = () => 10


    //    （3）匿名函数如果只有一行，则大括号也可以省略
    val f5: (Int, Int) => Int = (x, y) => {
      println("匿名函数")
      x + y
    }

    //    （4）如果参数只出现一次，且按照顺序出现，则参数省略且后面参数可以用_代替
    val f6: (Int, Int) => Int = _ + _


    // 化简为_的条件
    // 1. 传入的参数类型可以推断 所以可以省略
    val f7: (Int, Int) => Int = (x, y) => y - x

    // 2. 参数必须只使用一次  使用的顺序必要和定义的顺序一样
    val f8: (Int, Int) => Int = -_ + _


    // 如果化简为匿名函数  只剩下一个_  则不可以化简
    val function: String => String = _ + ""
    val str: String = function("linhai")
    val function1: String => String = a => a


    // 如果化简的下划线在函数里面  也会报错
//    val function1: String => Unit = println(_ + "hi")

    val function2: String => Unit = println
    function2("linhai")
}

5.9 函数柯里化&闭包

1）说明

函数柯里化：将一个接收多个参数的函数转化成一个接受一个参数的函数过程，可以简单的理解为一种特殊的参数列表声明方式。

闭包：就是一个函数和与其相关的引用环境（变量）组合的一个整体(实体)

2）案例实操

（1）闭包

sql 复制代码

//外部变量
var z: Int = 10

//闭包
def f(y: Int): Int = {
      z + y
}

复制代码

（2）柯里化

sql 复制代码

object TestFunction {

  val sum = (x: Int, y: Int, z: Int) => x + y + z

  val sum1 = (x: Int) => {
    y: Int => {
      z: Int => {
        x + y + z
      }
    }
  }

  val sum2 = (x: Int) => (y: Int) => (z: Int) => x + y + z

  def sum3(x: Int)(y: Int)(z: Int) = x + y + z


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

    sum(1, 2, 3)
    sum1(1)(2)(3)
    sum2(1)(2)(3)
    sum3(1)(2)(3)
    
  }
}

5.10 递归

1）说明

一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

2）案例实操

sql 复制代码

object TestFunction {

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

        // 阶乘
        // 递归算法
        // 1) 方法调用自身
        // 2) 方法必须要有跳出的逻辑
        // 3) 方法调用自身时，传递的参数应该有规律
        // 4) scala中的递归必须声明函数返回值类型

        println(test(5))
    }

    def test( i : Int ) : Int = {
        if ( i == 1 ) {
            1
        } else {
            i * test(i-1)
        }
    }
}

第6章面向对象

Scala的面向对象思想和Java的面向对象思想和概念是一致的。

Scala中语法和Java不同，补充了更多的功能。

6.1 类和对象

类：可以看成一个模板

对象：表示具体的事物

6.1.1 定义类

0）回顾：Java中的类

如果类是public的，则必须和文件名一致。

一般，一个.java有一个public类

注意：Scala中没有public，一个.scala中可以写多个类。

1）基本语法

若提取对象的多个属性，则提取器为unapply(obj:Obj):Option[(T1,T2,T3...)]

若提取对象的可变个属性，则提取器为unapplySeq(obj:Obj):Option[Seq[T]]

2）样例类

（1）语法：

case class Person05 (name: String, age: Int)

（2）说明

样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，如apply、unapply、toString、equals、hashCode和copy。

样例类是为模式匹配而优化的类，因为其默认提供了unapply方法，因此，样例类可以直接使用模式匹配，而无需自己实现unapply方法。

构造器中的每一个参数都成为val，除非它被显式地声明为var（不建议这样做）

（3）实操

上述匹配对象的案例使用样例类会节省大量代码

sql 复制代码

case class Person05(var name: String, age: Int)

8.3 偏函数中的模式匹配

偏函数也是函数的一种，通过偏函数我们可以方便的对输入参数做更精确的检查。例如该偏函数的输入类型为List[Int]，而我们需要的是第一个元素是0的集合，这就是通过模式匹配实现的。

1）偏函数定义

sql 复制代码

val second: PartialFunction[List[Int], Option[Int]] = {
    case x :: y :: _ => Some(y)
}

注：该偏函数的功能是返回输入的List集合的第二个元素。

2）偏函数原理

上述代码会被scala编译器翻译成以下代码，与普通函数相比，只是多了一个用于参数检查的函数------isDefinedAt，其返回值类型为Boolean。

sql 复制代码

al second = new PartialFunction[List[Int], Option[Int]] {

    //检查输入参数是否合格
    override def isDefinedAt(list: List[Int]): Boolean = list match {
        case x :: y :: _ => true
        case _ => false
    }

    //执行函数逻辑
    override def apply(list: List[Int]): Option[Int] = list match {
        case x :: y :: _ => Some(y)
    }
}

3）偏函数使用

偏函数不能像second(List(1,2,3))这样直接使用，因为这样会直接调用apply方法，而应该调用applyOrElse方法，如下

second.applyOrElse(List(1,2,3), (_: List[Int]) => None)

applyOrElse方法的逻辑为 if (ifDefinedAt(list)) apply(list) else default。如果输入参数满足条件，即isDefinedAt返回true，则执行apply方法，否则执行defalut方法，default方法为参数不满足要求的处理逻辑。

3）案例实操

（1）需求

将该List(1,2,3,4,5,6,"test")中的Int类型的元素加一，并去掉字符串。

（2）实操

sql 复制代码

object Test06_PartitionFunc {

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

	// 将该List(1,2,3,4,5,6,"test")中的Int类型的元素加一，并去掉字符串。
    val list = List(1, 2, 3, 4, 5, 6, "test")

    // 步骤一: 过滤掉字符串
    val list1: List[Any] = list.filter((a: Any) => a match {
      case s: String => false
      case i: Int => true
    })

    // 步骤二: 对int值加一
    val list2: List[Int] = list1.map((a: Any) => {
      a match {
        case i: Int => i + 1
      }
    })

    println(list2)

    val list3: List[Int] = list.collect({
      case i: Int => i + 1
    })

    println(list3)

    val value:PartialFunction[Any, Int] =  {
      case i: Int => i + 1
    }

    // 函数的定义 需要多写一个math关键字
    // 偏函数将match关键字省略
    val function: Any => Int = (a: Any) => a match {
      case i: Int => i + 1
}
  }
}

方法一：

List(1,2,3,4,5,6,"test").filter(.isInstanceOf[Int]).map( .asInstanceOf[Int] + 1).foreach(println)

方法二：

List(1, 2, 3, 4, 5, 6, "test").collect { case x: Int => x + 1 }.foreach(println)

8.4 下划线的使用总结

附加内容：下划线的使用总结。

（1）用于类中的var属性，使用默认值。

（2）用于高阶函数的第一种用法，表示函数自身。

（3）匿名函数化简，用下划线代替变量。

（4）用于导包下的所有内容。

（5）用于起别名时表示匿名。

（6）用于模式匹配表示任意数据。

sql 复制代码

object Test01_Extends {

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

    // 下滑线的使用总结
    //    （2）用于高阶函数的第一种用法，表示函数自身
    def sayHi(name: String): Unit = {
      println(s"hi $name")
    }

    val function: String => Unit = sayHi _

    //    （3）匿名函数化简，用下划线代替变量
    val function1: (Int, Int) => Int = (a: Int, b: Int) => a + b
    val function2: (Int, Int) => Int = _ + _


    //    （4）用于导包下的所有内容
    import scala.util.control.Breaks._

    //    （5）用于起别名时表示匿名
    import scala.util.control.{Breaks => _}
    //    Breaks

	//	   （6）用于模式匹配表示任意数据
	10 match {
      case 10 => println(10)
      case _ => println("其他数据")
    }
  }
}

class Person01 {
  //    （1）用于类中的var属性，使用默认值
  var name: String = _
}

第9章异常

语法处理上和Java类似，但是又不尽相同。

9.1 Java异常处理

sql 复制代码

public class ExceptionDemo {

    public static void main(String[] args) {

        try {
            int a = 10;
            int b = 0;
            int c = a / b;
        }catch (ArithmeticException e){
// catch时，需要将范围小的写到前面
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("finally");
        }
    }
}

注意事项

（1）Java语言按照try---catch---finally的方式来处理异常

（2）不管有没有异常捕获，都会执行finally，因此通常可以在finally代码块中释放资源。

（3）可以有多个catch，分别捕获对应的异常，这时需要把范围小的异常类写在前面，把范围大的异常类写在后面，否则编译错误。

9.2 Scala异常处理

sql 复制代码

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

    try {
        var n= 10 / 0
    }catch {
        case ex: ArithmeticException=>{
            // 发生算术异常
            println("发生算术异常")
        }
        case ex: Exception=>{
            // 对异常处理
            println("发生了异常1")
            println("发生了异常2")
        }
    }finally {
        println("finally")
    }
}

（1）我们将可疑代码封装在try块中。在try块之后使用了一个catch处理程序来捕获异常。如果发生任何异常，catch处理程序将处理它，程序将不会异常终止。

（2）Scala的异常的工作机制和Java一样，但是Scala没有"checked（编译期）"异常，即Scala没有编译异常这个概念，异常都是在运行的时候捕获处理。

（3）异常捕捉的机制与其他语言中一样，如果有异常发生，catch子句是按次序捕捉的。因此，在catch子句中，越具体的异常越要靠前，越普遍的异常越靠后，如果把越普遍的异常写在前，把具体的异常写在后，在Scala中也不会报错，但这样是非常不好的编程风格。

（4）finally子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清理工作，这点和Java一样。

（5）用throw关键字，抛出一个异常对象。所有异常都是Throwable的子类型。throw表达式是有类型的，就是Nothing，因为Nothing是所有类型的子类型，所以throw表达式可以用在需要类型的地方

sql 复制代码

def test():Nothing = {
    throw new Exception("不对")
}

（6）Java提供了throws关键字来声明异常。可以使用方法定义声明异常。它向调用者函数提供了此方法可能引发此异常的信息。它有助于调用函数处理并将该代码包含在try-catch块中，以避免程序异常终止。在Scala中，可以使用throws注解来声明异常

sql 复制代码

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

@throws(classOf[NumberFormatException])
def f11()={
  	"abc".toInt
}

第10章隐式转换

当编译器第一次编译失败的时候，会在当前的环境中查找能让代码编译通过的方法，用于将类型进行转换，实现二次编译，用于拓展类的方法。

10.1 隐式函数

1）说明

隐式转换可以在不需改任何代码的情况下，扩展某个类的功能。

2）案例实操

需求：通过隐式转化为Int类型增加方法。

sql 复制代码

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

    // 隐式函数
    // 将当前作用域下所有传入参数的类型   隐式转换为  返回值类型
    implicit def changeInt(self: Int) = {
      new MyRichInt(self)
    }

    val i: Int = 10


    // 比较自身和传入参数的大小  返回较大的值
    val value: Int = i.myMax(20)
    println(value)


    val i1: Int = i << 2
    println(i1)

  }


  // 隐式转换的目标
  class MyRichInt(val self: Int) {

    def myMax(i: Int): Int = {
      if (i > self) i else self
    }

    // 如果隐式转换和自身的方法冲突  会使用它自身的  因为不会编译失败
    def <<(x: Int): Int = {
      0
    }
  }
}

大数据开发之Scala

第 1 章：scala入门

1.1 概述

第 2 章：变量和数据类型

2.1 注释

2.2 变量和常量（重点）

2.3 标识符的命名规范

2.5 数据类型（重点）

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

2.8 浮点类型（Float、Double）

2.9 字符类型（Char）

2.10 布尔类型：Boolean

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

2.12 类型转换

2.12.1 数值类型自动转换

2.12.2 强制类型转换

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

第3章 运算符

3.1 算术运算符

3.2 关系运算符（比较运算符）

3.3 逻辑运算符

3.4 赋值运算符

3.5 位运算符

3.6 Scala运算符本质

第4章 流程控制（没有Switch）

4.1 分支控制if-else

4.2 Switch分支结构

4.3 For循环控制

4.3.1 基本语法

4.3.1 补充语法

4.5 While和do...While循环控制

4.5.1 While循环控制

4.5.2 do...while循环控制

4.6 循环中断

第5章 函数式编程

5.1 方法基本语法

5.2 方法声明

5.3 方法参数

5.4 方法至简原则

5.5 函数的基本语法

5.6 函数和方法的区别

5.7 高阶函数

5.8 匿名函数

5.9 函数柯里化&闭包

5.10 递归

第6章 面向对象

6.1 类和对象

6.1.1 定义类

8.3 偏函数中的模式匹配

8.4 下划线的使用总结

第9章 异常

9.1 Java异常处理

9.2 Scala异常处理

第10章 隐式转换

10.1 隐式函数

第3章运算符

第4章流程控制（没有Switch）

第5章函数式编程

第6章面向对象

第9章异常

第10章隐式转换