Scala入门基础

最新推荐文章于 2024-07-22 09:50:02 发布

2401_84185106

最新推荐文章于 2024-07-22 09:50:02 发布

阅读量697

点赞数 10

分类专栏：程序员文章标签： scala python 开发语言

本文链接：https://blog.csdn.net/2401_84185106/article/details/138331953

版权

程序员专栏收录该内容

119 篇文章 1 订阅

订阅专栏

本文详细介绍了Scala中的关键数据结构如ArrayBuffer、可变数组、函数定义与调用、不同类型的函数（普通、匿名、高阶和参数变长）、控制结构（if、while、for）、元组、列表(List)、向量(Vector)、集合(Set)和映射(Map)，以及函数组合器(map)的应用。

摘要由CSDN通过智能技术生成

val arrbuf:ArrayBuffer[type]=new ArrayBuffertype

import scala.collection.mutable.ArrayBuffer
val arrbuf:ArrayBuffer[Int]=new ArrayBuffer[Int]()

使用+=操作符，可以添加一个或多个元素。

使用++=操作符，可以添加其它集合中的所有元素。

5 函数

5.1 函数定义和调用

定义函数

def functionName (参数列表) : [return type] = {}

例如，定义一个函数add，返回两个整型数据之和。

def add (x:Int, y:Int):Int = {x+y}

此处两种函数作用效果一样，上面函数直接返回相加的结果，下面函数通过定义中间量sum计算两个整型的和并返回。

:paste
def add (x:Int, y:Int):Int = {
    var sum = 0
    sum = x+y
    return sum
}

函数的定义由def关键字开始，add为函数名，紧接着是可选的参数列表需要指定参数类型，之后冒号“:”后接着函数的返回类型，一个等号“=”，最后“{}”部分为函数的方法体。

如果函数无返回值，则函数的返回类型为Unit。

调用函数

函数一旦定义，可通过函数名调用。

functionName(参数列表)

函数可以赋值给变量，注意，赋值给变量需要在函数后面加空格和下划线。

5.2 函数种类

5.2.1 普通函数

函数一旦定义完成，可通过函数名调用函数。

:paste
def add (x:Int, y:Int):Int = {
    var sum = 0
    sum = x+y
    return sum
}

5.2.2 匿名函数

匿名函数即在定义函数时不给出函数名，经常成为“Lambda表达式”。匿名函数使用箭头“=>”定义，箭头左边是参数列表，箭头右边是表达式，表达式将产生函数的结果。

(参数列表) => 表达式

调用匿名函数可以将函数赋值给一个常量或变量，通过常量名或变量名调用该函数。

val addInt = (a:Int, b:Int)=>a+b

如果函数中的每个参数在函数中最多只出现一次，则可以用占位符“_“代替参数，与上个示例函数相同。

5.2.3 高阶函数

高阶函数即操作其它函数的函数。高阶函数可以使用函数作为参数，也可以使用函数作为输出结果。

高阶函数经常将只需要执行一次的函数定义为匿名函数作为参数。

val f = (a:Int, b:Int)=>a+b
def addInt(f:Int, c:Int):Int={f+c}
addInt(f(2,3),4)

上函数将匿名函数单独定义调用，下函数在addInt函数内直接定义匿名函数f复用定义相加功能，实现三个数相加的功能。值得注意的是，下函数在函数中定义匿名函数f时只是进行了函数定义，并没有写明代码功能，再进行调用时，可以定义其它运算功能复用。

:paste
def addInt(a:Int, b:Int, c:Int, f:(Int, Int)=>Int):Int = {
    return f(a,b)+c
}
val result = addInt(3,4,5,(x,y)=>{x+y})

5.2.4 参数变长函数

有时需要将函数定义为参数个数可变的形式，此时可使用变长参数定义函数。

例如，定义一个函数sum传入int类型的数据列表sum，通过for循环遍历列表nums进行累加操作。

