scala基础

## scala基础

### 函数

格式：

```scala
def  函数名(参数列表) : [返回类型] = {
    函数体;
}
```

示例：

```scala
def sum(value1:Int, value2:Int):Int={
    value1+value2;
}
println(sum(2,3)) // --> 5;
```

注意：

- scala的函数返回参数时，只要确保函数体的最后一条命令返回的值与函数定义的返回值相同即可正常返回。

### 匿名函数

格式：

```SCALA
(参数)=>函数体;
```

示例：

```scala
val add=(x:Int)=>x+1;
println(add(10)); // --> 11
```

### 条件语句

格式：

```scala
if (布尔表达式){
    代码块
}
```

```scala
if (布尔表达式){
    代码块
}else{
    代码块
}
// 三
```

```scala
if (布尔表达式1){
    代码块
}else if(布尔表达式2){
    代码块
}else if(布尔表达式3){
    代码块
}else{
    代码块
}
```

示例：

```scala
var a:Int=10;
if(a==10){
    println("a等于10");
} // --> a等于10
```

```scala
var a:Int=10;
if(a<10){
    println("a小于10");
}else{
    println("a不小于10");
} // --> a不小于10
```

```scala
var a:Int=10;
if(a<10){
    println("a小于10");
}else if(a==10){
    println("a等于10");
}else{
    println("a不小于10");
} // --> a等于10
```

### 循环

#### while

格式：

```scala
while(条件表达式){
    循环体
}
```

示例：

```scala
var num:Int=0;
while(num<=10){
    num=num+1;
}
println(num); // --> 11;
```

#### for

格式：

```scala
for(变量<-集合;过滤条件){
    循环体;
}
```

示例：

```scala
for(num:Int<-1 to 10;if num%2!=1){
    println(num);
} // --> 2 4 6 8 10
```

注意：

1. n to m 表示从n到m的数组（包含n和m）示例：1 to 4就是(1, 2, 3, 4)
2. for循环的过滤条件要用if做操作，不能直接写个布尔表达式
3. for循环的多重循环嵌套不同于其他语言，只需要在过滤条件里再写一个循环条件，示例：```for(num:Int<-1 to 10;js:Int<-1 to 10)```

#### do…while

格式：

```scala
do{
    循环体;
}while(布尔表达式)
```

示例：

```scala
var num:Int = 10;
do{
    num+=1;
}while(num<=10);
println(num) // --> 11
```

#### 跳出/中断循环

scala本身是没有跳出循环或者中断循环的方法的。

因此如果要跳出或者中断循环只能先导入一个包，即:```scala.util.control._```

格式：

```scala
import scala.util.control._;
var loop = new Breaks;
for(变量<-集合;过滤条件){
    循环体;
    loop.break;
}
```

示例：

```scala
import scala.util.controll._;
var loop = new Breaks;
for(num:Int<-1 to 10){
    println(num);
    loop.break;
} // --> 1
```

### 数组(Array)

#### 创建

格式：

```scala
var 变量名:Array[数组类型] = new Array[数组类型](数组长度)
```

```scala
var 变量名=Array(元素列表)
```

示例：

```scala
var age:Array[Int] = new Array[Int](3)
```

```scala
var age = Array(1,2,3)
```

#### 设置值

格式：

```scala
数组名(下标参数)=元素
```

示例：

```scala
var age:Array[Int] = new Array[Int](3)
age(0)=1;
age(1)=2;
age(2)=3;
```

#### 获取值

格式：

```scala
数组名(下标参数);
```

示例：

```scala
var age = Array(1,2,3)
println(age(1)) // --> 2
```

#### 常用方法

注意：

- concat()方法的使用需要导入包```Array._```

#### 注意

- scala默认创建的是不可变数组，创建可变数组需要导入包```scala.collection.mutable.ArrayBuffer```

### 列表(List)

#### 创建

scala构造列表还可以使用::加上Nil两个符号进行操作。

| 符号 |                  描述                  |
| :--: | :------------------------------------: |
| Nil  |               代表空列表               |
|  ::  | 中缀操作符，表示从前端扩展，遵循右结合 |

格式：

```scala
val 常量名:List[列表类型] = List(元素列表)
```

```scala
val 常量名:List[列表类型] = 元素1::元素2::Nil
```

示例：

```scala
val age:List[Int] = List(1, 2, 3, 4)
```

#### 获取值

格式：

