Scala编程语言入门教程

Scala教程

  • 方便个人学习和查阅

学习目标

在这里插入图片描述

Scala介绍

简介

在这里插入图片描述
Scala创始人Martin Odersky马丁·奥德斯基

再回到我们的scala语言,在Scala官网https://www.scala-lang.org/介绍了其六大特征。

在这里插入图片描述

  1. Javascala可以混编

  2. 类型推测(自动推测类型)

  3. 并发和分布式(Actor

  4. 特质,特征(类似javainterfacesabstract结合)

  5. 模式匹配(类似java中的switch...case

  6. 高阶函数

一句话总结:scala是一门以jvm为运行环境的静态类型编程语言,具备面向对象及函数式编程的特性。

具体应用

kafka:分布式消息队列,内部代码经常用来处理并发的问题,用scala可以大大简化其代码。

spark:方便处理多线程场景,另外spark主要用作内存计算,经常要用来实现复杂的算法。利用scala这种函数式编程语言可以大大简化代码。

Scala安装使用

windows安装,配置环境变量

版本选择

在这里插入图片描述

根据我们接下来学习的spark的版本来决定scala的版本。具体选择情况在spark的官网进行查看。

http://spark.apache.org/docs到里面找对应spark版本的文档进行查看。

下载

官网下载scala2.12:https://www.scala-lang.org/download/2.12.11.html

在这里插入图片描述

安装好java是前提

到当前网页最下方找到如下图所示文件下载(zip文件也可以,记得一同下载api docs的zip包和源码sources)。

在这里插入图片描述

下载下来即可,双击msi包安装,记住安装的路径方便后续配置环境变量。

在这里插入图片描述

在这里插入图片描述

该内容在对应安装好的bin目录下。

配置环境变量

配置方法同jdk配置方式。

在这里插入图片描述

新建SCALA_HOME

上个步骤完成后,编辑Path变量,在后面新建如下:

在这里插入图片描述

验证

打开cmd,输入:scala -version 看是否显示版本号,确定是否安装成功
在这里插入图片描述

idea 中配置scala插件

安装

第一步:打开idea,点击Configure->Plugins

在这里插入图片描述

第二步:搜索scala,点击Install安装,第一次安装完成后会要求重启ide

在这里插入图片描述

第三步:设置新建项目的默认设置

新建项目相关设置

第一步:设置你的jdk

在这里插入图片描述

第二步:选中你对应jdk安装路径即可。

在这里插入图片描述

最终如图所示即可

在这里插入图片描述

创建scala项目

第一步:创建基础scala项目,配置scala sdk(Software Development Kit)

在这里插入图片描述

在这里插入图片描述

第二步:点击Browse选择本地安装的Scala目录即可。

在这里插入图片描述

Scala基础

数据类型

在这里插入图片描述

比较特殊的None,是Option的两个子类之一,另一个是Some,用于安全的函数返回值。

scala推荐在可能返回空的方法使用Option[X]作为返回类型。如果有值就返回Some[X],否则返回None

def get(key: A): Option[B] = {if (contains(key))Some(getValue(key))elseNone
}

Nil表示长度为0的List

变量和常量的声明

注意如下两点:

  • 定义变量或者常量的时候,也可以写上返回的类型,一般省略,如:val a:Int = 10
  • 常量不可再赋值
/*** 定义变量和常量* 变量 :用 var 定义 ,可修改 * 常量 :用 val 定义,不可修改*/
var name = "zhangsan"
println(name)
name ="lisi"
println(name)
val gender = "m"
//    gender = "m"//错误,不能给常量再赋值 

键盘标准输入

编程中可以通过键盘输入语句来接收用户输入的数据。(回顾java中的scanner对象)

scala中只需要导入对应的包,比java还要简单不需要实例化对象。

import scala.io.StdInobject Test {def main(args: Array[String]): Unit = {println("请输入姓名")val name = StdIn.readLine()println("请输入年龄")val age = StdIn.readInt()printf("您输入的姓名是%s,年龄是%d",name,age)}
}

如上述代码所示,printf的用法和java中一样为格式化输出。使用时注意规范即可。

符号含义
%d十进制数字
%s字符串
%c字符
%e指数浮点数
%f浮点数

类和对象

创建类

class Person{val name = "zhangsan"val age = 18def sayName() = {"my name is "+ name}
}

创建对象

object Lesson_Class {def main(args: Array[String]): Unit = {val person = new Person()println(person.age);println(person.sayName())}
}

伴生类和伴生对象

class Person(xname :String , xage :Int){var name = Person.nameval age = xagevar gender = "m"def this(name:String,age:Int,g:String){this(name,age)gender = g}def sayName() = {"my name is "+ name}}object Person {val name = "zhangsanfeng"def main(args: Array[String]): Unit = {val person = new Person("wagnwu",10,"f")println(person.age);println(person.sayName())println(person.gender)}
}

注意点:

  • 建议类名首字母大写 ,方法首字母小写,类和方法命名建议符合驼峰命名法。

  • scala 中的object是单例对象,相当于java中的工具类,可以看成是定义静态的方法的类。object不可以传参数。另:Trait不可以传参数

  • scala中的class类默认可以传参数,默认的传参数就是默认的构造函数。
    重写构造函数的时候,必须要调用默认的构造函数。

  • class 类属性自带gettersetter方法。

  • 使用object时,不用new,使用class时要new ,并且new的时候,class中除了方法不执行,其他都执行。

  • 如果在同一个文件中,object对象和class类的名称相同,则这个对象就是这个类的伴生对象,这个类就是这个对象的伴生类。可以互相访问私有变量。

    上述这些注意点就是scalaoop面向对象的注意点。

if else

java一样的语法结构,单,双,多分支这样三种顺序控制结构。

/*** StdIn键盘标准输入 scala.io包下的*/
def main(args: Array[String]): Unit = {println("请输入年龄:")val age = StdIn.readInt()if(age >= 18 && age < 100){println("成年")}else if( age > 0 && age < 18){println("未成年")}else{println("???")}
}

for ,while,do…while

1.tountil 的用法(不带步长,带步长区别)

/*** to和until* 例:* 1 to 10 返回1到10的Range数组,包含10* 1 until 10 返回1到10 Range数组 ,不包含10*/println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
println(1.to(10))//与上面等价,打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10println(1 to (10 ,2))//步长为2,从1开始打印 ,1,3,5,7,9
println(1.to(10, 2)) println(1 until 10 ) //不包含最后一个数,打印 1,2,3,4,5,6,7,8,9
println(1.until(10))//与上面等价println(1 until (10 ,3 ))//步长为2,从1开始打印,打印1,4,7

2.创建for循环

/*** for 循环* */
for( i <- 1 to 10 ){println(i)
}

3.创建多层for循环

//可以分号隔开,写入多个list赋值的变量,构成多层for循环
//scala中 不能写count++ count-- 只能写count+
var count = 0;
for(i <- 1 to 10; j <- 1 until 10){println("i="+ i +",	j="+j)count += 1
}
println(count);
//例子: 打印小九九
for(i <- 1 until 10 ;j <- 1 until 10){if(i>=j){print(i +" * " + j + " = "+ i*j+"	")}if(i==j ){println()} 
}

4.for循环中可以加条件判断,分号隔开

//可以在for循环中加入条件判断
for(i<- 1 to 10 ;if (i%2) == 0 ;if (i == 4) ){println(i)
}

5.scala中不能使用count++count--只能使用count = count+1count += 1

6.for循环用yield 关键字返回一个集合(for {子句} yield {变量或表达式},原来的集合不会被改变,只会通过你的for/yield构建出一个新的集合。)

7.while循环(两种方式),while(){},do {}while()

//将for中的符合条件的元素通过yield关键字返回成一个集合
val list = for(i <- 1 to 10  ; if(i > 5 )) yield i 
for( w <- list ){println(w)
}/*** while 循环*/
var index = 0 
while(index < 100 ){println("第"+index+"次while 循环")index += 1 
}
index = 0 
do{index +=1 println("第"+index+"次do while 循环")
}while(index <100 )

Scala函数

Scala函数的定义

有参函数

无参函数

在这里插入图片描述

def fun (a: Int , b: Int ) : Unit = {println(a+b)
}
fun(1,1)def fun1 (a : Int , b : Int) = a+b
println(fun1(1,2))  

注意点:

Scala使用def关键字告诉编译器这是一个方法。

我们可以通过在参数后面加一个冒号和类型来显式地指定返回类型。

方法可以写返回值的类型也可以不写,会自动推断,有时候不能省略,必须写,比如在递归函数中或者函数的返回值是函数类型的时候。

Scala中函数有返回值时,可以写return,也可以不写return,不写return时会把函数中最后一行当做结果返回。当写return时,必须要写函数的返回类型。

如果返回值可以一行搞定,可以将{}省略不写

传递给方法的参数可以在方法中使用,并且scala规定方法的传过来的参数为val的,不是var的。

如果去掉方法体前面的等号,那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立,scala可以把任意类型转换为Unit。假设,函数里面的逻辑最后返回了一个string,那么这个返回值会被转换成Unit,原本逻辑的值会被丢弃。

递归函数

/*** 递归函数 * 5的阶乘*/
def fun2(num :Int) :Int= {if(num ==1)numelse num * fun2(num-1)
}
print(fun2(5))

包含参数默认值的函数

  • 默认值的函数中,如果传入的参数个数与函数定义相同,则传入的数值会覆盖默认值。
  • 如果不想覆盖默认值,传入的参数个数小于定义的函数的参数,则需要指定参数名称。
 /*** 包含默认参数值的函数* 注意:* 1.默认值的函数中,如果传入的参数个数与函数定义相同,则传入的数值会覆盖默认值* 2.如果不想覆盖默认值,传入的参数个数小于定义的函数的参数,则需要指定参数名称*/
def fun3(a :Int = 10,b:Int) = {println(a+b)
}
fun3(b=2)

可变参数个数的函数

可变参数理解为不定长数组,传递多个参数时用逗号分开,处理起来按照数组方式。

/*** 可变参数个数的函数* 注意:多个参数逗号分开*/
def fun4(elements :Int*)={var sum = 0;for(elem <- elements){sum += elem}sum
}
println(fun4(1,2,3,4))

匿名函数

一共有如下三种:

  1. 有参匿名函数
  2. 无参匿名函数
  3. 有返回值的匿名函数
  • 可以将匿名函数返回给val定义的值
  • 匿名函数不能显式声明函数的返回类型
/*** 匿名函数* 1.有参数匿名函数* 2.无参数匿名函数* 3.有返回值的匿名函数* 注意:* 可以将匿名函数返回给定义的一个变量*/
//有参数匿名函数
val value1 = (a : Int) => {println(a)
}
value1(1)
//无参数匿名函数
val value2 = ()=>{println("我爱中国")
}
value2()
//有返回值的匿名函数
val value3 = (a:Int,b:Int) =>{a+b
}
println(value3(4,4))

嵌套函数

/*** 嵌套函数* 例如:嵌套函数求5的阶乘*/
def fun5(num:Int)={def fun6(a:Int,b:Int):Int={if(a == 1){b}else{fun6(a-1,a*b)}}fun6(num,1)
}
println(fun5(5))

偏应用函数

偏应用函数是一种表达式,不需要提供函数需要的所有参数,只需要提供部分,或不提供所需参数。如下场景中,一个参数是完全相同,另一个参数不同,在这样一个情况之下,我们可以使用偏应用函数来进行优化。

/*** 偏应用函数*/
def log(date :Date, s :String)= {println("date is "+ date +",log is "+ s)
}val date = new Date()
log(date ,"log1")
log(date ,"log2")
log(date ,"log3")//想要调用log,以上变化的是第二个参数,可以用偏应用函数处理
val logWithDate = log(date,_:String)
logWithDate("log11")
logWithDate("log22")
logWithDate("log33")

高阶函数

函数的参数是函数,或者函数的返回类型是函数,或者函数的参数和函数的返回类型是函数的函数。

  • 函数的参数是函数
  • 函数的返回是函数
  • 函数的参数和函数的返回是函数
/*** 高阶函数* 函数的参数是函数		或者函数的返回是函数		或者函数的参数和返回都是函数*/    
//函数的参数是函数
def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {f(a,100)
}
def f(v1 :Int,v2: Int):Int  = {v1+v2
} 
println(hightFun(f, 1))//函数的返回是函数
//1,2,3,4相加
def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {def f2 (v1: Int,v2:Int) :Int = {v1+v2+a+b}f2
}
println(hightFun2(1,2)(3,4))//函数的参数是函数,函数的返回是函数
def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {f
} 
//println(hightFun3(f)(100,200))
println(hightFun3((a,b) =>{a+b})(200,200))
//以上这句话还可以写成这样
//如果函数的参数在方法体中只使用了一次 那么可以写成_表示
println(hightFun3(_+_)(200,200))

柯里化函数

柯里化–颗粒化,将参数变成颗粒散落简而言之就是将参数拆拆拆。函数柯里化基本是在做这么一件事情:只传递给函数一部分参数来调用它,让它返回一个函数去处理剩下的参数。如果写成公式文字就是这样。

fn(a,b,c,d)=>fn(a)(b)(c)(d)fn(a,b,c,d)=>fn(a,b)(c)(d)fn(a,b,c,d)=>fn(a)(b,c,d)

柯里化函数最早在js中有使用到: 实例如下:

// 普通的add函数
function add(x, y) {return x + y
}
// Currying(柯里化)后
function curryingAdd(x) {return function (y) {return x + y}
}add(1, 2)           // 3
curryingAdd(1)(2)   // 3

可以理解为高阶函数的简化。和我们文档中上面的函数的返回类是函数的例子进行比较。

//def fun7(a :Int,b:Int,c:Int,d:Int) = {
//  a+b+c+d
//}
//println(fun7(1,2,3,4))
/*** 柯里化函数*/
def fun7(a :Int,b:Int)(c:Int,d:Int) = {a+b+c+d
}
println(fun7(1,2)(3,4))//执行完1+2得出3之后继续往下作为函数执行3+3+4最终求出结果10

Scala字符串

String

StringBuilder 可变

string操作方法举例

  • 比较:equals
  • 比较忽略大小写:equalsIgnoreCase
  • indexOf:如果字符串中有传入的assci码对应的值,返回下标
/*** String && StringBuilder*/
val str = "abcd"
val str1 = "ABCD"println(str.indexOf(97))
println(str.indexOf("b"))
println(str==str1)
/*** compareToIgnoreCase* * 如果参数字符串等于此字符串,则返回值 0;* 如果此字符串小于字符串参数,则返回一个小于 0 的值;* 如果此字符串大于字符串参数,则返回一个大于 0 的值。*/
println(str.compareToIgnoreCase(str1))val strBuilder = new StringBuilder
strBuilder.append("abc")
//strBuilder.+('d')
strBuilder+ 'd'
//strBuilder.++=("efg")
strBuilder++= "efg" 
//strBuilder.+=('h')
strBuilder+= 'h' 
strBuilder.append(1.0)
strBuilder.append(18f)
println(strBuilder)

String基本方法:(见附件)

String方法

集合

数组

创建数组

两种方式:

/*** 创建数组两种方式:* 1.new Array[String](3)* 2.直接Array*///创建类型为Int 长度为3的数组
val arr1 = new Array[Int](3)
//创建String 类型的数组,直接赋值
val arr2 = Array[String]("s100","s200","s300")
//赋值
arr1(0) = 100
arr1(1) = 200
arr1(2) = 300

数组遍历

两种方式:

  • for
  • foreach
/*** 遍历两种方式*/
for(i <- arr1){println(i)
}
arr1.foreach(i => {println(i)
})for(s <- arr2){println(s)
}
arr2.foreach { x => println(x) 
}
//最简单写法
arr2.foreach(println)

创建二维数组

/*** 创建二维数组和遍历*/
val arr3 = new Array[Array[String]](3)
arr3(0)=Array("1","2","3")
arr3(1)=Array("4","5","6")
arr3(2)=Array("7","8","9")
for(i <- 0 until arr3.length){for(j <- 0 until arr3(i).length){print(arr3(i)(j)+"	")}println()
}var count = 0
for(arr <- arr3 ;i <- arr){if(count%3 == 0){println()}print(i+"	")count +=1 
}arr3.foreach { arr  => {arr.foreach { println }
}}val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
arr4.foreach { arr => {arr.foreach(i => {println(i)})
}}
println("-------")
for(arr <- arr4;i <- arr){println(i)
}

数组中方法举例

数组方法

可变长度数组

//需要引入相应包,mutable就是可变,immutable就是不可变
import scala.collection.mutable.ArrayBufferval arr = ArrayBuffer[String]("a","b","c")
arr.append("hello","scala")//添加多个元素
arr.+=("end")//在最后追加元素
arr.+=:("start")//在开头添加元素
arr.foreach(println)

list

创建list

//创建
val list = List(1,2,3,4,5)

不要忘记Nil长度为0的List

list遍历

for,foreach两种方式

//遍历
list.foreach { x => println(x)}
//    list.foreach { println}

list方法举例

filter:过滤元素

count:计算符合条件的元素个数

map:对元素操作

flatmap :压扁扁平,先map再flat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6S9oGcYM-1691214029238)(Scala.assets/list方法map&flatMap.png)]

