Scala学习笔记

àì夳堔傛蜴生んèń 2021-09-30 03:28 598阅读 0赞

# Scala学习笔记 #

本文是基于Windows 10系统环境，学习Scala基本语法

*  **Windows 10**

--------------------

## 一、环境搭建 ##

### (1) java安装和配置 ###

[具体过程参考该链接][Link 1]

### (2) scala安装 ###

下载并解压至某个路径

### (3) scala配置环境变量 ###

![在这里插入图片描述][20200629172955655.png]  
![在这里插入图片描述][20200629173006340.png]

### (4) 安装scala插件 ###

打开IntelliJ 点击安装scala

## 二、创建一个hello world程序 ##

### (1) 创建工程 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70]

### (2) 添加scala SDK ###

右击项目，选择 “Open Module Settings”  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 1]

在左侧选项中单击“Libraries”，然后单击“+”，并在下拉弹出框中选中"Scala SDK"  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 2]  
单击"Browse"按钮，选择下载好的Scala文件夹根目录  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 4]  
首先点击“Apply”，然后点击“OK”  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 5]

### (3) 编写代码 ###

新建一个scala目录，并标记为source root  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 6]

### (5) 代码约定 ###

scala是完全面向对象，故scala去掉了java中非面向对象的元素，如static关键字，void类型

1.  static  
    scala无static关键字，由object实现类似静态方法的功能（类名.方法名）  
    class关键字和java中的class关键字作用相同，用来定义一个类
2.  void  
    对于无返回值的函数，scala定义其返回值类型为Unit类
3.  object  
    object也被称为伴生对象或者单例对象

### (6) 整合spark ###

scala整合spark，pom文件中引入了spark-core和spark-mllib的依赖，同时引入了scala打包的插件

*  **pom.xml**

<dependencies>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-core_2.12</artifactId>
                <version>3.0.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-mllib_2.12</artifactId>
                <version>3.0.0</version>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>2.5.5</version>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.scala-tools</groupId>
                    <artifactId>maven-scala-plugin</artifactId>
                    <version>2.15.2</version>
                    <executions>
                        <execution>
                            <id>scala-compile-first</id>
                            <phase>process-resources</phase>
                            <goals>
                                <goal>compile</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>scala-test-compile</id>
                            <phase>process-test-resources</phase>
                            <goals>
                                <goal>testCompile</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>

*  **Cluster\_Kmeans.object**

object Cluster_Kmeans { 
        def main(args: Array[String]): Unit = { 
            val conf = new SparkConf().setMaster("local[*]").setAppName("Clusetr_Kmeans")
            val sc = new SparkContext(conf)
    
            val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
            def mapFunction(num: Int): Int = { 
                num * 2
            }
            val mapRDD: RDD[Int] = rdd.map(_ * 2)
            mapRDD.collect().foreach(println)
            println(args(0))
            sc.stop()
        }
    }

### (7) 上传至spark集群 ###

spark-submit --class com.chaoyue.spark.mllib.demo.cluster.Cluster_Kmeans spark-mllib-demo-1.0-SNAPSHOT-jar-with-dependencies.jar

## 三、基础语法 ##

### (1) 注释 ###

1.  单行注释： //
2.  多行注释： /\* \*/
3.  文档注释：

/**
     *
     */

### (2) 变量声明 ###

*  **声明不可变的变量 val**

val myStr = "Hello,world"
    val myStr : String = "Hello,world"
    val myStr : java.lang.String = "Hello,world"
    // val 声明为不可变的变量，声明的时候必须初始化

*  **声明可变的变量 var**

var myPrice : Double = 3.5
    // var 声明为可变的变量，声明的时候需要初始化，初始化后还可以再次对其赋值

*  **基本数据类型**

Byte、Char、Short、Int、Long、Float、Double、Boolean
    // 在scala中每一个基本类型都是一个类，例如Int的全名为scala.Int
    // 比较特殊的是String，使用的是java.lang.Stirng

*  **基本原则**

1.  能用常量的地方，尽量用常量，少用变量
2.  声明变量时，类型可以省略，编译器自动推导，即类型推导
3.  类型确定后，就不能修改，说明scala是强数据类型语言
4.  变量声明后，必须有初始值
5.  在声明/定义一个变量时，可以使用var或val来修饰，var修饰的变量可改变，val修饰的变量不可改
6.  var修饰的对象引用可以改变，val修饰的对象则不可改变，但是对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等）

