scala学习笔记（1初识）

谁借莪１个温暖的怀抱￠ 2023-03-02 14:49 17阅读 0赞

> 为什么学习Scala？
> 
> 因为Spark是使用Spark编写的，学习Spark有助于更好的学习Scala
> 
> 而Spark是大数据的重要内容，大数据需要使用Spark

# Scala环境配置 #

下载Scala安装包：https://www.scala-lang.org/download

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5OsoYvZc-1596024135950)(…/…/…/…/Pictures/Typora/image-20200721145902016.png)\]

> 需要jdk环境

在idea上使用，需要安装scala插件(百度搜索)

# Scala简介 #

> scala编译时，object在底层会生成两个类
> 
>     object Hello
>     -----------
>     Hello,Hello$
>     //我们在main中编写的代码，是放在Hello$的main中的，scala对此作了包装
>     //编译时，Hello类的main方法调用hello$类的一个静态对象MODULES$，然后该对象再调用Hello$类的main方法

*  Scala源自Java
    
     *  Scala构建在JVM之上
     *  Scala与Java兼容、互通
 *  Scala的优势
    
     *  多范式编程：面向对象编程、函数式编程
     *  表达能力强，代码精简
 *  大数据与Scala
    
     *  Spark采用Scala语言设计
     *  提供的API更加优雅
     *  基于JVM的语言更融入Hadoop生态圈

## Scala概述 ##

*  面向对象特性  
    每个值都是对象  
    对象的数据类型和行为由类（Class）和特征（Trait，类似于interface）描述  
    利用特征实现混入式多重继承
 *  函数式编程  
    每个值都是一个值  
    支持高阶函数、柯里化(currying)、样例类（case class）及模式匹配……
 *  Scala是静态类语言
 *  扩展性：隐式类、字符串插值

## Scala 包 ##

scala有两种方式定义包

1.  与java相同，在文件头定义包名
    
        package com.heihei
        
        class HelloWorld
2.  类似于c\#，用括号将包中的类包起来
    
        package com.heihei{
            class HelloWorld
        }

## Scala import ##

与java不同，Scala中的import语句可以出现在任何地方(不一定是文件顶部)，import的作用范围从import语句处到语句块结束

//如果要引入包中的几个成员，可以使用selector(选取器)
    import java.a.{c,d}
    
    //scala支持重命名成员
    import java.util.{HashMap => JavaHashMap}
    
    //隐藏成员
    import java.util.{HashMap => _,_}//引用util包中成员，但HashMap被隐藏

> scala默认引用java.lang.\_、scala. \_、和Predef. \_

# Scala基础 #

## Scala 数据类型 ##

Scala的数据类型分为AnyVal(值类型)和AnyRef(引用类型)

原始数据类型与java相同

<table> 
 <thead> 
  <tr> 
   <th><strong>数据类型</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Byte</td> 
   <td>8位有符号整数。数值区间-128 ~ 127</td> 
  </tr> 
  <tr> 
   <td>Short</td> 
   <td>16位有符号整数。数值区间-32768 ~ 32767</td> 
  </tr> 
  <tr> 
   <td>Int</td> 
   <td>32位有符号整数。数值区间 -2147483648 ~ 2147483647</td> 
  </tr> 
  <tr> 
   <td>Long</td> 
   <td>64位有符号整数。 -9223372036854775808 ~ 9223372036854775807</td> 
  </tr> 
  <tr> 
   <td>Float</td> 
   <td>32位IEEE 754 单精度浮点数</td> 
  </tr> 
  <tr> 
   <td>Double</td> 
   <td>64位IEEE 754 双精度浮点数</td> 
  </tr> 
  <tr> 
   <td>Char</td> 
   <td>16位无符号Unicode字符。区间值为U+0000 ~ U+FFFF</td> 
  </tr> 
  <tr> 
   <td>Boolean</td> 
   <td>true或false</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>等于java.lang.String</td> 
  </tr> 
 </tbody> 
</table>

> 与java不同，上表的数据类型都是对象，scala没有java中具备的原生数据类型
> 
> 所以，在scala中可以对数字等基础类型调用方法

## Scala字面量 ##

### 多行字符串表示方法 ###

scala是可以使用上个双引号来分隔字符串的

val value = 
    """aaa
    bbb
    	ccc"""
    ----------------
    aaa
    bbb
    	ccc

## Scala数据类型层次结构 ##

Any:		 所有类型的超类(顶级类型)
    AnyVal：		表示值类型的超类
    AnyRef：		表示引用类型的超类，对应java.lang.Object
    Unit：		表示无值，类似Java中的void
    Nothing：	所有类型的子类
    Null：		表示null或空引用

> null是Null类型的唯一实例
> 
> nothing是所有类型的之类，Null是所有引用类型的子类，Nothing的父类

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SYLhjDaO-1596024135953)(…/…/…/…/Pictures/Typora/image-20200717111633549.png)\]

## 变量与常量 ##

### 变量 ###

赋值后可以改变，生命周期可以被多次赋值