//filter
val list1  = list.filter { x => x>3 }
list1.foreach { println}
//count
val value = list1.count { x => x>3 }
println(value)//map
val nameList = List("hello beijing","hello shanghai","hello guangzhou")
val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
mapResult.foreach{println}    //flatmap
val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
flatMapResult.foreach { println }

list方法总结

List方法

可变长度List

import scala.collection.mutable.ListBufferval listBuffer = ListBuffer[Int](1,2,3,4,5)
listBuffer.append(6,7,8,9)	//追加元素
listBuffer.+=(10)			//在后面追加元素
listBuffer.+=:(100)			//在开头追加元素
listBuffer.foreach(println)

Set

创建Set

注意:set集合自动去重

//创建 
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)

遍历Set

同样两种方式forforeach

//遍历
set1.foreach { println}
for(s <- set1){println(s)
}
println("*******")

Set方法举例

  1. 交集:intersect ,&
  2. 差集:diff ,&~
  3. 子集:subsetOf
  4. 最大:max
  5. 最小:min
  6. 转成数组:toList
  7. 转成字符串:mkString
/*** 方法举例*///交集
val set3 = set1.intersect(set2)
set3.foreach{println}
val set4 = set1.&(set2)
set4.foreach{println}
println("*******")
//差集
set1.diff(set2).foreach { println }
set1.&~(set2).foreach { println }
//子集
set1.subsetOf(set2)//最大值
println(set1.max)
//最小值
println(set1.min)  
println("****")//转成数组,list
set1.toArray.foreach{println}
println("****")
set1.toList.foreach{println}//mkString
println(set1.mkString)
println(set1.mkString("\t"))

