Scala

Scala

介绍

Scala是一种多规范的编程语言，它结合了面向对象编程（OOP）和函数式编程（FP）的特征，Scala的名字源于”Scalable language“，意为”可伸缩语言“。2003年开发的，并在JVM（Java虚拟机）上运行的，Scala被设计用于编程简介高效的代码的同时提供强大的表达能力和灵活性。

特点

• 面向对象和函数式编程支持：
  • Scala支持面向对象的编程范式，同时也强调函数式编程，允许开发者以更函数式的方式思考和编写代码，从而更好地处理并发和异步编程等问题。
• 静态类型：
  • Scala是一门静态类型语言，可以在编译时捕获一些错误，提高代码的稳定性和可维护性。
• 表达力强：
  • Scala提供了丰富的语法特性，可以用更少的代码表达更多的概念，从而增强代码的可读性和可理解性。
• 互操作性：
  • Scala可以与Java无缝集成，可以直接调用Java类库和组件，这对于现有的Java开发者来说是一个优势，也使得在已有的Java项目中引入Scala逐步过渡变得容易。
• 并发支持：
  • Scala通过其函数式编程特性，提供了更好的并发编程支持，例如使用不可变数据结构和并行集合来简化多线程编程。

为什么学习

• 丰富的编程范式：
  • 学习Scala可以让你同时了解面向对象和函数式编程的特性，从而能够更灵活地选择适合不同情境的编程方式。
• 并发和多线程编程：
  • Scala在并发编程方面提供了强大的支持，这在处理现代应用中的并发性和异步编程方面非常有用。
• 表达能力：
  • Scala的语法特性允许你以更简洁的代码表达复杂的概念，提高代码的可读性和可维护性。
• JVM平台：
  • Scala运行在Java虚拟机上，因此可以与Java代码互操作，适合在现有的Java项目中引入。Scala可以直接调用Java中的方法，访问Java中的字段，继承java类，实现Java接口。
• 函数式思维：
  • 学习Scala可以培养函数式编程思维，这对于提高编程的抽象能力、模块化能力和问题解决能力都很有帮助。

总之，学习Scala可以让你拥有多规范编程的能力，从而更好的应对复杂的软件开发任务，尤其是在并发编程和大规模的应用开发方面。

数据类型

类型	数据类型
整数类型	byte,short,int,long
浮点数类型	float,double
字符类型	char
布尔类型	boolean
字符串类型	String
数组类型	Array
列表类型	list
元组类型	tuple
集合类型	set
映射类型	map

运算符

类型	运算符
算术运算符	+，-，*，/，%
比较运算符	==，!= , > , < , >= , <=
逻辑运算符	&& , || , !
赋值运算符	= , += , -= , *= , /=
位运算符	& , | , ^ , ~ , << , >>
条件运算符	if-else , match-case
循环运算符	for , while , do-while

案例

scala> "hello scala"
res0: String = hello scala

scala> 1+1
res1: Int = 2

变量，常量

关键字	定义
var	变量
val	常量

创建变量方式

var 变量名称: 数据类型 = 变量值;

例如

# 创建变量count,数据类型为Int类型，初始值为10
scala> var count:Int=10;
count: Int = 10
# 输入count变量，返回变量值
scala> count
res0: Int = 10
# 对count变量重新赋值
scala> count=1;
count: Int = 1

scala> count
res1: Int = 1

创建常量的方式

val 常量名称：数据类型 = 常量值

例如

# 创建常量name,数据类型为String,常量值为zhangsan
scala> val name:String = "zhangsan";
name: String = zhangsan
# 输入name常量，返回常量值
scala> name
res3: String = zhangsan
# 对常量name重新赋值时，编译错误，常量无法重新赋值
scala> name = "lisi";
<console>:12: error: reassignment to val
       name = "lisi";

函数

使用关键字def来定义函数，函数定义语法为：

def 函数名称(参数列表)：返回类型={
	//函数体
	//可以包含多条一句
	//最后一行的表达式作为返回值
}

无参函数

# 定义函数sayHello,Unit:表示无值，等同于Java中的void 
scala> def sayHello():Unit={
     | println("Hello,Scala!");//打印：Hello,Scala!
     | }