### (3) 命名规则 ###

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

### (4) scala数据类型 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 7]

1.  scala中一切数据都是对象，都是Any的子类
2.  scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象
3.  scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
4.  scala中的StringOps是对Java中String的增强
5.  Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。void不是数据类型，只是一个关键字
6.  Null是一个类型，只有一个对象就是null。它是所有引用类型AnyRef的子类
7.  Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数

### (5) 类型转换 ###

#### 5.1 数值类型自动转换 ####

当scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 8]

1.  自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
2.  把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
3.  （byte，short）和char之间不会相互自动转换。
4.  byte，short，char他们三者可以计算，在计算时首先转换为int类型。

#### 5.2 强制类型转换 ####

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

#### 5.3 数值类型和String类型间转换 ####

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

1.  基本类型转String类型（语法：将基本类型的值+"" 即可）
2.  String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
3.  在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。  
    var n5:Int = “12.6”.toInt会出现NumberFormatException异常。

### (4) 算数运算 ###

val sum1 = 3 + 5
    val sum2 = (3).+(5) 
    var i = 0
    i += 1 // 递增，不可以使用 i++
    // val 声明为不可变的变量，var 声明为可变的变量

### (5) scala运算符本质 ###

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

1.  用对象的方法时，点.可以省略
2.  如果函数参数只有一个，或者没有参数，()可以省略

val sum:Int = 3.+(5)
    println(123 toString)

### (5) 递增序列 ###

1 to 5  // (1,2,3,4,5) 
    1.to(5)  // (1,2,3,4,5)
    1 until 5  // (1,2,3,4)
    1 to 5 by 2  // (1,3)
    0.5f to 4.9f by 0.3f // 浮点型的递增序列

### (6) 输入输出语句 ###

import scala.io.StdIn._  //使用输入输出语句必须进行导包，下划线_表示所有包
    var i = readInt()  // 输入一个整数 
    var j = readFloat()  // 输入一个浮点数
    var g = readBoolean()  // 输入一个布尔变量
    var str = readLine()  //输入一行
    
    print(i)  // 输出i的值
    println("hello")  // 输出并换行
    println("hello"+","+"world")  // 输出并换行
    val i = 36
    val f = 56.5
    printf("My name is %s. I am %d years old and %.1f Kg.\n", "Jack", i, f)

### (7) 写入文件/读取文件 ###

*  **写入文件**

import java.io.PrintWriter
    val out = new PrintWriter("out.txt")
    for (i <- 1 to 5) out.println(i)
    out.close()

*  **读取文件**

import java.io.Source
    val inputFile = Source.fromfile("out.txt")
    val lines = inputFile.getLines
    for (line <- lines) println(line)

### (8) 异常处理 ###

*  **读取文件**

import java.io.FileReader
    import java.io.FileNotFoundException
    import java.io.IOException
    try { 
    	val f = new FileReader("input.txt")
    } catch { 
    	case ex : FileNotFoundException =>
    		// 文件不存在时的操作
    	case ex : IOException =>
    		//发生I/O错误时的操作
    } finally { 
    	file.close()
    }

## 三、控制结构 ##

### (1) if 条件 ###

val x = 6
    if(x>0){ 
    	println("aaa")
    	"aaa"
    } else { 
    	println("bbb")
    	"bbb"
    }

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

val res:Any = if (age<18) "boy" else "man"

### (2) while 循环 ###

val i = 6
    while(i>0){ 
    	i -= 1
    	println("i is %d\n", i)
    }
    
    val j = 0
    do{ 
    	j += 1
    	println(j)
    }while(j<5)

### (3) for循环 ###

*  **闭区间的循环**

//打印5次，闭区间
    for(i <- 1 to 5) println(i)
    for(i <- 1.to(5) ) println(i)

*  **前闭后开区间的循环**

//打印4次，前闭后开区间
    for(i <- 1 until 5) println(i)

*  **步长为2的循环**

for(i <- 1 to 5 by 2) println(i)

*  **带有守卫条件的循环**

for(i <- 1 to 5 if i%2==0) println(i)

*  **多条件循环**