Set方法总结

Set方法

可变长度Set

import scala.collection.mutable.Setval set =  Set[Int](1,2,3,4,5)
set.add(100)
set.+=(200)
set.+=(1,210,300)
set.foreach(println)

Map

创建Map

  • Map(1 –>"shanghai") 键 -> 值的对应关系创建

  • Map((1,"shanghai")) 元组的形式(key,value)

创建map时,相同的key被后面的相同的key顶替掉,只保留一个。

val map = Map("1" -> "shanghai",2 -> "shanghai",(3,"beijing")
)

获取Map的值

  • map.get("1").get

  • map.get(100).getOrElse("no value")此种方式如果map中没有对应项则赋值为getOrElse里面的值。

//获取值
println(map.get("1").get)
val result = map.get(8).getOrElse("no value")
println(result)

遍历Map

两种方式forforeach

//map遍历
for(x <- map){println("====key:"+x._1+",value:"+x._2)
}
map.foreach(f => {println("key:"+ f._1+" ,value:"+f._2)
})
遍历key
//遍历key
val keyIterable = map.keys
keyIterable.foreach { key => {println("key:"+key+", value:"+map.get(key).get)
} }
println("---------")
遍历value
//遍历value
val valueIterable = map.values
valueIterable.foreach { value => {println("value: "+ value)
} }

