scala知识点

Posted 2020-11-15 xl717

--------数据类型-------
整型，浮点型，字符，字符串，布尔型，Unit无值，Null空值，
Nothing：其他所有类型的子类型
Any:所有其他类的超类
AnyRef:所有引用类的基类
--------数据结构----------
字符串String，
StringBuffer:可变，每次操作都是对其本身进行操作
append方法把字符添加到缓冲区的末端
insert方法是在指定的点添加字符

数组Array,可变的，具有索引的集合
但是一但大小设定，就无法再改变
Vector:不可变的Array
ArrayBuffer:可变类的Array

容器：
import scala.collection
import scala.collection.mutable._ 可变容器
import scala.collection.immutable._ 不可变容器
列表List[T],不可变的链表，很适合递归操作
ListBuffer:可变列表
集合Set,默认是不可变的
可变集合Set：scala.collection.mutable.Set

映射Map
元组Tuple（数值），这个数值是元组总包含几个元素
元组不可变，可包含不同类型的元素
访问：t._1表示访问第一个元素
选项Option[T]:一个类型为T的可有值(Some)可无值(None)的一个值。

-------- => --------
1.传名调用：将未计算的参数表达式直接应用到函数内部
2.case 1=>"one"

-------- -> ----------
1. Map("runoob" -> "www.runoob.com")

-------- :: ----------
1. List的一个方法，用于在头部添加新元素
1::List(2,3)=List(2,3).::1=List(1,2,3)
在scala里所有以：结尾的运算符是右关联的，其他的运算符都是左关联的！
2.表示一个非空的List，常见于模式匹配
case n::rest=>n+sum(rest)
n::rest会匹配一个非空集合，结合的第一个元素被提取并赋值给变量n，剩余变量被提取并赋予变量rest.

----------打印--------
print,println

-----------循环----------
for(arg<-args){}
for(i <- 1 to 10){}
for循环中的yield会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。

----------模式匹配--------
1.每个备选项都开始于关键字case
2.每个备选项都包含了一个模式及一到多个表达式。
case 模式=>表达式

def matchTest(x:Any):Any=x match{
case 1=>"one"
case "two"=>2
case y:Int=>"scala.Int"
case _=>"many"
}

---------函数--------
def main(args: Array[String]){} 主函数
def func(a:Int,b:Int):Int={} 函数定义
def func(a:Int,b:Int):Int 抽象函数
def func(args:String*)={} 函数最后一个参数可以是可变参数
val mul=(x:Int,y:Int)=>x+y ;println(mul(3,4)) 匿名函数，mul是一个函数

--------字符串---------
String:不可变,修改后会产生一个新的对象
StringBuilder：可变 val buf=new StringBuilder;
获得字符串长度：str.length()
字符串连接：str1.concat(str2) 或 str1+str2
printf()方法格式化字符串并输出：
var fs=printf("浮点型变量为 " +
"%f, 整型变量为 %d, 字符串为 " +
" %s", floatVar, intVar, stringVar)
println(fs)
根据给定正则表达式的匹配拆分此字符串
String[] split(String regex)
删除指定字符串的首尾空白符
String trim()

-------数组---------
第一个元素索引为0，最后一个元素索引为元素总数减1
声明数组：var z=new Array[String](3)
定义一个数组：var z=Array("baidu","ali")
元素赋值：z(0)="baidu"

多维数组：
矩阵和表格是常见的二维数组
定义一个二维数组：var myMatrix=ofDim[Int](3,3)

合并数组：concat()接收多个数组参数，var list3=concat(list1,list2)
创建区间数组：range(start,end,step),step步长，默认为1

数组方法，需要使用import Array._ 引入包
创建一个二数组，长度有第一个参数指定，同时每个元素使用第二个参数进行填充
list0=fill[Int](3,4)(0:Int)

返回指定长度数组，每个数组元素为指定函数的返回值。
list=Array.iterate(0,3)(a=>a+1) 数组初始值为0，长度为3，计算函数是a=>a+1
(list:Array(0,1,2))

--------------集合-------------------
List 列表 val x=List(1,2,3,4)
Set 集合 val x=Set(1,3,5,7)
Map 映射：键值对 val x=Map("one"->1,"two"->2)
元组 ：不同类型值的集合 val x=(10,"one")
Option[T] :有可能包含值，也可能不包含值的容器 val x:Option[Int]=Some(5)

----------------Iterator 迭代器---------------------
Iterator 迭代器：逐一访问容器内元素的方法
方法：next(),hasNext,max,min,sizelength,contains(elem:Any):Boolean,
count(p:(A)=>Boolean):Int 返回迭代器元素中满足条件p的元素总数
exists(p:(A)=>Boolean):Boolean
filter(p:[A]=>Boolean):Iterator[A]
filterNot(p:[A]=>Boolean):Iterator[A]
find(p:[A]=>Boolean):Option[A]
...

val it=Iterator("baidu","ali")
while (it.hasNext){
println(it.next())
}

------------类-------------------
class Point(xc:Int,yc:Int){
var x:Int=xc
var y:Int=yc
def move(dx:Int,dy:Int){}
}

继承：extends
1.重写一个非抽象方法必须使用override修饰符
2.只有主构造函数才可以往基类的构造函数里写参数
3.只允许继承一个父类，会继承父类的所有属性和方法
class Location(override val xc:Int,override val yc:Int,
val zc:Int) extends Point(xc,yc){
var z:Int=zc
def move(dx:Int,dy:Int,dz:Int){} //move是不同的函数了
}

Trait特征（接口）：关键字trait，extends
1.可继承多个特征
2.特征可以定义属性和方法的实现
3.子类继承特征可以实现未被实现的方法

------------常用函数-----------
isInstanceOf():判断类型

--------------case class--------------
case类：模式类
让编译器帮忙自动生成常用方法！
1.编译器会为case class自动生成以下的方法：
equals,hashCode,toString,copy
2.编译器会为case class自动生成伴生对象
3.编译器会为伴生对象自动生成以下方法
apply，unapply
意味着不用使用new关键字就可以实例化一个case class
4.case class的类参数在不指定val/var修饰时，会自动编译为val，即对外只读，
如果需要case class的字段外部可写，可以显式地指定var关键字

通常不会让一个普通类继承case class，会导致一些问题
copy方法会基于当前实例的所有字段值赋值一个 新的实例并返回，
可以在通过给copy方法传递参数来重新设定某一个或几个字段的值，
这是通过命名参数实现（named parameters）实现的。

case object 是全局的一个唯一的实例