sayHello: ()Unit
# 调用函数
scala> sayHello()
Hello,Scala!

有参函数

# 定义函数add,参数为x(Int整数类型),y(Int整数类型),返回类型为Int
scala> def add(x:Int,y:Int):Int={
     | x+y;
     | }
add: (x: Int, y: Int)Int
# 调用函数，传入实参
scala> val result = add(10,10)
result: Int = 20

scala> result
res8: Int = 20

默认参数函数

# 定义函数greet，参数为name（String字符串类型），greeting（String字符串类型，默认值为Hello）
scala> def greet(name:String,greeting:String="Hello"):Unit={
     | println(s"$greeting,$name");//插值语法
     | }
greet: (name: String, greeting: String)Unit

scala> greet("zhangsan");
Hello,zhangsan

scala> greet("lisi","Hi");
Hi,lisi

可变参数函数

# 定义函数sum，参数为number(Int整数类型，*多个值)
scala> def sum(number:Int*):Int = {
     | number.sum; //参数的和
     | }
sum: (number: Int*)Int

scala> println(sum(1,2,3,4,5,6));
21

匿名函数（lambda表达式）

# 定义函数add，参数为x(Int整数类型),y(Int整数类型),返回类型为Int
scala> val add:(Int,Int)=> Int=(x,y)=>x+y
add: (Int, Int) => Int = <function2>

scala> println(add(3,4))
7

if判断

语法

if(布尔表达式){
	//执行条件为true时的代码块
}else{
	//执行条件为false时的代码块
}

例如

scala> val x = 10;
x: Int = 10

scala> if (x>5){
     | println("x大于5");
     | }else{
     | println("x小于5");
     | }
x大于5

for循环

语法

for（变量 <- 初始值 to 结束值）{
	//循环体
}

例如

# 循环从1输出到5
scala> for(i <- 1 to 5){
     | println(i);
     | }
1
2
3
4
5

数组

创建数据的方式

var 数据名称 : Array[数据类型] = new Array[数据类型](数组长度)
var 数组名称 : Array[数据类型] = Array(元素1,元素2......) 
var 数组名称 : Array.ofDim[数据类型](数组长度)

操作数组常用的方式

方法	描述
length	返回数组的长度
head	返回数组的第一个元素
tail	返回数组中除了第一个元素意外的所有元素
isEmpty	判断数组是否为空
contains()	判断数组中是否包含某个元素
forEach()	遍历数组
max	返回数组的最大元素
min	返回数组的最小元素
sum	返回数组的和
distinct	去重
sorted	升序排序
mkString	数组以字符串形式显示

例如

# 第一种创建方式
scala> var arr: Array[String] = new Array[String](3)
arr: Array[String] = Array(null, null, null)
# 数组的长度
scala> arr.length
res0: Int = 3
# 对索引1的元素赋值
scala> arr(1)="zhangsan"
# 查看索引1的元素
scala> arr(1)
res2: String = zhangsan
# 查看索引0的元素
scala> arr(0)
res3: String = null
# 查看数组
scala> arr
res4: Array[String] = Array(null, zhangsan, null)


# 第二种创建方式
scala> var arr1 : Array[Int] = Array(1,2,3,4)
arr1: Array[Int] = Array(1, 2, 3, 4)
# 数组长度
scala> arr1.length
res6: Int = 4
# 索引处的元素值
scala> arr1(2)
res7: Int = 3

List列表

在Scala中，List是一个常用的数据结构，用于存储有序的元素序列。List是不可变的，意味着一旦创建就不能修改，但可以通过创建新的List来进行操作和转换

语法

val 列表名称:List[列表类型] = List(列表元素);

例如

scala> val list:List[String] = List("zhangsan","lisi","wangwu");
list: List[String] = List(zhangsan, lisi, wangwu)

scala> val ageList:List[Int] = List(18,29,38,10);
ageList: List[Int] = List(18,29,38,10)

列表常用方法