合并Map

//合并map
val map1 = Map((1,"a"),    (2,"b"),    (3,"c")    
)
val map2 = Map((1,"aa"),(2,"bb"),(2,90),(4,22),(4,"dd")
)
map1.++(map2).foreach(println)

注意:合并map会将map中的相同keyvalue替换.

Map方法举例

  • filter:过滤,留下符合条件的记录

  • count:统计符合条件的记录数

  • containsmap中是否包含某个key

  • exist:符合条件的记录存在与否

/*** map方法*/
//count
val countResult  = map.count(p => {p._2.equals("shanghai")
})
println(countResult)//filter
map.filter(_._2.equals("shanghai")).foreach(println)//contains
println(map.contains(2))
//exist
println(map.exists(f =>{f._2.equals("guangzhou")}))

Map方法总结

Map方法

可变长度Map

import scala.collection.mutable.Map
//如果你想要添加一个原来的map中没有的value类型,要么就手动显示[String,Any]
val map =  Map[String,Any](("name", "lisi"),("money",200))
map+=("age"->18)//单个添加
map+=("age1"->18,"age2"->18,"age3"->18)//多个添加
map-=("age")//删除直接针对key值。map.remove("age")

元组Tuple

元组的定义

大体与列表一样,不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。

创建元组

  • val tuple = new Tuple(1)

  • val tuple2 = Tuple2(1,2) ,也可以直接写成val tuple3 =(1,2,3)

  • 取值用._X可以获取元组中的值

