scala基础

最后更新时间：2022年04月18日

scala基础

函数

格式：

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

示例：

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

注意：

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

匿名函数

格式：

(参数)=>函数体;

示例：

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

条件语句

格式：

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

示例：

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

循环

while

格式：

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

示例：

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

for

格式：

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

示例：

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

格式：

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

示例：

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

跳出/中断循环

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

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

格式：

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

示例：

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

数组(Array)

创建

格式：

var 变量名:Array[数组类型] = new Array[数组类型](数组长度)
var 变量名=Array(元素列表)

示例：

var age:Array[Int] = new Array[Int](3)
var age = Array(1,2,3)

设置值

格式：

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

示例：

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

获取值

格式：

数组名(下标参数);

示例：

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

常用方法

方法名描述
arr.length返回数组长度
arr.head返回数组第一个元素
arr.tail返回数组除了第一个元素以外的元素
arr.isEmpty判断数组是否为空
arr.contains(x)判断数组是否包含元素x
arr1++arr1将两个数组合并为一个数组
concat(arr1，arr2)将两个数组合并为一个数组(需要导包)

注意：

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

注意

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

列表(List)

创建

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

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

格式：

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

示例：

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

获取值

格式：

数组名(下标参数);

示例：

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

常用方法

方法名描述
list.head返回列表第一个元素
list.last返回列表最后一个元素
list.tail返回列表除了第一个元素外的所有元素
list.init返回列表除了最后一个元素外的所有元素
list.take(n)返回包含列表前n个元素的新列表
list.contains(x)判断列表是否包含某个元素x
list1:::list2合并两个列表
list1.:::list2合并两个列表，并且顺序为list2, list1
List.concat(list1, list2)合并两个列表

注意

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

集合(Set)

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

创建

格式：

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

示例：

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

添加值

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

格式：

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

示例：

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

获取值

格式：

集合名(下标参数)

示例：

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

常用方法

方法名描述
set.head返回集合的第一个元素
set.last返回集合的第二个元素
set.tail返回集合除第一个元素的所有元素
set.init返回集合除了最后一个元素的所有元素
set.take(x)返回含有集合前x个元素的新集合
set.contains(x)判断集合是否含有某个元素
set1++set2合并两个集合

注意

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

映射(Map)

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

创建

格式：

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

示例：

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

修改值

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

格式：

映射名(键)=值

示例：

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

添加键值对

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

格式：

映射名+=(键->值)

示例：

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

注意

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

元祖

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

创建

格式：

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

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

val 常量名=(元素列表)

示例：

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

获取值

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

格式：

元祖名._下标参数

示例：

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

scala的类(class)

创建

格式：

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

示例：

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

格式：

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

示例：

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. 主构造代码块只会执行一次，因为是单例的

格式：

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

示例：

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

匹配模式

变量匹配

格式：

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

示例：

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

列表匹配

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

格式：

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

示例：

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关键值定义的类被称为样例类。样例类是一个特殊的类，经过优化用于模式匹配。

格式：

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

示例：

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

示例：

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

格式：

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


写入

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

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

格式：

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

示例：

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


键入数据

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

格式：

val 常量名=Console.readLine

示例：

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

声明：一代明君的小屋|版权所有，违者必究|如未注明，均为原创|本网站采用BY-NC-SA协议进行授权

转载：转载请注明原文链接 - scala基础

欢迎来到我的小屋