```scala
数组名(下标参数);
```

示例：

```scala
val age = 1::2::3::Nil
println(age(1)) // --> 2
```

#### 常用方法

#### 注意

1. 列表只能赋值给常量。
2. 列表构造以后就无法修改元素和元素的顺序。即，无法增删改。
3. 想给列表添加新元素可以通过合并列表的方法创建新列表。

### 集合(Set)

集合的元素是唯一且不可变的。

#### 创建

格式：

```scala
val 常量名:Set[集合类型]=Set(元素列表)
```

示例：

```scala
val age:Set[Int] = Set(1,2,3,4,5)
```

#### 添加值

注意：添加值只能使用可变型map，即导入包```scala.collection.mutable.Set```

格式：

```scala
集合名+=元素
```

```scala
集合名+=(元素列表)
```

```scala
集合名++=集合
```

示例：

```scala
val age:Set[Int] = Set(1,2,3,4,5)
age+=10
```

```scala
val age:Set[Int] = Set(1,2,3,4,5)
age+=(11,12,13,14)
```

```scala
va:Set[Int] = Set(1,2,3,4,5)
val value:Set[Int] = Set(11,12,13,14,15)
age++=value
```

#### 获取值

格式：

```scala
集合名(下标参数)
```

示例：

```scala
val age:Set[Int] = Set(1,2,3,4,5)
println(age(2)) 
```

#### 常用方法

#### 注意

* scala默认创建的是不可变集合，若是创建可变集合，需要导入包```scala.collection.mutable.Set```

### 映射(Map)

映射是一种可迭代的键值对结构，所有的值都要通过键来获取，并且在map中键是唯一的。

#### 创建

格式：

```scala
val 常量名:Map[键类型, 值类型]=Map(键->值)
```

示例：

```scala
val actor:Map[String,Int] = Map("kirito"->16,"asina"->15,"alen"->14)
```

#### 修改值

注意：修改值只能使用可变型map，即导入包```scala.collection.mutable.Map```

格式：

```scala
映射名(键)=值
```

示例：

```scala
val actor:Map[String,Int] = Map("kirito"->16,"asina"->15,"alen"->14)
actor("asina")=10
```

#### 添加键值对

注意：添加值只能使用可变型map，即导入包```scala.collection.mutable.Map```

格式：

```scala
映射名+=(键->值)
```

示例：

```scala
val actor:Map[String,Int] = Map("kirito"->16,"asina"->15,"alen"->14)
actor+=("sitate"->20)
```

#### 注意

* scala默认创建的是不可变映射，若是创建可变映射，需要导入包```scala.collection.mutable.Map```

### 元祖

用()括号括起来的，和列表类似的结构。元祖可以包含不同类型的数据。

#### 创建

格式：

```scala
val 常量名=new Tuplen(元素列表)
```

其中Tuplen的n这个地方表示的是改元祖的长度，只能为数值

```scala
val 常量名=(元素列表)
```

示例：

```scala
val actor = new Tuple4(1, 2, 3, "kirito")
```

```scala
val actor = (1, 2, 3, "kirito")
```

#### 获取值

注意：元祖取值的下标是从1开始的

格式：

```scala
元祖名._下标参数
```

示例：

```scala
val actor = new Tuple4(1, 2, 3, "kirito")
println(actor._2) // --> 2
```

### scala的类(class)

#### 创建

格式：

```scala
class 类名(父类参数列表, 参数列表) extends 父类名(父类参数列表){
    类属性列表
    def 方法名(方法参数列表):返回类型={
        方法体
    }
}
```

示例：

```scala
class character(hpx:Int, spx:Int){
   	var hp:Int = hpx;
    var sp:Int = spx;
}
class Actor(hpx:Int, spx:Int, atkx:Int) extends character(hpx, spx){
    var atk:Int = atkx;
    def Attatk(ehp:Int):Int={
    	ehp - this.atk
    }
}
```

#### 继承

1. 在scala中只允许继承一个父类
2. 在scala中使用extends这个关键字来进行继承
3. 子类继承父类已经实现的方法使用关键字override
4. 子类继承父类中没有实现的方法则不需要使用关键字override

格式：

```scala
class 父类名(父类参数列表, 参数列表){
    类属性列表
    def 方法名1(方法参数列表):返回类型={
        方法体
    }
    def 方法名2:返回类型
}
class 类名(父类参数列表, 参数列表) extends 父类名(父类参数列表){
    类属性列表
    override
    def 方法名1(方法参数列表):返回类型={
        方法体
    }
    def 方法名2(方法参数列表):返回类型={
        方法体
    }
}
```