:paste
def sum(nums:Int*):Int = {
    var res = 0
    for (num<-nums) {
        res += num
    }
    return res
}

6 控制结构

6.1 if判断

if (布尔表达式1) {

// 若布尔表达式1为true 则执行该语句块

}else if (布尔表达式2) {

// 若布尔表达式2为true 则执行该语句块

}else {

// 若以上条件都为false 执行该语句块

}

例如，通过if循环判断i的大小区间并对各区间结果进行输出。

var i=5
:paste
if (i<5) {
    println("i小于5")
} else if (i>5) {
    println("i大于5")
} else {
    println("i等于5")
}

6.2 循环

6.2.1 while循环

while先判断后执行，do while先执行后判断。

当不满足循环条件时，while循环一次都不会执行，do while循环至少执行一次。

while (表达式) {

循环体

}

do {

循环体

} while (表达式)

var a=21
while (a<=20) {
    println(a)
    a+=1
}
var b=21
do {
    println(b)
    b+=1
} while (b<=20)

6.2.2 for循环

for (变量<-表达式) {

语句块

}

其中”变量<-表达式“被称为”生成器“。

to遍历方式，前后闭合

var a=0
for (a<-1 to 5) {
    println("Value of a:"+a)
}

until遍历方式，前闭合后开

var a=0
for (a<-1 until 5) {
    println("Value of a:"+a)
}

遍历数组列表

var a=0
val numArray=Array(1,2,3,5)
for (a<-numArray) {
    println("Value of a:"+a)
}

for循环中使用if判断语句，循环守卫。等效for循环嵌套if判断。

var a=0
val numArray=Array(1,2,3,4,6,8,9)
for (a<-numArray if a!=3 if a<8) {
    println("Value of a:"+a)
}

var a=0
val numArray=Array(1,2,3,4,6,8,9)
for (a<-numArray) {
    if (a!=3 && a<8) {
        println("Value of a:"+a)
    }
}

for推导式，迭代原数组列表构造新数组列表。

for { 子句 } yield { 变量或表达式 }

var a=0
val numArray=Array(1,2,3,4,6,8,9)
var restVal=for {a<-numArray if a!=3 if a<8} yield a
for (a<-restVal) {println("Value of a:"+a)}

6.3 循环控制

为了提前终止整个循环或跳到一下个循环，Scala没有break和continue关键字。

Scala提供了一个Breaks类（位于包scala.util.control）。

Breaks类有两个方法用于对循环结构进行控制，即breakable和break。

breakable {

…

if ( … ) break

…

}

import scala.util.control.Breaks._

for遍历在breakable方法体中

val array=Array(1,3,10,5,4)
breakable {
    for (i<-array) {
        if (i>5) break
        println(i)
    }
}

breakable方法在for循环方法内

val array=Array(1,3,10,5,4)
for (i<-array) {
    breakable{
        if (i>5) break
        println(i)
    }
}

7 Tuple（元组）

元组与数组列表一样不可变，但与数组列表不同的是元组可以包含不同类型的元素。

元组的索引从1开始（_1、_2），最大长度支持22。

7.1初始化元组

初始化方式1：

var tup=()

初始化方式2：

new Tuple后直接加数字表示数组列表的长度。

var tup=new TupleInt()

7.2 访问元组

tup._1

7.3 迭代元组

tup.productIterator.foreach(i=>{println("Value:"+i)})

7.4 元组转字符串

使用Tuple.toString()方法将元组的所有元素组合成一个字符串。

8 List（列表）

8.1 初始化列表

不同于Java的java.util.List，Scala的List一旦被定义就不能改变值，因此声明List时必须初始化。

初始化方式1：

val listName:List[type] = List(ele1,ele2,…)

val list:List[String]=List("baidu","google","edge")
val list1:List[Int]=List(1,2,3)
val list2:List[List[Int]]=List(List(1,2,3),List(4,5,6))

初始化方式2：

