Scala

古城微笑少年丶 2022-03-24 15:46 168阅读 0赞

1，概述

Scala 是基于 jvm (虚拟机) 上的编程语言，主要用于 spark；

常用的 Scala 的文件类型：scala App，scala class，scala object；主要用 object

三种类型的共同点：先翻译成 java 文件，编译成 class 文件，最后执行 class；

三种类型的区别是：1）scala App 里主要执行代码，相当于java 的 main方法。而在object，class文件中执行代码必须放在方法中；

2）scala object 里只有一个无参的构造方法，不能有有参数构造方法；

3）scala object 里没有静态类型的变量与方法；

4）scala class 与 java class 基本一样；

配置 Scala 环境：

1）获取 Scala sdk 安装包 scala-2.12.8.tgz

2）解压到 /usr/local/下

3）配置环境变量

4）生效环境变量

5）测试

$>scala  -version

2，数据类型

2.1，java 中基本类型对应的数据类型

byte：Byte

short：Short

int ：Int

long：Long

float：Float

double：Double

char：Char

boolean：Boolean

2.2，Unit

Unit 与  java void 作用类似表示没有返回值，返回()；

2.3， String

与 java 的 String 作用相同；

2.4，any 等类型

any：任意类型；

3，声明变量，方法，函数

3.1，修饰符

**Scala 修饰符有三个：private，protected，public； public是默认；**

与 java 的区别：protected：java 的 protected 是同包，子类可以访问，Scala 的 protected 只能子类访问；

3.2，常量

语法：**val  变量\[：类型\] ＝ 初始化值；**

常量的值初始化后不能再做更改；

样例：val  num  = 10;             //根据值 10 常量类型自动设置为 Int

val  num1:Int = 10;      //指定为Int类型

val  num2:Double = 10d;

3.3，变量

变量值可以更改

语法：**val  变量\[：类型\] ＝ 初始化值；**

3.4，方法

语法：**def  方法名（参数1：类型1，参数2：类型2\*）：返回类型=\{方法体\} **

注意：没有返回值不用写 ：返回类型= 号；形参是常量类型，不能改变值；

样例：求两个数的积：

object valdemo{
        def main(args:Array[String]:Unit = {
            println(fun(2,13));
    
        }
        
        //有返回值
        def fun(a:Int,b:Int):Int={
            var c = a*b
            c   //如果有返回值，最后一行即返回值不用写 return
        }
    
        //无返回值
        def fun1(a:Int,b:Int){  //没有返回值不需要设置返回值类型
            var c = a*b
            println(c)
        }
    
        //无返回值
        def fun2(a:Int,b:Int):Unit={  //没有返回值不需要设置返回值类型
            var c = a*b
            println(c)
        }
    }

3.5，函数

语法：**var  mulFun = (参数名1：类型，参数名2：类型\*) => \{方法体\}**

样例：求两个数的积：

var mulFun = (a:Int,b:Int)=>\{a\*b\}

object test1{
         def main(args:Array[String]:Unit = {
            var mulFun = (a:Int,b:Int)=>{
                a*b
            }
            println(mulFun(3,7));
        }
    }

4，Array 与 map

4.1，概念

数组是定长的一组数据，大部分数组都是同一类型的；但是 **元数组** 是可以是任意类型的。

4.2，定义数组

1）＝ new Array\[类型\] （长度）

语法：**var  nums = new Array\[Int\](5)**

2）＝（元素1，元素2 ，~~~）

语法：**var  nums = (1,3,5,7,9)**

object test1{
         def main(args:Array[String]:Unit = {
            var nums1 = new Array[Int](3)
             //设值
             nums1(0) = 1
             nums1(1) = 2
             nums1(2) = 3
    
            var nums2 = Array(1,3,5,7,9)
             //取值
             println(nums2(1))
    
            //遍历
            for(a<-nums2){
                println(a)
            }
            
            val printFun = (x:Int)=>{println(x)};
            nums2.foreach(printFun)
            //或者
            nums2.foreach(x=>println(x));
            //或者
            nums2.foreach(println);
        }
    }

4.3，操作数组

4.4，其他操作

5，List 与高阶函数

5.1，

5.2，高阶函数

5.2.1，foreach

foreach 循环返回值是 Unit 时  语法：

**foreach（形参名＝>方法体）\{\}**

样例：

val printFun = (x:Int)=>{println(x)};
    nums2.foreach(printFun)
    //或者
    nums2.foreach(x=>println(x));
    //或者
    nums2.foreach(println);

5.2.2，filter

filter是过滤，返回值是一个新数组或集合，方法体要求返回Boolean，如果是 true 数据在返回结果中保留，反之丢弃

语法：**filter（形参名=>方法体）**

样列：获取数组中的偶数：

val nums = Array(1,2,3,4,5,6,7,8);
    var rs = nums.filter(a=>a%2==0);
    rs.foreach(x=>print(x+" "))

5.2.3，map

map是对数组或集合中每一个数据做处理，返回值是一个新的数组或集合，方法体要求返回一个数组或集合元素；

语法：**map（形参=>方法体） **

样例：

val nums = Array(1,2,3,4,5,6,7,8,9,10);
    val rs = nums.map(x=>x*3)    //每一个元素乘3作为新数组成员
    rs.foreach(x=>print(x+" "))
    
    var nusic = new Array[String](5);
    music(0) = "101_song_2016-11 song1";
    music(1) = "102_song_2016-11 song2";
    music(2) = "103_song_2016-11 song3";
    music(3) = "104_song_2016-11 song2";
    music(4) = "105_song_2016-11 song2";
    var names = music.map(info=>{    //以空格拆分每一个元素生成新的结果集，新数组每一个元素只要歌名       
        info.split(" ")(1)
    });
    names.foreach(println)

5.2.4，reduce

reduce 是先对数组或集合中的元素1和元素2进行处理，然后将结果与元素3进行处理，依次类推。

语法：**reduce（形参=>方法体）**

样例：

// x：上一条数据，y：下一条数据
    val nums4 = Array(1,2,3,4,5,6,7,8)
    var sum = nums4.reduce((x,y)=>{x+y});
    或者
    var sum1 = nums4.reduce(_+_);
    println(sum);