Hadoop+Spark大数据技术(微课版)曾国荪、曹洁版思维导图第五章 Scala基础与编程(未完待续。。。)

5.1 Scala概述

### 5.1.2 Windows环境下安装Scala
### 5.1.1 Scala特性

* 1.面向对象

* 2.函数式编程

* 3.扩展性

* 4.并发性

* 5.可以和Java混编
## 5.2 Scala基础语法

*

  ### 1.声明常量和变量

  * (1)声明常量

    * val 常量名:数据类型=初始值

    * val a:int =1或val a = 1

  * (2)声明变量

    * var 变量名:数据类型=初始值

    * 注:

      * 支持同时声明多个变量如var a,b = 1

      * 可以重复使用同一变量名定义变量,解释器以最新定义为准

      * 声明变量需要初始化,否则报错

      * (优先使用常量,除非确实需要修改)

*

  ### 2.输出值的方式

  *

    #### (1)直接调用变量名

  *

    #### (2)借助输出函数

    * 差值字符串

      * 字符串前加"s"或"f"

        * 加s:不支持格式化

          * ${varName}

        * 加f:支持在$变量后指定格式化参数

          * $varNum%.2f (保留小数点两位)

      * ${varName}插入变量名

    * 1.print()函数结合加号对多个内容进行连接并输出

    * 2.println()函数输出结束后自动换行

    * 3.printf()函数格式化输出

*

  ### 3.数据类型 (首字母大写)