for(i <- 1 to 5; j <- 1 to 3) println(i*j)

*  **for推导式**

val r = for(i <- 1 to 5 if i%2==0) yield { println(i); i}

*  **倒序循环**

for(i <- 1 to 5 reverse) println(i)

*  **退出循环，类似于java中的break**

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("正常结束循环")
    }

## 四、数据结构 ##

### (1) 列表List ###

List是不可变的集合

*  **声明一个列表**

var strList = List("BigData", "Hadoop", "Spark")

*  **获取一个列表的头部**

strList.head() //返回列表的头部 "BigData"

*  **获取一个列表的尾部**

strList.tail() //返回除列表的头部元素剩下的列表 ("Hadoop", "Spark")

*  **列表增加一个元素**

val otherList = "Apache"::strList // ("Apache", "BigData", "Hadoop", "Spark")

### (2) 集合Set ###

Set是元素不可重复的集合，集合包括可变集合不可变集，分布位于scala.collection.mutable包和scala.collection.immutable包，缺省的情况下创建的是不可变集

*  **声明一个集合**

var strSet = Set("BigData", "Hadoop", "Spark")
    strSet += "scala"

*  **声明一个可变集合**

import scala.collection.mutable.Set
    val myMutableSet = Set("BigData", "Hadoop", "Spark")
    myMutableSet += "scala"

### (3) 映射Map ###

*  **声明一个映射**

val myMap = Map("B"->"BigData", "H"->"Hadoop", "S"->"Spark")
    println(myMap("B"))
    
    val tmp = if(myMap.contains("B")) myMap("B") else 0
    println(tmp)

*  **一个映射增加元素或者更新元素**

import scala.collection.mutable.Map
    val myMap = Map("B"->"BigData", "H"->"Hadoop")
    println(myMap("B"))
    myMap("B") = "BigTable" // 更新元素
    myMap("S") = "Spark" // 增加元素
    
    myMap += ("A"->"Apache") // 增加元素

*  **遍历一个映射**

for ((k,v) <- myMap) println("code is : %s and name is : %s\n", k, v)

*  **遍历一个映射的键**

for (k <- myMap.keys) println(k)

*  **遍历一个映射的值**

for (k <- myMap.values) println(v)

### (4) 迭代器Iterator ###

*  **声明一个迭代器**

val iter = Iterator("BigData", "Hadoop", "Spark")
    while(iter.hasNext){ 
    	println(iter.next())
    }
    
    val iter = Iterator("BigData", "Hadoop", "Spark")
    for(elem <- iter){ 
    	println(elem)
    }

*  **迭代器的grouped方法和sliding方法**

val xs = List(1,2,3,4,5)
    val iter = xs grouped 3
    iter.next() // List(1,2,3)
    iter.next() // List(4,5)
    
    val iter2 = xs sliding 3
    iter2.next() // List(1,2,3)
    iter2.next() // List(2,3,4)
    iter2.next() // List(3,4,5)

### (5) 数组Array ###

*  **声明一个数组Array**

val intValueArr = new Array[Int](3)
    intValueArr(0) = 12
    intValueArr(1) = 42
    intValueArr(2) = 62
    
    val myStrArr = new Array[String](3)
    myStrArr(0) = "BigData"
    myStrArr(1) = "Hadoop"
    myStrArr(2) = "Spark"
    for(i<- 0 to 2) println(myStrArr(i))
    
    val intValueArr = new Array(11,33,44)
    val myStrArr = new Array("BigData","Hadoop","Spark")

*  **定义一个二维和三维数组Array**

val myMatrix = Array.ofDim[Int](3,4)
    println(myMatrix(0)(1))  // 返回第一行第二列数据
    val myCube = Array.ofDim[String](3,2,4)

### (6) 元组Tuple ###

*  **声明一个数组Tuple**

val myTuple = ("Hadoop",111, 4.5)
    println(myTuple._1)
    println(myTuple._2)

## 五、面向对象编程基础 ##

### (1) 类的定义和调用 ###