方法	描述
head	返回列表的第一个元素
tail	返回除第一个元素之外的所有元素
last	返回列表的最后一个元素
init	返回除最后一个元素之外的所有元素
::或+:	将元素添加到列表的开头，返回新列表
:+或 :::	将元素添加到列表的末尾，返回新列表
++	将两个列表连接在一起，返回新列表
filter	根据给定的条件过滤列表中的元素，返回符合条件的新列表
drop	删除前n个元素，返回新列表
dropWhile	删除满足指定条件的前缀元素，返回新列表
dropRight	删除后n个元素，返回新列表
dropRightWhile	删除满足指定条件的后缀元素，返回新列表
updated	通过下标更新列表中的元素，返回新列表
patch	替换列表中的一部分元素，返回新列表
isEmpty	判断列表是否为空
contains	判断列表是否包含指定的元素
exists	判断列表中是否存在满足指定条件的元素
forall	判断列表中的所有元素是否都满足指定条件
foreach	对列表的每个元素应用指定的函数
map	将列表中的每个元素通过指定的函数进行转换，返回新列表
filter	根据指定条件过滤列表中的元素，返回新列表
foldLeft或reduceLeft	从左到右对列表的元素进行累积计算
foldRight或reduceRight	从右到左对列表的元素进行累积计算

案例

定义数组

scala> val ageList:List[Int] = List(18,28,39,40,12,32,21);
ageList: List[Int] = List(18, 28, 39, 40, 12, 32, 21)

• 访问元素

# 获取第一个元素
scala> ageList.head
res7: Int = 18

# 获取除第一个元素外的所有元素
scala> ageList.tail
res8: List[Int] = List(28, 39, 40, 12, 32, 21)

# 获取最后一个元素
scala> ageList.last
res9: Int = 21

# 获取除最后一个元素外的所有元素
scala> ageList.init
res10: List[Int] = List(18, 28, 39, 40, 12, 32)

• 添加元素

# 在列表开头添加元素
scala> 80::ageList
res11: List[Int] = List(80, 18, 28, 39, 40, 12, 32, 21)

# 在列表末尾添加元素
scala> ageList :+ 90
res12: List[Int] = List(18, 28, 39, 40, 12, 32, 21, 90)

# 连接两个列表
scala> ageList ++ List(70,60)
res13: List[Int] = List(18, 28, 39, 40, 12, 32, 21, 70, 60)

• 修改元素

# 更新0索引位置的元素为43
scala> ageList.updated(0,43)
res15: List[Int] = List(43, 28, 39, 40, 12, 32, 21)

# 替换一部分元素，将索引1，2位置的值替换
scala> ageList.patch(1,List(31,42),2)
res16: List[Int] = List(18, 31, 42, 40, 12, 32, 21)

• 遍历列表

# 对列表的每个元素应用函数进行遍历打印
scala> ageList.foreach(println);
18
28
39
40
12
32
21

# 将列表中的每个元素平方
scala> ageList.map(x => x * x)
res19: List[Int] = List(324, 784, 1521, 1600, 144, 1024, 441)

# 过滤出偶数元素
scala> ageList.filter(_%2 == 0)
res20: List[Int] = List(18, 28, 40, 12, 32)

# 计算列表元素的累加和
scala> ageList.foldLeft(0)(_+_)
res21: Int = 190

• 判断列表

# 判断列表是否为空
scala> ageList.isEmpty
res22: Boolean = false

# 判断列表是否包含40
scala> ageList.contains(40)
res25: Boolean = true

# 判断列表是否存在偶数元素
scala> ageList.filter(_%2==0)
res26: List[Int] = List(18, 28, 40, 12, 32)

# 判断列表中的所有元素是否都为正数
scala> ageList.forall(_>0)
res2: Boolean = true

• 删除元素

# 根据条件过滤元素
scala> ageList.filter(_%2 == 0)
res3: List[Int] = List(18, 28, 40, 12, 32, 70, 60)

# 删除前两个元素
scala> ageList.drop(2)
res4: List[Int] = List(39, 40, 12, 32, 21, 70, 60)

# 删除小于30的前缀元素
scala> ageList.dropWhile(_<30)
res6: List[Int] = List(39, 40, 12, 32, 21, 70, 60)

# 删除后两个元素
scala> ageList.dropRight(2)
res7: List[Int] = List(18, 28, 39, 40, 12, 32, 21)

Set集合

在Scala中，集合（Set）是一个用于存储不重复元素的无序集合