注意:tuple最多支持22个参数。

//创建,最多支持22个
val tuple = new Tuple1(1)
val tuple2 = Tuple2("zhangsan",2)
val tuple3 = Tuple3(1,2,3)
val tuple4 = (1,2,3,4)
val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)//使用
println(tuple2._1 + "\t"+tuple2._2)
val t = Tuple2((1,2),("zhangsan","lisi"))
println(t._1._2)

遍历元组

虽然元组不是集合,但是在遍历使用时可以当作一个集合来用。

通过tuple.productIterator得到迭代器,进而实现遍历。迭代器只能使用一次,下次还想遍历就需要构建一个新的iterator

//遍历
val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){println(tupleIterator.next())
}

元组的简单方法

例如swaptoString方法。注意swap的元素翻转只针对二元组。

/*** 方法*/
//翻转,只针对二元组
println(tuple2.swap)//toString
println(tuple3.toString())

trait

概念

ScalaTrait(特征) 相当于 Java 的接口,实际上它比接口还功能强大。

与接口不同的是,它还可以定义属性和方法的实现。

一般情况下Scala的类可以继承多个Trait,从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似,但它使用的关键字是 trait

具体写法

trait中带属性带方法实现

注意:

  • 继承的多个trait中如果有同名的方法和属性,必须要在类中使用override重新定义。

  • trait中不可以传参数

trait Read {val readType = "Read"val gender = "m"def read(name:String){println(name+" is reading")}
}trait Listen {val listenType = "Listen"val gender = "m"def listen(name:String){println(name + " is listenning")}
}class Person() extends Read with Listen{override val gender = "f"
}object test {def main(args: Array[String]): Unit = {val person = new Person()person.read("zhangsan")person.listen("lisi")println(person.listenType)println(person.readType)println(person.gender)}
}

trait中带方法不带方法实现

