scala总结

变量和常量的使用

关键字

var:定义的是变量,值是可以变化的

val:定义的是常量,值是不能变化的

基础语法

在scala中定义变量的时候,可以不带类型,由后面的值进行自动推导

1. var variable = value

   不去指定variable的类型后面的值进行自动推导

2.var variable:Int

​ 使用指定的类型声明一个变量,此时前面声明的类型必须和后面的值类型一致

var a=10    //不设置类型,由值自动推导类型
var b:Int=0 //设置一个变量,手动指定类型,此时前后的类型需要一致
var n1,n2=10 //同时设置两个变量,两个变量类型和值相同
var (n3,n4)=(30,40)  //同时设置两个变量,两个变量的值不同
var (n5,n6,n7)=(10,"hello world",3.14)  //同时设置多个变量,多个变量的类型和值都不同

转义字符

val str2:String = "leetom: \"hello world\""

"""

以"""开头,以"""结尾,中间的部分不用做转义
val str3:String = """leetom: "hello world""""
"""中间是可以换行的
stripMargin可以解析一行的|开头
val str4:String = 
"""leetom: "say hello"
   |leejerry: "good day"
   |leetoy:"nice day"
   |""".stripMargin

语法糖

val name:String="leetom"
val age:Int = 18
val gender:Char = 'm'
println(s"我的名字是:$name,我的年龄是:$age,我的性别是:$gender")

类型转换

自动类型转换

val num1:Int=10
val num2:Long=num1

强制类型转换

val n1:Long=1000L
val n2:Byte=n1.toByte

数值类型转字符串类型

val s1:String = n2.toString

判断变量是否为指定类型

s1.isInstanceOf[String]

字符串转数值类型

val s2:String="123456"
val s3:Int=s2.toInt

算数运算符大部分和java相同

a.+(b)和a+b等价

代码块,一段可以执行的代码

//代码段
{
    代码段
    这里的代码会被执行
    除了有局部变量作用域限定,没有其他意义
}

表达式

val res0:Int={
    val a=10
    val b=20
    a+b
}
这段代码可以被求值
代码段中的最后一行的结果是个代码段执行的结果最后一个值前面不能添加return
res0的类型是由右侧的代码段结果进行自动推导

分支if else

val le1:Int={
    if(a>b)
        a
    else
        b
}

while循环

var sum=0
var num=0
while(num<=100){
    sum+=num
    num+=1
}

do while循环

sum=0
num=1
do{
    sum+=num
    num+=1
}while(num<=100)

for循环

to:1 to 100 生成区间[1:100]

until:1 until 100 生成区间[1,100)

基础语法

for(变量<-区间)

使用区间的每一个值依次给变量赋值

for(a<-1 to 3){}

嵌套循环一次建每一层的循环条件在一个for的的小括号中写出来,用分号分隔

for(a<-1 to 3;b<-1 to 3){}

循环推导式

将每次循环得到的值放在yield后面

val res:immutable.Seq[Int] = for(i<-1 to 50 if i%2==0 && i%3==0) yield i 

scala中的break

scala中没有break和continue
可以使用breakable
导入包
import scala.until.control.Breaks._
breakable{
    for(i<-1 to 100){
        println(i)
        if(i==5)
            break
    }
}

方法

定义的时候方法的返回值类型可以不写,由实际的返回值进行推导

但是递归调用方法的到时候这个方法的返回值必须明确

如果方法体重的逻辑很简单,只有一行,大括号可以省略不写 推荐省略不写

如果一个方法是无参方法,调用的时候可以不写小括号

如果一个方法时无参的,在定义的时候可以省略小括号不写,在调用的时候也能不写小括号

def calculate(a:Int,b:Int):Int = a+b
定义方法时,可以不写等号
如果不定义等号不会通过右边的方法体的结果,来自动推导的方法的返回类型
def myMethod(){
    val a=10
    val b=10
    a+b
}

调用方法的时候可以使用带名参数

//定义方法的时候可以允许参数是有默认值的
//默认参数调用的时候可以不进行值的设置
def calculate(x:Int,y:Int,z:Int=10):Int={
    x+y+z
}
//有默认值的参数,在调用的时候默认传递的值其实是按照顺序进行赋值的
def calculate2(x:Int=20,y:Int,z:Int=30):Int+{
    x+y+z
}
calculate(5,10)
​
调用方法的时候传参的时候可以使用带名参数
calculate2(y=20)
calculate2(y=5,z=10,x=20)

在java里变长参数可以传递一个数组值,但在scala中是不允许的

def getSum(numbers:Int*):Int={
    //在scala中变长参数的类型也是数组的类型
    varsum=0
    for(n<-numbers){
        sum+=n
    }
    sum
}
​
getSum(array:_*)

函数

函数和方法的区别

语法区别

方法:def 方法名字(参数列表):返回值类型={方法体}

函数:val 函数变量:函数类型(可以不设置)=(函数的参数列表)=>{函数体}

位置不同

方法:一般定义在类内,特质内,包括在某一个object内

函数:一般定义在类内,特质内,object内,方法内

def calculate(calculator:(Int,Int)=>Int,x:Int,y:Int):Unit={
    println(calculator(x,y))
}
def calculateMethod(x:Int,y:Int):Int=x+y
​
//定义一个scala函数需要依靠某一个变量的值,将这个函数给某一个变量赋值
val calcultor=(a:Int,b:Int)=>a+b
calcultor(10,20)
//如果左侧函数的变量类型已经确定,可以不写参数类型
val calculator2:(Int,Int)=>Int=(x,y)=>x+y
//如果参数只用到一次,在实现部省略参数声明部分用_代替
val calculator3:Int=>Unit=println(_)
val calculator4:Int=>Int=_*2
val calculator5:(Int,Int)=>Int=_+_
val calculator6:(Int,Int,Int)=>Int=_+_+_
//如果函数的实现中使用_来表示唯一使用到的参数且这个参数作为另一个函数或方法出现,此时可以省略掉这个下划线和方法或者参数的小括号
val calculator7:Int=>Unit=println(_)
val calculator8:Int=>Unit=println
val calculator9:(Int,Int)=Int=>calculateMethod
//高阶函数就是将参数或者返回值设置为其他的函数,就是一个高阶函数
calculate(_+_,10,20)
calculate(calculator5,100,200)
calculate(calculateMethod,100,200)
val cal:((Int,Int)=>Int,Int,Int)=>Int=_(_,_)
cal(_+_,100,200)
//方法转函数直接在后面加一个空格下划线即可
val calculator10=calculateMethod _
​

在scala中集合大概分为scala.collection.immutable和scala.collection.mutable

scala默认采用的是immutable的

mkString:将一个集合中的元素拼接成一个字符串

​ -()=>将所有的元素拼接成一个字符串

​ -(sep:String)=>将所有的元素拼接到一起,中间使用指定的分隔符 分隔

​ -(start:String,sep:String,end:String)=>将所有的元素拼接到一起,使用sep分隔 前缀start,后缀end

创建数组

val array1=new A