* ![](https://file.jishuzhan.net/article/1781597249688571906/d357296476786b7997d9f824dba856e1.webp)
  * 9种基本数据类型:String位于java.lang包,其余位于Scala包

  * Any是所有其他类型的超类(父类)

  * Nothing是任何其他类型的子类

  * Unit无返回值

  *

    #### String对象

    * 字符串对象用双引号

    * 常用方法

      * (1)String concat(String str)方法

        * 将指定字符串连接到此字符串的结尾

        * "ABC",concat("DEF")

      * (2)Boolean endsWith(String sufix)方法

        * 测试字符串是否以指定的后缀结束

        * "ABC". endsWith("C")

      * (3)Int length()方法

        * 返回字符串的长度

        * "ScalaPythonJava".length()

          * res: Int = 15

      * (4)Boolean matches(String regex)方法

        * 判断字符串是否匹配给定的正则表达式

        * "ScalaPythonJava".matches(".\*Python.\*")

          * res: Boolean = true

      * (5)String replace(char oldChar, char newChar)方法

        * 返回一个新的字符串,newChar 字符串替换原字符串中出现的oldChar字符串得到

        * "I love Python".replace("Python","Scala")

          * res: String = I love Scala

      * (6)String replaceAll(String regex, String replacement)方法

        * 使用给定的replacement字符串替换字符串中所有与给定的正则表达式相匹配的子字符串

        * "ab123sdab4543das756as876asd".replaceAll("\\\\d+","#num#")

        * res: String =abfnumtsdabfnumidastnumfasfnumfasd

      * (7)String replaceFirst(String regex,String replacement)方法

        * 使用给定的replacement字符串替换字符串中与给定的正则表达式相匹配的第一个子字符串

      * (8)String\[\] split(String regex)方法

        * 按正则表达式匹配的子字符串拆分字符串。

        * String\[\]表示split(String regex)执行结束后的返回值是字符串数组

        * "I love Python".split("")

          * res: Array\[String\]= Array(I, love, Python)

      * (9)Char\[\] toCharArray()方法

        * 将字符串转换为一个字符数组

        * "Scala".toCharArray()

          * res: Array\[Char\] = Array(S, c, a, l, a)

      * (10)String toLowerCase()方法

        * 将字符串中的所有字符都转换为小写

      * (11)String trim()方法

        * 删除字符串的首尾空白符

      * (12)String take(num)方法

        * 获取字符串前num个字符

        * //获取"hello"前两个字符 "hello".take(2)

          * res: String = he

      * (13)reverse属性

        * 反转字符串

*

  ### 4.运算符

  * 算术运算符

    * +、-、\*、/、%(取余)

  * 关系运算符(比较运算符)

    * ==,!=,>,<,≥,≤

  * 逻辑运算符

    * \&\&与(都满足),‖或(一个满足), !非

  * 赋值运算符

    * =,+=,-=,\*=,/=,%=
## 5.3 Scala控制结构

*

  ### 1.条件表达式

  * val s = if(x >0)1 else 0

*

  ### 2.if...else选择结构

  * 单分支,双分支,多分支

*

  ### 3.编写和运行Scala脚本

  * 一起执行的Scala语句序列放在同一文件,称为脚本

  * 执行scala test.scala

*

  ### 4.循环结构

  * while,do while,for

  * for没有直接对应结构

    *

      #### (1)for(x\<-Range)

      * Range 可以是一个数字区间,如

        * i to j表示的区间是\[i,j\]

        * i until j表示的区间是\[i,j)

    *

      #### (2)for 循环可用分号隔开多个区间

      * 可以迭代多个区间的所有可能值

      * for( a \<- 1 to 2;b \<-1 to 2) println( "a:"+a+"b:"+b)

    *

      #### (3)for 循环中使用数组、列表和集合

      * for 循环中使用列表 val list1=List(3,5,2,1,7)//创建列表 listl: List\[Int\] = List(3,5,2,1,7) for(x \<- list1) print(""+x) 3 5 2 1 7

    *

      #### (4)for 循环中使用过滤器

      * for(x \<- list1 if x%2==1) print(""+x) 3 5 1 7
## 5.4 数组

*

  ### 1.定长数组 使用()访问数组元素而不是\[\]

  * var z:Array\[String\] = new Array\[String\](3)

  * var z = new Array\[String\](3)

*

  ### 2.变长数组

  *

    #### 1、ArrayBuffer创建变长数组

    * import scala.collection.mutable.ArrayBuffer

    * val arr1 = ArrayBuffer\[Int\]()//定义一个Int类型、长度为0的变长数组

  *

    #### 2.追加、修改、删除变长数组的元素

    * val bigData = ArrayBuffer("Hadoop","Storm")//创建变长数组

    *

      ##### (1)"+="追加一个元素

      * bigData += "Spark"

    *

      ##### (2)"++="追加一个数组的元素

      * bigData ++= Array("Hbase","Graphx")

    *

      ##### (3)"-="删除元素

      * bigData -= "Graphx"

    *

      ##### (4)"--="删除在指定数组中出现的元素

      * bigData --= Array("Spark","Graphx")

    *

      ##### (5)remove()方法删除指定位置的元素

      * 调用变长数组对象的removeo方法从指定索引开始移除指定数量的元素。

      * bigData.remove(1,2)//从索引1处开始移除2个元素

    *

      ##### (6)insert()方法在指定位置前插入元素

      * bigData.insert(0,"Spark")//在索引 0前插入元素"Spark"

      * 定长数组和变长数组之间转换,调用toBuffer()和toArray()方法。

*

  #### 3.遍历数组

  *

    ##### 1.for 循环和until遍历数组

    * for(i \<- 0 until a.length)

    * △注意:变量i的取值从0到a.length-1。

  *

    ##### 2.直接遍历数组元组

    * for(e \<- b)

    * △注意:变量e先被设为b(0),然后被设为b(1),以此类推。

*

  #### 4.数组转换

  * 按某种方式将一个数组转换为一个全新的数组,而原数组不变。

  * 创建一个新数组 val a=Array(1,2,3,4)

    *

      ##### 1.for(...) yield

      * val result = for(elem \<- a) yield 2 \* elem

        * result: Array\[Int\] = Array(2, 4, 6, 8)

      * result中的值由yield之后的表达式2\*elem产生,每次迭代为result产生一个值。

    *

      ##### 2.数组对象的map()方法

      * val result2 = a.map{3 \* _}

        * result2: ArraylInt\] = Array(3,6, 9,12)

    *

      ##### 3.数组对象的filter()和map()方法

      * val result3 = a.filter(_ % 2 == 0).map {2 \* _}

        * result3: Array\[Int\] = Array(4, 8)

    * 可以添加语句处理那些满足特定条件的元素。