val listName:List[type] = ele1::ele2::…::Nil

其中构造列表的两个基本单位时Nil和::，Nil也可以表示为一个空列表，::称为中缀操作符，表示列表从前端拓展，遵循右结合。

val list:List[String]="baidu"::"google"::"edge"::Nil
val list1:List[Int]=1::2::3::Nil
val list2:List[List[Int]]=(1::2::3::Nil)::(4::5::6::Nil)

8.2 常用方法

连接列表可以使用 ::: 运算符或List.::😦)方法或List.concat()方法连接两个或多个列表。

::: 运算符和List.::😦)方法的结果是不同的。

:::运算符在列表后添加，List.::😦) 方法在列表前添加。

val site1 = List("google","baidu","edge")
val site2 = List("taobao","facebook")

val site3 = site1:::site2
val site4 = site1.:::(site2)
val site5 = List.concat(site1,site2)

8.3 可变列表

初始化ListBuffer列表：

创建可变列表需要导入包 import scala.collection.mutable.ListBuffer

val list:ListBuffer[type]=new ListBuffertype

import scala.collection.mutable.ListBuffer
val list:ListBuffer[Int]=new ListBuffer[Int]()

使用+=操作符或append 方法，可以添加一个或多个元素。

使用++=操作符可以添加其它集合中的所有元素。

toList 方法转换为List

toBuffer 方法转换为可变数组

list.-= 删除指定值

remove 方法按照索引删除

listBuffer.-=("baidu")
listBuffer.remove(0,2)

9 Vector（向量）

向量类似动态数组的功能

val vectorName:Vector[Type] = Vector(n1, n2, ,…)

访问向量

val vector1:Vector[Int]=Vector(1,2,3)
vector1(0)

连接向量

可以使用 +: 或 :+ 连接向量和元素

:和+前后的位置根据vector的位置来定

val vector1:Vector[Int]=Vector(1,2,3)
val vector2:Vector[Int]=4+:5+:vector1
val vector3:Vector[Int]=vector1:+4

10 Set（集合）

Set是没有重复对象的集合，所有元素都是唯一的。

Scala集合分为可变集合和不可变集合。

默认使用不可变集合，可变集合需要导入包 import scala.collection.mutable.Set

10.1 初始化Set

val setName:Set[type] = Set(ele1, ele2, …)

import scala.collection.mutable.Set
val set:Set[Int] = Set(1,2,3)

10.2 Set操作

Set的方法与列表中同类方法的用法相同，合并列表使用“:::”或concat方法，而合并两个集合使用“++”方法。

val set1:Set[Int] = Set(4,5,6)
val set2:Set[Int] = Set(4,5,8)
set1.&(set2)
set1.intersect(set2)

+= 或 add添加元素

-= 或 remove移除指定元素

11 Map（映射）

Map是一种可迭代的键值对结构，所有的值都可以通过建来获取。

键都是唯一的，但值可以不唯一。

同样，Scala映射分为可变映射和不可变映射。

默认使用不可变映射，可变映射需要导入包 import scala.collection.mutable.Map

11.1 初始化

val MapName:Map[keyType, valueType]=Map(key1->value1, key2->value2, …)

val map:Map[String, Int]=Map("a"->1, "b"->2, "c"->3)

11.2 Map操作

只有可变集合才能添加元素，使用+=添加元素。

Map映射与Set集合操作函数用法相同，可以使用++运算符或Map.++()方法连接两个Map，Map合并时会移除重复的key。

12 函数组合器

Scala为各种数据结构提供了很多函数组合器，运用函数组合器的操作会在集合中的每个元素上分别应用一个函数，即组合器的参数都是一个函数。

12.1 map

map是指通过一个函数重复计算列表中的所有元素，并返回一个相同数量元素的新列表。

例如，声明一个整型列表，使用map对列表num中的每个元素进行平方计算。

val num:List[Int] = List(1,2,3,4,5)
num.map(x=>x*x)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取