示例：

```scala
abstract class character(hpx:Int, spx:Int){
   	var hp:Int = hpx;
    var sp:Int = spx;
    def hunger(num:Int):Int ={
        this.hp-num
    }
    def Attatk(ehp:Int):Int
}
class Actor(hpx:Int, spx:Int, atkx:Int) extends character(hpx, spx){
    var atk:Int = atkx;
    override
    def hunger(num:Int):Int ={
        this.hp-num-10
    }
    def Attatk(ehp:Int):Int={
    	ehp - this.atk
    }
}
```

#### 单例模式(object)

在scala中没有static关键字，因此scala中不存在静态成员。但是在scala中可以使用object来实现单例模式。

1. 是单例的

2. 不需要通过new来创建对象，直接通过类名创建

3. 没有有参的主构造器，但是有主构造代码块（不包含在任何方法中的代码，就是object的主构造代码块）

4. 通常用于封装一些常量、工具类、枚举和隐式转换函数

5. 主构造代码块只会执行一次，因为是单例的

格式：

```scala
object 类名{
    类属性列表
    def 类方法名(参数列表):返回类型={}
}
```

示例：

```scala
object Enemy{
    var atk =10
    def Attatk(ehp:Int):Int = {
        ehp-this.atk
    }
    println(Enemy.Attatk(1100))
}
Enemy // --> 1090
```

### 匹配模式

#### 变量匹配

格式：

```scala
变量名 match{
    case 选项 => 返回值
}
```

示例：

```scala
val a =List(true,false)
for(b:Boolean<- a){
	b match{
        case true =>println("好")
        case false =>println("废物")
        case _ =>println("差")
    }
}
```

#### 列表匹配

在match中”_“表示占一位，”\_*“表示占任意位。

格式：

```scala
列表名 match{
    case 列表类型(参数,_,*) => 返回值
}
```

示例：

```scala
val a = List(1,2,3,4,5)
a match{
    case List(1,_,_) => println("yi")
    case List(_,2,_) => println("er")
    case List(1,_,_,_,_) => println("san")
    case List(_,2,_,_*) => println("si")
    case _ => println("tc")
} // --> san
```

#### 样例类

case关键值定义的类被称为样例类。样例类是一个特殊的类，经过优化用于模式匹配。

格式：

```scala
case class 类名(参数列表:参数类型)
```

示例：

```scala
case class Actor(name:String, age:Int)
var a = new Actor("kirito",12)
var b = new Actor("asina",15)
var c = new Actor("alen",19)
for(actor:Actor<-List(a,b,c)){
    actor match{
        case Actor("kirito",12) => println("I'am kirito")
        case Actor("asina",15) => println("I'am asina")
        case _ => println("I'am actor")
    }
}
 // --> I'am kirito
 // --> I'am asina
 // --> I'am actor
```

### 读写文件

#### 读取

用户可以通过scala的Source类来读取文件内容。即导入包```scala.io.Source```

示例：

```scala
import scala.io.Source
Source.fromFile("文件地址").foreach(print)
```

格式：

```scala
import scala.io.Source
Source.fromFile("C:/Users/honor/Desktop/cs.txt").foreach(print)
```

![读取文件](https://www.yidaimingjvn.xyz/usr/uploads/2022/04/3704242815.png)

####  写入

scala不提供任何特殊文件写入能力，进行文件的写操作的时候使用java的I/O类的PrintWriter方法。

使用前要导入包```java.io._```

格式：

```scala
import java.io._
val 常量名 = new PrintWriter(new File("文件路径"))
常量名.write("写入内容")
常量名.close
```

示例：

```scala
import java.io._
val a = new PrintWriter(new File("C:/Users/honor/Desktop/cs.txt"))
a.write("写入内容")
a.close
```

![写入文件](https://www.yidaimingjvn.xyz/usr/uploads/2022/04/1168940930.png)

#### 键入数据

用户可以使用Console.readLine来接收用户键盘输入的指令。

格式：

```scala
val 常量名=Console.readLine
```

示例：

```scala
val line = Console.readLine // <-- wsys
println(line) // --> wsys
```

scala基础

sparkRDD编程

c语言基本数据类型之实数型

一代明君

Comments | NOTHING