var a=1
    a: Int = 1
    //------------------------------
    a=2
    a: Int = 2

### 常量 ###

赋值后不可变，类似于Java中的final变量

val a =1
    a: Int = 1
    //----------------------------------
    a=2
    error: reassignment to val

> 创建一个对象后，往往不需要改变对象本身的引用
> 
> val 相当于使用final修饰变量，没有线程安全问题，效率较高，推荐使用

> 在scala中，变量的声明需要赋初始值

### scala多变量声明 ###

scala中可以支持多个变量的声明：`val a,b=100 //a=100,b=100`

## type 关键字 ##

type 类型别名=类型
    //----------------------------------
    type T = String
    defined type alias T
    //--------------------------
    val name:T="jason"
    name: T = jason

## 字符串插值 ##

### s插值器 ###

允许将变量引用、表达式直接插入字面字符中

val name="James"
    println(s"Hello,$name")	//Hello,James
    println(s"1+1=${1+1}") 	//1+1=2

### f插值器 ###

val height=1.9d
    val name="James"
    println(f"$name%s is $height%2.2f meters tall")

### raw插值器 ###

s"a\nb"		//将输出换行符
    raw"a\nb"		//输出原始字符

## 条件控制 ##

scala中任何表达式都是有返回值的，if/else 也是有返回结果的

var sum = 9
    println(if(sum<5) 5)
    //返回(),即Unit

### switch ###

scala中没有switch，使用模式匹配来处理`match-case`

### for ###

for(i<- 1 to 3)
    //i为循环的变量，1-3循环，两端闭合
    for(i<- 1 until 3)
    //1-3循环，左闭右开

#### 循环守卫 ####

也叫循环保护式，值为true时才进入循环内部，类似于continue

for(i <- 1 to 3 if i!=2) print(i+" ")
    //打印结果：1 3

#### 引入变量 ####

这里举例说明

for(i<- 1 to 3;j=4-i)
    等价于
    for(i <- 1 to 3){
        val j = 4-i
    }

#### 嵌套循环 ####

for(i<- 1 to 3;j<- 2 to 4)
    //嵌套循环

#### 循环返回值 ####

之前提过，scala中任何表达式都是有返回值的

val res = for(i<- 1 to 10)yield i
    
    //这里，没次遍历过程都会返回一个新Vector集合
    对1-10进行遍历，
    yield i 将每次循环得到的i放入集合中，返回给res
    //这里的i指的是一个代码块，在这个位置可以对遍历得到的i进行处理,举例
    val res = for(i<- 1 to 10)yield {
    	if(i>2) 19 else i 
    }

#### 花括号代替小括号 ####

在for表达式中，可以使用花括号代替小括号

> 不成文规定  
> 推导式中只有单一表达式是用圆括号  
> 包含大于一个表达式，使用花括号

for(i<- 1 to 10;j<- 2 to 9){
        print(i+j)
    }
    //可以写成
    for{
        i<- 1 to 10
        j<- 2 to 9
    }{
        print(i+j)
    }

#### for循环中控制步长 ####

##### 1.Range #####

`for(i<- Range(1,10,2))`

##### 2.使用循环守卫 #####

`for(i<- 1 to 10 if i%2== 1)`

### while ，do while ###

由于while和do while 没有结果为Unit,本身没有返回值，所以需要返回结果时只能通过在外部定义变量的方式(即循环内部对外部变量造成影响)，所以推荐使用for循环

### break 和 continue ###

scala中没有break和continue，若想实现break和continue效果，可以借助Break函数

## 访问修饰符 ##

### Private ###

scala允许内部类访问外部类的私有成员，因为内部类包含在外部类里

### Protected ###

在java中，Protected修饰的成员可以被该成员子类和同一个包的其他类访问

而在Scala中，Protected修饰的成员只可以被该成员之类访问(保护的更加严格)

### Public ###

在Scala中，默认访问修饰符为public，在任何地方都可以被访问

### 作用域保护 ###

private[x] //该成员除了x可见，对其他都为私有
    protected[x]	//类比上一句，差不多

## 方法与函数 ##

在Scala中，方法是类的一部分，函数是一个对象(换句话说，在类中定义的函数就是方法)

函数是一个完整的对象，Scala中的函数其实就是继承了Tradit的类的对象

Scala中，使用val语句定义函数，def语句定义方法

### 方法声明和方法抽象 ###

//方法声明
    def functionName ([参数列表]) ：[return type]
    //若不写=号和方法主体，这默认为一个抽象类型方法
    
    
    //方法定义
    def functionName ([参数列表]) : [return type] ={
        function body
        return ...
    }

### 方法调用 ###

//标准格式
    functionName(参数列表)

## Scala闭包 ##

闭包的实质是代码与非局部变量的混合，(本质上闭包是一个函数)

object add {
    
      def main(args: Array[String]): Unit = {
        println("add2 value is:" + add2(2))
        println("add2 value is:" + add2(3))
      }
    
      val tag=3
      val add2 = (i:Int) => i*tag
    }