语法

# Scala默认创建的时不可变集合
val 集合名称: Set[数据类型] = Set(集合元素)

# 创建一个可变集合
import scala.collection.mutable.Set
val 集合名称: Set[数据类型] = Set(集合元素)

# 创建一个不可变集合
import scala.collection.immutable.Set
val 集合名称: Set[数据类型] = Set(集合元素)

集合常用的方法

方法	描述
add	向集合中添加元素，并返回一个布尔值表示是否成功添加
remove	从集合中移除指定元素，并返回一个布尔值表示是否成功移除
contains	判断集合中是否包含指定元素
foreach	对集合中的每个元素应用指定的函数
map	将集合中的每个元素通过指定的函数进行转换，返回新的集合
filter	根据指定条件过滤集合中的元素，返回符合条件的新集合

例如

定义集合

# 定义为可变
scala> import scala.collection.mutable.Set;
import scala.collection.mutable.Set

scala> val nameSet:Set[String] = Set("张三","李四","王五")
nameSet: scala.collection.mutable.Set[String] = Set(李四, 张三, 王五)

• 添加元素

scala> nameSet.add("赵六")
res10: Boolean = true

scala> nameSet
res11: scala.collection.mutable.Set[String] = Set(李四, 张三, 王五, 赵六)

scala> nameSet+"老王"
res12: scala.collection.mutable.Set[String] = Set(老王, 李四, 张三, 王五, 赵六)

• 删除元素

scala> nameSet.remove("张三")
res14: Boolean = true

scala> nameSet
res15: scala.collection.mutable.Set[String] = Set(李四, 王五, 赵六)

scala> nameSet - "李四"
res16: scala.collection.mutable.Set[String] = Set(王五, 赵六)

• 判断集合是否包含某个元素

scala> nameSet.contains("赵六")
res17: Boolean = true

• 遍历集合

scala> nameSet.foreach(println)
李四
王五
赵六

Map映射

在Scala中，映射（Map）是一种键值对的集合，其中每个键都唯一且与一个值相关联

语法

# Scala默认创建的时不可变映射
val 映射名称:Map[键的数据类型，值的数据类型] = Map(键->值)

# 创建可变映射
import scala.collection.mutable
val 映射名称:Map[键的数据类型，值的数据类型] = Map(键->值)

常用的方法

方法	描述
keys	返回所有键的集合
values	返回所有值的集合
contains	检查是否包含键的键值对
exists	检查是否包含值的键值对
foreach	迭代Map
toList	转换为列表
++	合并Map
updated	更新Map中的值
-	删除键值对

例如

定义映射

scala> import scala.collection.mutable
import scala.collection.mutable

scala> val nameMap:Map[String,Int] = Map("张三"->28,"李四"->29,"王五"->30)
nameMap: Map[String,Int] = Map(张三 -> 28, 李四 -> 29, 王五 -> 30)

• 获取所有键或所有值

scala> nameMap.keys
res20: Iterable[String] = Set(张三, 李四, 王五)

scala> nameMap.values
res22: Iterable[Int] = MapLike(28, 29, 30)

• 检查是否包含某个建或值

scala> nameMap.contains("张三")
res23: Boolean = true

scala> nameMap.values.exists(_==28)
res24: Boolean = true

• 迭代Map

scala> nameMap.foreach{
     | case (key,value) => println(s"Key:$key,Value:$value")
     | }
Key:张三,Value:28
Key:李四,Value:29
Key:王五,Value:30

• 转换为列表

scala> nameMap.toList
res27: List[(String, Int)] = List((张三,28), (李四,29), (王五,30))

• 更新Map中的值

scala> nameMap.updated("王五",20)
res28: scala.collection.immutable.Map[String,Int] = Map(张三 -> 28, 李四 -> 29, 王五 -> 20)

• 删除键值对

scala> nameMap-"王五"
res29: scala.collection.immutable.Map[String,Int] = Map(张三 -> 28, 李四 -> 29)

元组

在Scala中，元组（Tuple）时一种类似于列表的结构，是一种不同类型的值的集合

语法

val 元组名称 = (元组元素);
// Tuple3中的3元组即元组中包含了3个元素，若定义的时N元组，写成Tuplen
val 元组名称 = new Tuple3(元素元素);