object Lesson_Trait2 {def main(args: Array[String]): Unit = {val p1 = new Point(1,2)val p2 = new Point(1,3)println(p1.isEqual(p2))println(p1.isNotEqual(p2))}
}trait Equal{def isEqual(x:Any) :Boolean def isNotEqual(x : Any)  = {!isEqual(x)}
}class Point(xx:Int, yy:Int) extends Equal {val x = xxval y = yydef isEqual(p:Any) = {if(p.isInstanceOf[Point]){//判断p是否为[XX]类的实例val point : Point = p.asInstanceOf[Point]//将p转换为[XX]类的实例x == point.x && y == point.y}elsefalse}
}

模式匹配 * match

概念

Scala 提供了强大的模式匹配机制,应用也非常广泛。

一个模式匹配包含了一系列备选项,每个都开始于关键字 case

每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

具体写法

object Lesson_Match {def main(args: Array[String]): Unit = {val tuple = Tuple6(1,2,3f,4,"abc",55d)val tupleIterator = tuple.productIteratorwhile(tupleIterator.hasNext){matchTest(tupleIterator.next())}}/*** 注意点:* 1.模式匹配不仅可以匹配值,还可以匹配类型* 2.模式匹配中,如果匹配到对应的类型或值,就不再继续往下匹配* 3.模式匹配中,都匹配不上时,会匹配到 case _ ,相当于default*/def matchTest(x:Any) ={x match {case x:Int=> println("type is Int")case 1 => println("result is 1")case 2 => println("result is 2")case 3=> println("result is 3")case 4 => println("result is 4")case x:String => println("type is String")
//      case x :Double => println("type is Double")case _ => println("no match")}}}

注意点

  • 模式匹配不仅可以匹配值还可以匹配类型
  • 从上到下顺序匹配,如果匹配到则不再往下匹配(跳出)
  • 都匹配不上时,会匹配到case _ ,相当于default
  • match 的最外面的{ }可以去掉看成一个语句

偏函数

如果一个方法中没有match 只有case,这个函数可以定义成PartialFunction偏函数。偏函数定义时,不能使用括号传参,默认定义PartialFunction中传入一个值,匹配上了对应的case,返回一个值,只能匹配同种类型。

一个case语句就可以理解为是一段匿名函数。

在这里插入图片描述

在这里插入图片描述

map函数和collect函数在源码中查看区别,collect接受的参数类型是PartialFunction[A,B],而不是A=>B

/*** 一个函数中只有case 没有match ,可以定义成PartailFunction 偏函数*/
object Lesson_PartialFunction {def MyTest : PartialFunction[String,String] = {case "scala" =>{"scala"}case "hello" =>{"hello"}case _ => {"no  match ..."}}def main(args: Array[String]): Unit = {println(MyTest("scala"))}
}/*** 第二个例子* map和collect的区别。*/
def main(args: Array[String]): Unit = {val list1 = List(1, 3, 5, "seven") map {MyTest}//List(1, 3, 5, "seven") map { case i: Int => i + 1 }list1.foreach(println)val list = List(1, 3, 5, "seven") collect {MyTest}//List(1, 3, 5, "seven") collect { case i: Int => i + 1 }list.foreach(println)
}
def MyTest: PartialFunction[Any, Int] = {case i: Int => i + 1
}

样例类(case classes)

概念

使用了case关键字的类定义就是样例类case classes,样例类是种特殊的类。实现了类构造参数的getter方法(构造参数默认被声明为val),当构造参数是声明为var类型的,它将帮你实现settergetter方法。

  • 样例类默认帮你实现了toString,equalscopyhashCode等方法。
  • 样例类可以new, 也可以不用new

具体写法

结合模式匹配的代码如下

case class Person1(name:String,age:Int)object Lesson_CaseClass {def main(args: Array[String]): Unit = {val p1 = new Person1("zhangsan",10)val p2 = Person1("lisi",20)val p3 = Person1("wangwu",30)val list = List(p1,p2,p3)list.foreach { x => {x match {case Person1("zhangsan",10) => println("zhangsan")case Person1("lisi",20) => println("lisi")case _ => println("no match")}} }}
}

隐式转换

概念

隐式转换是在Scala编译器进行类型匹配时,如果找不到合适的类型,那么隐式转换会让编译器在作用范围内自动推导出来合适的类型。

隐式值与隐式参数

隐式值是指在定义参数时前面加上implicit。隐式参数是指在定义方法时,方法中的部分参数是由implicit修饰【必须使用柯里化的方式,将隐式参数写在后面的括号中】。隐式转换作用就是:当调用方法时,不必手动传入方法中的隐式参数,Scala会自动在作用域范围内寻找隐式值自动传入。

注意点

  1. 同类型的参数的隐式值只能在作用域内出现一次,同一个作用域内不能定义多个类型一样的隐式值。
  2. implicit 关键字必须放在隐式参数定义的开头
  3. 一个方法只有一个参数是隐式转换参数时,那么可以直接定义implicit关键字修饰的参数,调用时直接创建类型不传入参数即可。
  4. 一个方法如果有多个参数,要实现部分参数的隐式转换,必须使用柯里化这种方式,隐式关键字出现在后面,只能出现一次。

具体写法

object Lesson_ImplicitValue {def Student(age:Int)(implicit name:String,i:Int)= {println( s"student :$name ,age = $age ,score = $i")}def Teacher(implicit name:String) ={println(s"teacher name is = $name")}def main(args: Array[String]): Unit = {implicit val zs = "zhangsan"implicit val sr = 100Student(18)Teacher}
}

隐式转换函数

隐式转换函数是使用关键字implicit修饰的函数。当Scala运行时,假设如果A类型变量调用了method()这个方法,发现A类型的变量没有method()方法,而B类型有此method()方法,会在作用域中寻找有没有隐式转换函数将A类型转换成B类型,如果有隐式转换函数,那么A类型就可以调用method()这个方法。

注意点

隐式转换函数只与函数的参数类型和返回类型有关,与函数名称无关,所以作用域内不能有相同的参数类型和返回类型的不同名称隐式转换函数。

具体写法

class Animal(name:String){def canFly(): Unit ={println(s"$name can fly...")}
}
class Rabbit(xname:String){val name = xname
}
object Lesson_ImplicitFunction {implicit def rabbitToAnimal(rabbit:Rabbit):Animal = {new Animal(rabbit.name)}def main(args: Array[String]): Unit = {val rabbit = new Rabbit("RABBIT")rabbit.canFly()}
}

隐式类

使用implicit关键字修饰的类就是隐式类。若一个变量A没有某些方法或者某些变量时,而这个变量A可以调用某些方法或者某些变量时,可以定义一个隐式类,隐式类中定义这些方法或者变量,隐式类中传入A即可。

注意点

  1. 隐式类必须定义在类,包对象,伴生对象中。
  2. 隐式类的构造必须只有一个参数,同一个类,包对象,伴生对象中不能出现同类型构造的隐式类。

具体写法

class Rabbit(s:String){val name = s
}object Lesson_ImplicitClass {implicit class Animal(rabbit:Rabbit){val tp = "Animal"def canFly() ={println(rabbit.name +" can fly...")}}def main(args: Array[String]): Unit = {val rabbit = new Rabbit("rabbit")rabbit.canFly()println(rabbit.tp)}
}

Actor Model

概念

Actor Model是用来编写并行计算或分布式系统的高层次抽象(类似java中的Thread)让程序员不必为多线程模式下共享锁而烦恼。Actors将状态和行为封装在一个轻量的进程/线程中,但是不和其他Actors分享状态,每个Actors有自己的世界观,当需要和其他Actors交互时,通过发送事件和消息,发送是异步的,非堵塞的(fire-andforget),发送消息后不必等另外Actors回复,也不必暂停,每个Actors有自己的消息队列,进来的消息按先来后到排列,这就有很好的并发策略和可伸缩性,可以建立性能很好的事件驱动系统。

2.12版本后,actor彻底从scala中抽离了出来,所以我们在使用前需要引入相应的lib。

<dependency><groupId>com.typesafe.akka</groupId><artifactId>akka-actor_2.12</artifactId><version>2.5.9</version>
</dependency>

Actor的特征

  • ActorModel是消息传递模型,基本特征就是消息传递
  • 消息发送是异步的,非阻塞的
  • 消息一旦发送成功,不能修改
  • Actor之间传递时,接收消息的actor自己决定去检查消息,actor不是一直等待,是异步非阻塞的

具体写法

Actor发送接收消息

import akka.actor.Actor
import akka.actor.ActorSystem
import akka.actor.Propsclass HelloActor extends Actor {override def receive: Receive = {case "hey" => println("hey yourself")case _ => println("hehe")}
}object Main extends App {val system = ActorSystem("HelloSystem")val helloActor = system.actorOf(Props[HelloActor], name = "helloActor")helloActor ! "hey"helloActor ! "good morning"
}

Actor与Actor之间通信

import akka.actor.{Actor, ActorRef, ActorSystem, Props}class MyActor extends Actor {override def receive: Receive = {case msg: String => {println(msg)Thread.sleep(1000)sender() ! "你说啥"}case Int => println("你竟然说数字")case _ => println("default")}
}
class MyActor2 extends Actor {private val other: ActorRef = context.actorOf(Props(new MyActor), "actor1child")override def receive: Receive = {case msg: String => {println(msg)other ! "nihao"}}
}
object Test extends App {private val system: ActorSystem = ActorSystem("system")private val actor: ActorRef = system.actorOf(Props(new MyActor2), "actor1")actor ! "你好actor2"
}

Spark预热之WordCount

<dependency><groupId>org.apache.spark</groupId><artifactId>spark-core_2.12</artifactId><version>2.4.6</version>
</dependency>
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.rdd.RDD.rddToPairRDDFunctionsobject WordCount {def main(args: Array[String]): Unit = {val conf = new SparkConf()conf.setMaster("local").setAppName("WC")val sc = new SparkContext(conf)val lines :RDD[String] = sc.textFile("./words.txt")val word :RDD[String]  = lines.flatMap{lines => {lines.split(" ")}}val pairs : RDD[(String,Int)] = word.map{ x => (x,1) }val result = pairs.reduceByKey{(a,b)=> {a+b}}result.sortBy(_._2,false).foreach(println)//简化写法lines.flatMap { _.split(" ")}.map { (_,1)}.reduceByKey(_+_).foreach(println)}
}

  • 学习资料,链接: https://pan.baidu.com/s/12BaUZIgtQHKkdyMn2RF9ig 提取码: 6ed5

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/30493.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

每日一学:什么是 Harbor ?

目录 什么是 Harbor &#xff1f; 一、Harbor 的优势 二、Harbor 架构构成 三、Core services 这是 Harbor 的核心功能 什么是 Harbor &#xff1f; Harbor 是 VMware 公司开源的企业级 Docker Registry 项目&#xff0c;其目标是帮助用户迅速搭建一个企业级的 Docker Reg…

VUE之JWT前后端分离认证,学生管理系统

参考资料: SpringBoot搭建教程 SpringCloud搭建教程 JWT视频教程 JWT官网 Vue视频教程 JWT视频参考资料、VUE视频资料,及前后端demo 特别有参考价值的JWT博客1 特别有参考价值的JWT博客2 cookie、localstorage和sessionStorage的区别1 cookie、localstorage和sessi…

Metamask登录方式集成

Metamask登录 https://www.toptal.com/ethereum/one-click-login-flows-a-metamask-tutorial#how-the-login-flow-works 参考&#xff1a; https://zh.socialgekon.com/one-click-login-with-blockchain 后端需要在用户表中增加address和nonce字段。兼容其他登录方式&#xff0…

【分布式技术专题】RocketMQ延迟消息实现原理和源码分析

痛点背景 业务场景 假设有这么一个需求&#xff0c;用户下单后如果30分钟未支付&#xff0c;则该订单需要被关闭。你会怎么做&#xff1f; 之前方案 最简单的做法&#xff0c;可以服务端启动个定时器&#xff0c;隔个几秒扫描数据库中待支付的订单&#xff0c;如果(当前时间-订…

国产芯力特SIT1024QHG四通道本地互联网络(LIN)收发器,可替代TJA1024HG

SIT1024Q 是一款四通道本地互联网络&#xff08;LIN&#xff09;物理层收发器&#xff0c;符合 LIN 2.0、LIN 2.1、LIN 2.2、 LIN 2.2A 、 ISO 17987-4:2016 (12V) 和 SAE J2602 标准。主要适用于使用 1kbps 至 20kbps 传输速 率的车载网络。 SIT1024Q 通过 TXDx 引…

【0805作业】Linux中 AB终端通过两根有名管道进行通信聊天(半双工)(全双工)

作业一&#xff1a;打开两个终端&#xff0c;要求实现AB进程对话【两根管道】 打开两个终端&#xff0c;要求实现AB进程对话 A进程先发送一句话给B进程&#xff0c;B进程接收后打印B进程再回复一句话给A进程&#xff0c;A进程接收后打印重复1.2步骤&#xff0c;当收到quit后&am…

桥接模式-java实现

桥接模式 桥接模式的本质&#xff0c;是解决一个基类&#xff0c;存在多个扩展维度的的问题。 比如一个图形基类&#xff0c;从颜色方面扩展和从形状上扩展&#xff0c;我们都需要这两个维度进行扩展&#xff0c;这就意味着&#xff0c;我们需要创建一个图形子类的同时&#x…

【MMU】认识 MMU 及内存映射的流程

MMU&#xff08;Memory Manager Unit&#xff09;&#xff0c;是内存管理单元&#xff0c;负责将虚拟地址转换成物理地址。除此之外&#xff0c;MMU 实现了内存保护&#xff0c;进程无法直接访问物理内存&#xff0c;防止内存数据被随意篡改。 目录 一、内存管理体系结构 1、…

内网穿透:实现公网访问内网群晖NAS的方法

公网远程访问内网群晖NAS 7.X版 【内网穿透】 文章目录 公网远程访问内网群晖NAS 7.X版 【内网穿透】前言1. 在群晖控制面板找到“终端机和SNMP”2. 建立一条连接公网数据隧道3. 获取公网访问内网群晖NAS的数据隧道入口 前言 群晖NAS作为应用较为广泛的小型数据存储中心&#…

SQL92 SQL99 语法 Oracle 、SQL Server 、MySQL 多表连接、Natural 、USING

SQL92 VS SQL 99 语法 92语法 内连接 from table1&#xff0c; table2 where table1.col table2.col 外连接 放在 从表 左连接&#xff1a; from table1&#xff0c; table2 where table1.col table2.col() 右连接&#xff1a; from table1&#xff0c; table2 where table…

自定义注解(Annontation)

目录 1.注解定义 2.元注解定义 3. 自定义注解&#xff08;自定义的注解名称相同的会覆盖原注解&#xff09; 4.Annotation架构&#xff08;元注解参数介绍&#xff09; 1.注解定义 注解是用来将任何的信息或元数据&#xff08;metadata&#xff09;与程序元素&#xff08;类…

苍穹外卖项目解读(四) 微信小程序支付、定时任务、WebSocket

前言 HM新出springboot入门项目《苍穹外卖》&#xff0c;笔者打算写一个系列学习笔记&#xff0c;“苍穹外卖项目解读”&#xff0c;内容主要从HM课程&#xff0c;自己实践&#xff0c;以及踩坑填坑出发&#xff0c;以技术&#xff0c;经验为主&#xff0c;记录学习&#xff0…

深度学习基础知识扫盲

深度学习 监督学习&#xff08;Supervised learning&#xff09;监督学习分类 无监督学习&#xff08;Non-supervised learning&#xff09;无监督学习的算法无监督学习使用场景 术语特征值特征向量特征工程&#xff08;Feature engineering&#xff09;特征缩放Sigmod functio…

大学生创业运营校园跑腿小程序怎么样?

校园跑腿小程序是一种基于移动互联网的服务平台&#xff0c;旨在为大学生提供便捷的跑腿服务。它可以连接大学生用户和需要代办事务的人群&#xff0c;实现多方共赢的局面。接下来&#xff0c;我将从需求背景、市场前景、功能特点等方面进行分析。 首先&#xff0c;校园跑腿小程…

使用mybatis-plus的updateById方法更新一个numeric(1)类型字段,sql成功执行,但是updates为0,更新失败的解决办法

使用mybatis-plus的updateById方法更新一个numeric(1)类型字段&#xff0c;sql成功执行&#xff0c;但是updates为0&#xff0c;更新失败的解决办法&#xff1a; 背景&#xff1a;我有一张表&#xff0c;有个启用禁用功能&#xff0c;没有放在编辑页面一起编辑保存&#xff0c;…

最强自动化测试框架Playwright-操作指南(3)-PO模式

playwright支持PO模式 创建页面对象 class SearchPage:def __init__(self, page):self.page pageself.search_term_input page.get_by_role("searchbox", name"输入搜索词")def navigate(self):self.page.goto("https://bing.com")def searc…

MySQL5.7数据库、Navicat Premium1.6可视化工具安装教程【详细教程】

文章目录 一、MySQL、Navicat、注册机地址二、安装&#xff08;一&#xff09;、MySQL安装&#xff08;二&#xff09;、Navicat Premium安装&#xff08;三&#xff09;、集活Navicat Premium 三、遇到的问题1、Are you sure your navicat has not beenpatched/modified befor…

【高频面试题】微服务篇

文章目录 Spring Cloud1.Spring Cloud 5大组件有哪些&#xff1f;2.服务注册和发现是什么意思&#xff1f;Spring Cloud 如何实现服务注册发现&#xff1f;3.负载均衡如何实现的 ?4.什么是服务雪崩&#xff0c;怎么解决这个问题&#xff1f;5.微服务是怎么监控的 业务相关6.项…

Nginx安装以及LVS-DR集群搭建

Nginx安装 1.环境准备 yum insatall -y make gcc gcc-c pcre-devel #pcre-devel -- pcre库 #安装openssl-devel yum install -y openssl-devel 2.tar安装包 3.解压软件包并创建软连接 tar -xf nginx-1.22.0.tar.gz -C /usr/local/ ln -s /usr/local/nginx-1.22.0/ /usr/local…

数组对象去重的几种方法

场景&#xff1a; let arrObj [{ name: "小红", id: 1 },{ name: "小橙", id: 1 },{ name: "小黄", id: 4 },{ name: "小绿", id: 3 },{ name: "小青", id: 1 },{ name: "小蓝", id: 4 } ]; 方法一&#xff1a;…