class Counter{ 
    	private var value = 0
    	def increment() : Unit = { value += 1}   //Unit 表示无返回值 等价于void
    	def current() : Int = { value}  //Int 表示返回值类型为Int
    	/* 如果大括号中只有一行语句，那么可以省略 def Increment() : Unit = value += 1 */
    	/* 如果大括号中只有一行语句，那么也可以省略 def Increment() : {value += 1} */
    }
    // 创建对象
    val myCounter = new Counter // 也可以val myCounter = new Counter()
    myCounter.increment() 
    print(myCounter.increment) // 如果没有参数，也可以写成myCounter.increment

*  **定义带有参数的函数**

class Counter{ 
    	private var value = 0
    	def increment(step: Int) : Unit = { value += step}   //Unit 表示无返回值 等价于void
    	def current() : Int = { value}  //Int 表示返回值类型为Int
    }

### (2) 类的setter()和getter()方法 ###

class Counter{ 
    	private var privateValue = 0
    	def value = privateValue    // 等价于getter()
    	def value_=(newValue : Int) { 
    		privateValue = newValue 
    	}  // 等价于setter()
    	
    }
    // 创建对象
    val myCounter = new Counter // 也可以val myCounter = new Counter()
    print(myCounter.value) // 输出0
    myCounter.value = 3
    print(myCounter.value) // 输出3

### (3) 类构造器 ###

class Counter{ 
    	private var value = 0
    	private var name = ""
    	private var mode = 1
    	def this(name : String){ 
    		this()
    		this.name = name
    	}
    	def this(name : String, mode : Int){ 
    		this(name)
    		this.mode = mode
    	}
    }
    // 主构造器的另一种写法
    class Counter(val name: String, val mode: Int){ 
    	private var value = 0
    	def info(): Unit{ 
    		printf("name is %s, and mode is %d", name, mode)
    	}
    }

### (4) 单例对象 ###

object Person{ 
    	private var lastId = 0
    	def newPersonId() = { 
    		lastId += 1
    		lastId
    	}
    }
    
    printf("The first person id is %d.\n", Person.newPersonId)
    printf("The second person id is %d.\n", Person.newPersonId)

### (5) 伴生对象 ###

*  **在java中，我们经常需要使用到同时包含实例方法和静态方法的类，在scala中可以通过伴生对象来实现**
 *  **当单例对象与某个类具有相同的名称时，它被称为这个类的“伴生对象”**
 *  **类和它的伴生对象必须存在于同一个文件中，而且可以相互访问私有成员（字段和方法**

class Person{ 
    	private val id = Person.newPersonId()
    	private var name = ""
    	def this(name: String){ 
    		this()
    		this.name = name
    	}
    	def info() {  printf("This id of %s is %d.\n", name, id) }
    }
    
    object Person{ 
    	private var lastId = 0
    	def newPersonId() = { 
    		lastId += 1
    		lastId
    	}
    
    	def main(args: Array[String]){ 
    		val person1 = new Person("Ziyu")
    		val person2 = new Person("Minxing")
    		person1.info()
    		person1.info()
    	}
    }

### (6) 对象的apply方法和update方法 ###

*  **apply()方法**  
    用括号传递给变量（对象）一个或者多个参数时，Scala会把它转换成对apply方法的调用

class TestApplyClassAndObject{ 
    	
    }
    class ApplyTest{ 
    	def apply() = println("apply method in class is called!")
    	def greetingOfClass: Unit = { 
    		println("Greeting method in class is called.")
    	}
    }
    object ApplyTest{ 
    	def apply() = { 
    		println("apply method in object is called!")
    		new ApplyTest()
    	}
    }
    object TestApplyClassAndObject{ 
    	def main(args: Array[String]){ 
    		val a = ApplyTest() //这里会调用伴生对象中的apply方法
    		a.greetingOfClass
    		a() //这里会调用伴生类中的apply方法
    	}
    }
    // apply method in object is called!
    // Greeting method in class is called.
    // apply method in class is called!

*  **update()方法**  
    当对带括号并包括一到若干参数的对象进行赋值时，编译器将调用对象的update方法，在调用时，是把括号里的参数和等号右边的对象一起作为update方法的输入参数来执行调用

val myStrArr = new Array[String](3)
    myStrArr(0) = "BigData" // 调用了伴生类Array中的update方法，执行myStrArr.update(0, "BigData")
    myStrArr(1) = "Hadoop" // 调用了伴生类Array中的update方法，执行myStrArr.update(0, "Hadoop")
    myStrArr(2) = "Spark" // 调用了伴生类Array中的update方法，执行myStrArr.update(0, "Spark")