例如

scala> val tuple = (1,"hello",true);
tuple: (Int, String, Boolean) = (1,hello,true)

scala> val tuple1 = new Tuple3(2,"Hi",3.14)
tuple1: (Int, String, Double) = (2,Hi,3.14)

• 获取元素

_N：通过索引获取元素的第N个元素，索引从1开始

scala> tuple._1
res30: Int = 1

scala> tuple._2
res31: String = hello

scala> tuple._3
res32: Boolean = true

• 转换为列表

scala> tuple.productIterator.toList
res33: List[Any] = List(1, hello, true)

• 合并元组

scala> tuple ++ tuple1
scala> Tuple.concat(tuple,tuple1)

关键字

• Unit ：表示无值，等同于Java中的void

• abstract：抽象类、抽象方法

• case：模式匹配中的一个分支

• class：类定义

• def：方法/函数定义

• do：do-while循环的开始

• else：if条件的分支

• extends：类的继承

• false：布尔值false

• final：不可继承、重写或修改的修饰符

• for：for循环

• if：条件语句

• implicit：隐式转换

• import：导入其他包或类

• match：模式匹配

• new：创建对象

• null：空值

• object：单例对象或伴生对象

• override：重写父类或特质中的方法

• package：包定义

• private：私有访问权限

• protected：受保护的访问权限

• return：返回值

• sealed：密封类

• super：父类引用

• this：当前类或对象的引用

• throw：抛出异常

• trait：特质定义

• true：布尔值true

• try：异常处理

• type：类型别名

• val：不可变变量声明

• var：可变变量声明

• while：while循环

• with：混入特质

• yield：生成器

idea关联Scala

创建maven项目

配置maven仓库

添加Scala插件

添加相关依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>com.singroupId>
    <artifactId>Demo-scalaartifactId>
    <version>1.0-SNAPSHOTversion>

    <dependencies>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13.2version>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-sql_2.12artifactId>
            <version>3.3.1version>
        dependency>
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-hive_2.11artifactId>
            <version>2.1.1version>
        dependency>
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-graphx_2.11artifactId>
            <version>2.1.1version>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.47version>
        dependency>

    dependencies>

project>

添加scala的SDK

创建Scala文件

案例

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, World!")
  }

}

阶乘

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object Factorial {
  def factorial(n: Int): Int = {
    if (n == 0) 1
    else n * factorial(n - 1)
  }

  def main(args: Array[String]): Unit = {
    val result = factorial(5)
    println(result) // 输出120
  }

}

素数

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object IsPrime {
  def isPrime(num: Int): Boolean = {
    if (num <= 1) false
    else if (num == 2) true
    else !(2 to (Math.sqrt(num).toInt + 1)).exists(x => num % x == 0)
  }

  def main(args: Array[String]): Unit = {
    println(isPrime(7)) // 输出true
    println(isPrime(15)) // 输出false
  }


}

列表中最大的数

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object ListMax {
  def main(args: Array[String]): Unit = {
    val numbers = List(2, 8, 1, 6, 10, 4)
    val maxNumber = numbers.max
    println(maxNumber) // 输出10
  }
}

计算列表中所有的和

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object HelloWorld {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5)
    val sum = numbers.sum

    println(sum) // 输出15
  }
 
}

遍历列表

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object ForEachList {
  def main(args: Array[String]): Unit = {
    val fruits = List("apple", "banana", "orange")

    fruits.foreach(println)
    // 输出:
    // apple
    // banana
    // orange
  }
}

判断天气

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object IfWeather {
  def main(args: Array[String]): Unit = {
    println(weatherType("sunny")) // 输出It's a sunny day!
    println(weatherType("snowy")) // 输出Unknown weather type.
  }
  def weatherType(weather: String): String = weather match {
    case "sunny" => "It's a sunny day!"
    case "cloudy" => "It's a cloudy day."
    case "rainy" => "Don't forget your umbrella!"
    case _ => "Unknown weather type."
  }
}

九九乘法表

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object Multiplication {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9; j <- 1 to i) {
      print(s"$j * $i = ${i * j}\t")
      if (i == j) println()
    }
  }
}