*

  #### 5.数组对象的操作方法

  *

    ##### 1.map()方法映射数组 var arr = Array(1,2,3,4)

    * 通过一个函数改变数组中的每个元素

    * arr.map(x =\> x\* 5)

      * res: Array\[Int\] = Array(5, 10, 15, 20)

    * △注意:x=\>x\*5这种表达式称为Lambda表达式,用来创建临时使用的匿名函数。

      * Lambda 表达式的语法格式如下: (参数1,参数2,...)=\>表达式

  *

    ##### 2.foreach()方法遍历数组中的元素

    * 和map()方法类似,但是foreach()没有返回值。

  *

    ##### 3.min、max、sum分别输出数组的最小元素、最大元素、数组元素和

  *

    ##### 4.head、tail分别查看数组的第一个元素、除第一个元素外的其他元素

  *

    ##### 5.sorted、sortBy()、sortWith()排序

    *

      ###### (1)sorted

      * sorted默认为升序排列,降序排列则需要反转。

      * arr.sorted//升序

      * arr.sorted.reverse//降序

    *

      ###### (2)sortBy()

      * 需要参数,表明进行排序的数组元素的形式。

      * arr.sortBy(x=\>x)//升序

      * arr,sortBy(x =\>-x)//降序

    *

      ###### (3)sortWith() var arr = Array("a","d","F","B","e")

      * sortWith((String,String)=\>Boolean) 需要匿名函数来说明排序规则,要有两个参数进行比较。

      * arr.sortWith((x:String, y:String) =\> x\<y)

      * arr.sortWith((x,y) =\> x\<y)

  *

    ##### 6.filter()方法进行过滤

    * filter()方法移除传入函数的返回值为 false的数组元素。

    * 过滤掉数组 arr中奇数,得到只含偶数的数组。arr.filter(x=\>x%2==0)

  *

    ##### 7.flatten扁平化操作 val arr = Array(Array(1,2),Array(3,4))//二维数组

    * 把嵌套的结构展开,二维数组展开成一维数组。

    * arr.flatten

      * res: Array(Int) = Array(1, 2, 3,4)

  *

    ##### 8.flatMap 操作

    * 结合map()和 fatten功能,相当于先进行map()操作再进行flatten操作,接收一个可以处理嵌套数组的函数,把返回结果连接起来。

    * arr.flatMap(x=\> x.map(_\*10))

      * res: Array\[Int\] = Array(10, 20, 30,40)

  *

    ##### 9.显示数组内容

    * mkString()方法显示数组的内容,允许指定元素之间的分隔符,该方法的另一个重载版本可以指定元素的前缀和后缀。

    * to\*方法(\*为数据类型名)

      * 数据类型转换
## 5.5 列表