### (7) 类的继承 ###

#### scala与java的不同 ####

*  **1. 在子类中重写超类的抽象方法时不需要使用override关键字**
 *  **2. 重写一个类抽象方法必须使用override修饰符**
 *  **3. 只有主构造器可以调用超类的主构造器**
 *  **4. 可以重写超类中的字段**

#### 抽象类 ####

//是抽象类，不能直接被实例化
    abstract class Car{  
    	val carBrand: String	//字段没有初始化值，就是一个抽象字段
    	def info()	//抽象方法，不需要使用abstract关键字
    	def greeting(){ println("welcome to my car")}

#### 实现类 ####

//实现类
    class BMWCar extends Car{  
    	override val carBrand = "BMW" //=重写超类字段，需要使用override关键字
    	def info(){ println("this is a %s car.", carBrand)}  //重写超类的抽象方法时，可以不用使用override关键字，如果加上编译不会报错
    	override def greeting(){ println("welcome to my %s car", carBrand)} //重写超类的非抽象方法时，必须使用override关键字

#### 一个实例 ####

abstract class Car{  
    	val carBrand: String	//字段没有初始化值，就是一个抽象字段
    	def info()	//抽象方法，不需要使用abstract关键字
    	def greeting(){ println("welcome to my car")}
    class BMWCar extends Car{  
    	override val carBrand = "BMW" //=重写超类字段，需要使用override关键字
    	def info(){ println("this is a %s car.", carBrand)}  //重写超类的抽象方法时，可以不用使用override关键字，如果加上编译不会报错
    	override def greeting(){ println("welcome to my %s car", carBrand)} //重写超类的非抽象方法时，必须使用override关键字
    class BYDCar extends Car{  
    	override val carBrand = "BYD" //=重写超类字段，需要使用override关键字
    	def info(){ println("this is a %s car.", carBrand)}  //重写超类的抽象方法时，可以不用使用override关键字，如果加上编译不会报错
    	override def greeting(){ println("welcome to my %s car", carBrand)} //重写超类的非抽象方法时，必须使用override关键字
    object MyCar{ 
    	def main(args: Array[String]){ 
    		val mycar1 = new BMWCar()
    		val mycar2 = new BYDCar()
    		mycar1.info()
    		mycar1.greeting()
    		mycar2.info()
    		mycar2.greeting()
    	}
    }

### (8) 类的特质 ###

*  **1. java中提供了接口，允许一个类实现任意数量的接口**
 *  **2. 在scala中没有接口的概念，而是提供了“特质trait”，它不仅实现了接口的功能，还具备了很多其他的特性**
 *  **3. scala的特质，是代码重用的基本单元，可以同时拥有抽象方法和具体方法**
 *  **4. scala中，一个类只能继承自一个超类，却可以实现多个特质，从而重用特质中的方法和字段，实现了多重继承**

#### 特质 ####

trait CarId{ 
    	var id: Int
    	def currentId(): Int  //定义了一个抽象方法
    }

#### 类中混入特质 ####

特质定义好以后，可以使用extends或者with关键字把特质进行混入

class BMWCarId extends CarId{ 
    	override var id = 10000  //汽车编号从10000开始
    	def currentId(): Int = { id += 1; id}  //返回汽车编号
    }

#### 特质可以包含具体实现 ####

trait CarGreeting{ 
    	def greeting(msg: String): {  println(msg) }
    }

#### 类中混入多个特质 ####

特质定义好以后，可以使用extends或者with关键字把特质进行混入

// 使用extends混入第一个特征，后面可以反复使用with混入更多的特征
    class BMWCarId extends CarId with CarGreeting{ 
    	override var id = 10000  //汽车编号从10000开始
    	def currentId(): Int = { id += 1; id}  //返回汽车编号
    }

### (9) 模式匹配 ###

#### 简单匹配 ####

// 类似于java中的switch语句
    val colorNum = 1
    val colorStr = colorNum match{ 
    	case 1 => "red"
    	case 2 => "green"
    	case 3 => "yellow"
    	case _ => "Not Allowed"
    }
    println(colorStr)
    
    // 获取不匹配变量的值
    val colorNum = 4
    val colorStr = colorNum match{ 
    	case 1 => "red"
    	case 2 => "green"
    	case 3 => "yellow"
    	case unexpected => unexpected + " is not Allowed"
    }
    println(colorStr)

#### 类型匹配 ####

for(elem <- List(9, 12.3, "spark", "hadoop", 'H'))
    	val str = elem match{ 
    		case i: Int => i + " is an int value" 
    		case d: Double => d + " is an double value" 
    		case "spark" => "spark is found." 
    		case s: String => s + " is an string value" 
    		case _ => "This is an unexpected value"
    	}
    	println(colorStr)
    }

#### 守卫语句 ####

for(elem <- List(1, 2, 3, 4))
    	elem match{ 
    		case _ if (elem % 2 == 0 ) => println(elem + "is even")
    			case _ => println(elem + "is odd")
    	}
    }

#### for表达式中的模式 ####

val myMap = Map("B"->"BigData", "H"->"Hadoop", "S"->"Spark")
    for ((k,v) <- myMap) println("code is : %s and name is : %s\n", k, v)

#### case类匹配 ####

case class Car(brand: String, price: Int)
    val myBYDCar = new Car("BYD", 89000)
    val myBMWCar = new Car("BMW", 120000)
    val myBenzCar = new Car("Benz", 150000)
    for (car <- List(myBYDCar, myBMWCar, myBenzCar)){ 
    	car match{ 
    		case Car("BYD", 89000) => println("Hello, BYD")
    		case Car("BMW", 120000) => println("Hello, BMW")
    		case Car(brand, price) => println(brand + price)
    	}
    }

## 六、函数式编程基础 ##

### (1) 函数的定义和调用 ###

def main(args: Array[String]): Unit = { 
    	def sum(a: Int, b: Int): Int = { 
    	return a.+(b)
    	}
    	printf(sum(1,2))
    }

### (2) 函数的定义 ###

def sum(a: Int, b: Int): Int = { 
    	return a.+(b)
    }
    // def：定义一个函数
    // sum：函数的名称
    // a,b：函数的形参名称
    // Int：形参和返回值的类型
    // { return a.+(b) }：函数体

*  **无参，无返回值**

def f1(): Unit = { 
    	function body...
    }

*  **无参，有返回值**

def f1(): Int = { 
    	function body...
    	return 123
    }

*  **有参，无返回值**

def f1(x: Int): Unit = { 
    	function body...
    }

*  **有参，有返回值**

def f1(x: Int): Int = { 
    	function body...
    	return x + 1
    }

*  **多参，无返回值**

def f1(x: Int, y: Int): Unit = { 
    	function body...
    }

*  **可变参数，无返回值，可变参数一定要放在参数列表的最后**

def f1(x: Int*): Unit = { 
    	function body...
    }

*  **参数默认值，带有默认值的参数一定要放在参数列表的最后**

def f1(x: Int, y: Int = 12): Unit = { 
    	function body...
    }

*  **带名参数**

def f1( y: Int = 12, x: Int): Unit = { 
    	function body...
    }
    f1(x = 22)

### (1) 函数的类型和值 ###

def counter(value: Int): Int = {  value += 1 }
    //上面这个函数的类型为
    (Int) => Int  // 或者 Int => Int
    //上面这个函数的值为
    (value) => { value += 1} // 只有一条语句时，大括号可以省略
    //那么可以定义一个函数
    val counter: Int => Int = {  (value) => value += 1 }

### (0) 函数和方法的区别 ###

为完成某一功能的程序语句的集合，称为函数，而类中的函数称之方法，方法也可以理解为特殊的函数。

1.  Scala语言可以在任何的语法结构中声明任何的语法
2.  函数没有重载和重写的概念；方法可以进行重载和重写
3.  Scala中函数可以嵌套定义

object TestFunction { 
    
        // (2)方法可以进行重载和重写，程序可以执行
        def main(): Unit = { 
        }
    
        def main(args: Array[String]): Unit = { 
            // （1）Scala语言可以在任何的语法结构中声明任何的语法
            import java.util.Date
            new Date()
    
            // (2)函数没有重载和重写的概念，程序报错
            def test(): Unit ={ 
                println("无参，无返回值")
            }
            test()
    		// (2)函数没有重载和重写的概念，程序报错
            def test(name:String):Unit={ 
                println()
            }
    
            //（3）Scala中函数可以嵌套定义
            def test2(): Unit ={ 
    
                def test3(name:String):Unit={ 
                    println("函数可以嵌套定义")
                }
            }
        }
    }

### (2) 函数的至简原则 ###

1.  return可以省略，Scala会使用函数体的最后一行代码作为返回值
2.  如果函数体只有一行代码，可以省略花括号
3.  返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
4.  如果有return，则不能省略返回值类型，必须指定
5.  如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
6.  Scala如果期望是无返回值类型，可以省略等号
7.  如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
8.  如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
9.  如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

object Hello { 
      def main(args: Array[String]): Unit = { 
        //(1) return可以省略，Scala会使用函数体的最后一行代码作为返回值
        def f1(s: String): String = { 
          return "hello," + s
        }
    
        //(2) 如果函数体只有一行代码，可以省略花括号
        def f2(s: String): String = "hello," + s
    
        //(3) 返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
        def f3(s: String) = "hello," + s
    
        //(4) 如果有return，则不能省略返回值类型，必须指定
        def f4(s: String): String = return "hello," + s
    
        //(5) 如果函数明确声明Unit，那么即使函数体中使用return关键字也不起作用
        def f5(s: String): Unit = return "hello," + s
    
        //(6) Scala如果期望是无返回值类型，可以省略等号
        def f6(s: String) { 
          return "hello," + s
        }
    
        //(7) 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
        def f7() { 
          return "hello"
        }
    
        println(f7)
      }
    
      //(8) 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
      def f8 { 
        return "hello"
      }
    
      println(f8)
    
      //(9) 如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
      //(x: String): 函数输入参数
      //{ println(x) }: 函数体
      // String => Unit: 函数签名，可以看做变量类型
      def f9: String => Unit = (x: String) => { 
        println(x)
      }
    
      def f10(f: String => Unit): Unit = { 
        f("xuzheng")
      }
      f10(f9)
      f10((x: String) => {  println(x) })
    }

### (2) 匿名函数 ###

// 匿名函数
    (num: Int) => num * 2
    // 匿名函数实例
    val muNumFunc: Int => Int = (num: Int) => num * 2
    println(muNumFunc(3))

### (3) 闭包 ###

// 闭包反映一个从开放到封闭的过程
    var more = 1
    val addMore = (x: Int) => x + more
    addMore(10)

### (4) 集合操作 ###

#### 遍历操作 ####

*  **列表遍历**

// 可以使用for循环进行遍历
    val list = List(1, 2, 3, 4, 5)
    for(elem <- list) println(elem)
    // 也可以使用foreach进行遍历
    val list = List(1, 2, 3, 4, 5)
    list.foreach(elem => println(elem))

*  **映射遍历**

// 可以使用for循环进行遍历
    val myMap = Map("B"->"BigData", "H"->"Hadoop", "S"->"Spark")
    for ((k,v) <- myMap) println("code is : %s and name is : %s\n", k, v)
    // 也可以使用foreach进行遍历
    val myMap = Map("B"->"BigData", "H"->"Hadoop", "S"->"Spark")
    myMap foreach { case(k,v) => println(k + ":" + v)}
    // 也可以使用foreach进行遍历
    val myMap = Map("B"->"BigData", "H"->"Hadoop", "S"->"Spark")
    myMap foreach { kv => println(kv._1 + ":" + kv._2)}

#### map操作 ####

val books = List("Hadoop", "Hive", "HDFS")
    books.map(s => s.toUpperCase)

#### flatMap操作 ####

flatMap 是map的一种扩展，在flatMap中，我们会传入一个函数，该函数对每一个输入都会返回一个集合，然后flatMap把生成的多个集合，拍扁成一个集合

val books = List("Hadoop", "Hive", "HDFS")
    books flatMap (s => s.toList)

#### filter操作 ####

遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

val myMap = Map("B"->"BigData", "H"->"Hadoop", "S"->"Spark")
    val un = myMap filter { kv => kv._2 contains "Hadoop"}

#### reduce归约 ####

直接使用reduce，默认是左归约

val list = List(1,2,3,4,5)
    list.reduceLeft(_ + _)   // 结果为 1+2+3+4+5=15
    list.reduceRight(_ + _)  // 结果为 5+4+3+2+1=15

#### fold操作 ####

val list = List(1,2,3,4,5)
    list.fold(10)(_ * _)   // 结果为 10*1*2*3*4*5=1200

## 七、Spark-shell编程 ##

### (1) 启动spark编程环境 ###

*  **本地单线程运行**

spark-shell --master local

*  **本地多线程运行**

spark-shell --master local[4]

*  **本地所有线程运行**

spark-shell --master local[*]

*  **连接到指定的spark master运行**

spark-shell --master spark://host:port

*  **以客户端模式连接到YARN集群**

spark-shell --master yarn-client

*  **以集群模式连接到YARN集群**

spark-shell --master yarn-cluster

### (2) 退出spark编程环境 ###

:quit

### (3) RDD创建 ###

*  **从本地文件系统中加载数据**

val linesRDD = sc.textFile("file:///usr/local/spark/mycode/rdd/word.txt")

*  **从分布式文件系统中加载数据**

// 以下三个语句等价
    val linesRDD = sc.textFile("hdfs://localhost:9000/user/hadoop/word.txt")
    val linesRDD = sc.textFile("/user/hadoop/word.txt")
    val linesRDD = sc.textFile("word.txt")

*  **通过数组创建RDD**

val array = Array(1,2,3,4,5)
    val arrayRDD = sc.parallelize(array)

*  **通过列表创建RDD**

val list = List(1,2,3,4,5)
    val listRDD = sc.parallelize(list)

### (4) RDD操作 ###

#### 转换操作 ####

*  **过滤操作**

filter(func) // 筛选出满足func的元素，并返回一个新的数据集

*  **映射操作**

map(func) // 将每一个元素传递到函数func中，并将结果返回为一个新的数据集

*  **多映射操作**

flatMap(func) // 与map()类似，但每个输入元素都可以映射到0或多个输出结果

*  **分组操作**

groupByKey() // 应用于(K,V)键值对的数据集时，返回一个新的(K,Iterable)形式的数据集

*  **聚合操作**

reduceByKey(func) // 应用于(K,V)键值对的数据集时，返回一个新的(K,V)形式的数据集，其中的每个值是将每个key传递到函数func中进行聚合

#### 行动操作 ####

count() // 返回数据集中的元素个数
    collect() // 以数组的形式返回数据集中的所有元素
    first() // 返回数据集中的第一个元素
    take(n) // 以数据的形式返回数据集中的前n个元素
    reduce(func) // 通过函数func(输入两个参数并返回一个值)聚合数据集中的元素
    foreach(func) // 将数据集中的每个元素传递到函数func中运行

#### RDD实例 ####

*  **统计文本中包含Spark单词的行数**

val linesRDD = sc.textFile("file:///usr/local/spark/mycode/rdd/word.txt")
    lines.filter(line => line.contains("Spark")).count()

*  **统计文本中单行所包含单词数据最大值**

val linesRDD = sc.textFile("file:///usr/local/spark/mycode/rdd/word.txt")
    lines.map(line=>line.split(" ").size).reduce((a,b) => if (a>b) a else b)

--------------------

[Link 1]: https://blog.csdn.net/qq_32599479/article/details/99400732
[20200629172955655.png]: /images/20210920/1d4c13fb53a04de58c384be78f9bf4fe.png
[20200629173006340.png]: /images/20210920/dfab13bfbcc448af81c6fdcdc6712c61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70]: /images/20210920/3e431326e1874c119b4e30c89d0d20cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 1]: /images/20210920/5ec187db91184a239ed31d506ebca802.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 2]: /images/20210920/650f8a9cabf541538b62a7d11b6ca48e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 3]: /images/20210920/74d34dede1f14ae9afeaa3c1ca947feb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 4]: /images/20210920/ce2842bcc2a94299a9b75f1144dfe03a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 5]: /images/20210920/1adb71c72f29453a8b70f0af2c9d9a6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 6]: /images/20210920/c4eaffd654f64971a7dd2511314354e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 7]: /images/20210920/ee937f658c9f4ae7bf3f4d2b5a1aafe9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTk5NDc5_size_16_color_FFFFFF_t_70 8]: /images/20210920/7bb8e4aa87864c6892f7a08667bd7b73.png