*

  ### 1.不可变列表

  * 与数组的比较

    * (List声明)类似于数组,所有元素都具有相同的数据类型。

    * 与数组不同的是,不可变列表的元素是不可变的,不可变列表的元素值一旦被觉了就不能改变。

  *

    #### 1.创建不可变列表

    * val course: List\[String\] = List("Scala", "Python")

      * course: List\[String\] = List(Scala, Python)

    * //创建二维列表 val dim: List\[List\[Int\]\]= List(List(1,0),List(0,1)

      * dim: List\[List\[Int\]\] = List(List(1, 0), List(0, 1))

    * 不可变列表具有递归的结构 (也即链接表结构) 数组不具有。即不变列表

      * 要么是Nil(即空列表)

      * 要么是一个head元素加上一个tail, 而tail又是一个列表

        * val nums:List\[Int\] = List(1,2,3,4)

          * nums: List\[Int\] = List(1, 2, 3, 4)

        * nums.head

          * res: Int = 1

        * nums.tail

          * res: List\[Int\] = List(2, 3,4)

    *

      ##### (1)创建空列表

      * val L = Ni1

      * val L2 = List()

    *

      ##### (2)"::"创建列表

      * "::"根据给定的head 和tail 创建一个新的列表。

      * △注意:"::"右结合,即从末端开始创建列表。

      * val newList=1::List(3, 5)

        * newList: List\[Int\] = List(1, 3, 5)

    *

      ##### (3)":::"连接列表创建新列表

      * val L4 = L3 ::: List("Hadoop","Hbase")

        * L4: List\[String\] = List(Spark, Scala, Python, Hadoop, Hbase)

  *

    #### 2.不可变列表的操作9个

    * head:返回列表的第一个元素。

    * tail:返回一个列表,含除了第一个元素之外的其他元素。

    * init:返回一个列表,含除了最后一个元素之外的其他元素。

    * reverse:用于将列表的元素顺序反转。

    * last:返回列表的最后一个元素。

    * length:返回列表的长度。

    * range:创建数值范围的列表。 List.range(from,until)

      * 创建从from 到until(不包括 until)的所有数值的列表。

      * step值作为第3个参数

        * 将产生从from到uni的间隔为step 的列表元素,step值可正可负。

        * List.range(1,9,2)

          * res: List\[Int\] = List(1, 3, 5, 7)

    * isEmpty:判断列表是否为空,在列表为空时返回true。

    * sorted:排序。

  *

    #### 3.不可变列表对象的常用方法15个

  * val L5= List("Spark","Scala", "Python", "Hadoop","Hbase")

  * L5: List(String)= List(Spark, Scala, Python, Hadoop, Hbase)

  * (1)count(s =\> s.length==num)

    * 统计列表中长度为num的字符串的个数

    * //对L5中长度为5的字符串进行计数 L5.count (s =\>s.length == 5)

      * res0: Int = 3

  * (2)drop(num)

    * 返回去掉列表开头num个元素的列表

    * L5.drop(2)

      * res1: List\[String\] = List (Python, Hadoop, Hbase)

  * (3)dropRight(num)

    * 返回去掉列最后num个元素的列表

    * L5.dropRight(3)

      * res2: List\[String\] = List(Spark, Scala)

  * (4)exists(s =\> s=="\*\*\*")

    * 判断列表中是否有字符串的值为"\*\*\*"

    * L5.exists(s =\> s=="Spark")

      * res3: Boolean = true

  * (5)forall(s =\> s.endsWith("k")

    * 判断列表里的元素是否都以"k"结尾

    * L5.forall(s =\> s.endsWith("k"))

      * res4: Boolean = false

  * (6)foreach(s =\> println(s))

    * 遍历输出列表元素

    * L5.foreach(s =\> print(s+" "))

      * Spark Scala Python Hadoop Hbase

  * (7)map(f)

    * 通过给定的函数f将所有元素重新计算

    * //对L5的元素都拼接$,并返回一个新的列表 scala\> L5.map(s =\> s + "$")

      * List\[String\] = List(Spark$, Scalas$, Python$, Hadoops$, Hbases$)

  * (8)mkString("-")

    * 对列表的元素以"-"拼接并返回

    * L5.mkString("-")

      * res11: String-Spark-Scala-Python-Hadoop-Hbase

  * (9)filterNot(s =\> s.length==5)

    * 返回列表中长度不为5的元素所组成的列表

    * L5.filterNot(s =\> s.length == 5)

      * res12: List\[String\] = List(Python, Hadoop)

  * (10)take(num)

    * 从列表左边取num个元素组成一个新列表

    * L5.take(3)

      * res13: List\[String\]=List(Spark, Scala, Python)

  * (11)takeRight(num)

    * 从列表右边取num个元素组成一个新列表

    * L5.takeRight(3)

      * res14: List(String) = List(Python, Hadoop, Hbase)

  * (12)sortBy(x =\> x),升序排列

    * sortBy(x =\> -x),降序排列

  * (13)sortWith(_\<_),升序排列

    * sortWith(_\>_),降序排列

  * (14)":+"和"+:"

    * ":+"在末端添加元素以得到一个新列表

      * list2.:+(10)

        * res25:List\[Int\] = List(3, 5,2, 1, 7,10)

    * "+:"在首端添加元素以得到一个新列表

      * list2.+:(0)

        * res26: List(Int\] = List(0, 3, 5,2, 1,7)

  * (15)toString()

    * 将列表转换为字符串

    * List(1,2,3).tostring()

      * res27: String = List(1, 2,3)

*

  ### 2.可变列表 ListBufer声明

  * 对于可变列表,既可以修改某个位置的元素值,也可以增加或删除列表元素。

  *

    #### 1.创建可变列表

    * import scala.collection.mutable.ListBuffer

    * val LBl = ListBuffer(1,2,3,4,5,6)

  *

    #### 2.可变列表的常用操作

    * (1)按值删除列表元素
  • 5.6 集合

    • 不可变集合

    • 可变集合

  • 5.7 元组

    • 元组的常用操作

    • 拉链操作

  • 5.8 映射

    • 不可变映射

    • 可变映射

  • 5.9 Scala函数

    • 匿名函数

    • 高阶函数

    • 函数的定义

  • 5.10 Scala模式匹配

  • 5.11 Scala面向对象编程

    • 类与对象

    • 单例对象和伴生对象

  • 5.12 Scala读写文件

    • 读文件

    • 写文件

相关推荐
2401_8576100312 分钟前
Spring Boot框架:电商系统的技术优势
java·spring boot·后端
娅娅梨31 分钟前
C++ 错题本--not found for architecture x86_64 问题
开发语言·c++
汤米粥37 分钟前
小皮PHP连接数据库提示could not find driver
开发语言·php
冰淇淋烤布蕾40 分钟前
EasyExcel使用
java·开发语言·excel
拾荒的小海螺1 小时前
JAVA:探索 EasyExcel 的技术指南
java·开发语言
SafePloy安策1 小时前
ES信息防泄漏:策略与实践
大数据·elasticsearch·开源
学术搬运工1 小时前
【珠海科技学院主办,暨南大学协办 | IEEE出版 | EI检索稳定 】2024年健康大数据与智能医疗国际会议(ICHIH 2024)
大数据·图像处理·人工智能·科技·机器学习·自然语言处理
马剑威(威哥爱编程)1 小时前
哇喔!20种单例模式的实现与变异总结
java·开发语言·单例模式
白-胖-子1 小时前
【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-统计数字
开发语言·c++·算法·蓝桥杯·等考·13级
好睡凯1 小时前
c++写一个死锁并且自己解锁
开发语言·c++·算法