scala小记
1.数据类型
Byte 8位有符号补码整数。数值区间为 -128 到 127
Short 16位有符号补码整数。数值区间为 -32768 到 32767
Int 32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float 32 位, IEEE 754 标准的单精度浮点数
Double 64 位 IEEE 754 标准的双精度浮点数
Char 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String 字符序列
Boolean true或false
Unit 类似于void，表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null null 或空引用
Nothing Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。
Any Any是所有其他类的超类
AnyRef AnyRef类是Scala里所有引用类(reference class)的基类
2.字面量（常量值）
var为可变变量，val为不可变变量（常量）,变量必须被初始化
val a=10：a为常量不可更改，10为字面量
var b=9：b为变量可以更改，9为字面量
1.整数字面量（十进制与十六进制）
十进制：10
十六进制：0XFFF（0X前缀）
2.浮点数字字面量
double类型：.1(0.1)、3.14e2（314）
float类型：0.1f（有后缀f）
类似于python语言的变量定义（类型推断机制，自动判断变量类型）
代码示例：
val a=1.0e2;//double
val b=1;//int
var c='a';//char
var d="abcd";//String
var e=true;//boolean
var f=.1f;//float
var g=1l//long
println(g.getClass())//获取字面量数据类型
3.操作符
scala中的操作符是方法
代码示例：
var a=5; var b=3; //a+b等价于a.+(b) var result1=a+b; var result2=a.+(b); println(result1,result2);
代码示例：
var d=1;
var c=d=0;//变为0，c变为Unit类型（等价于java中的void），并不是将c与d变量都赋值为0
println(c.getClass(),d)
![]()
4.控制台的读入与输出
读入
代码示例：
var a=readInt();//读取Int类型的数据
val b=readChar();
var c=readLine();
println("a的类型:"+a.getClass(),"b的类型:"+b.getClass(),"c的类型:"+c.getClass);
![]()
输出
代码示例：
//不在同一行的语句，“；”可以省略
print("print:"+a)
println("println:"+b)
printf("printf:"+c)
![]()
字符串插值机制，在字符串字面量前加一个“s”或是“f”，其中，“s”不支持格式化，“f”支持格式化
代码示例：
val a=3.1415926;
val b=0.618;
println(f"a:$a%.1f")//可以设置输出格式
println(s"b:$b")//不可设置输出格式
![]()
5.文件的写与读
写
代码示例：
val writeFile=new PrintWriter("D:\\123.txt")
writeFile.print("wuhu!")
writeFile.print("芜湖！")
writeFile.println("giao!")
writeFile.println("giao!")
writeFile.close()
![]()
读
代码示例：
val readFile=Source.fromFile("D:\\123.txt")
for(line<-readFile.getLines()){
println(line)
}
readFile.close()
![]()
6.for循环表达式
for（变量<-表达式）{}
代码示例：
println("单层循环：")
for(i<-1 to 3){
print(i+" ")
}
println("\n嵌套循环：")
for(i<-1 to 3;j<-1 to 3){
print(i+""+j)
}
println("\n嵌套循环：")
for(i<-1 to 3){
for(j<-1 to 3){
print(i+""+j)
}
}//两种写法等价
println("\n条件判断for：")
for(i<-1 to 3;if i==1){
print(i+" ")
}
println("\n遍历数组:")
for(i<-Array(10,100,100)){
print(i+" ")
}
println("\nyield关键字将for产生的所有值作为容器返回:")
val list1=for(i<-Array(1,2,3)) yield i
list1.foreach(print)
print("(容器类型："+list1.getClass()+")")
7.scala中的break与continue
scala中没有break与continue这两个关键字
只提供了Breaks来实现类似的功能，即breakable与break
代码示例：
val a = Array(1, 2, 3, 4)
//相当于java中的break
println("break:")
breakable {
for (i <- a) {
if (i%2==0) {
break
}
println(i)
}
}
//相当于java中的continue
println("continue:")
for(i<-a){
breakable{
if(i%2==0){
break
}
println(i)
}
}
![]()
breakable：确定break的作用区域
8.数据结构
1.Array数组（可变的，可索引的，元素具有相同类型的数据集合）
代码示例：
//显式创建数组，长度为3
val a=new Array[Int](3)
println("a:")
for(i<-a)
print(i+" ")
println("\nb:")
//隐式创建数组，初始值为1,2,3
val b=Array(1,2,3)
for(i<-b)
print(i+" ")
val c=Array.ofDim[Int](3,3)//定义3x3二维数组
val d=Array.ofDim[Int](3,3,3)//定义3x3x3的三维数组
println("\nc:")
c(1)(1)=1
print(c(1)(1))//圆括号访问数组
![]()
2.元组（tuple，多个不同类型对象的简单封装）
代码示例：
val a=(1,"lsw",3)
println("a:"+a)
//显式定义，Tuple3表示该元组有三个值，Tuple4表示该元组有四个值
val b=new Tuple3(1,"lsw",3)
println("b:"+b)
![]()
3.容器（list、seq、map）
scala使用三个包来组织容器:
scala.collection(元素可变与元素不可变容器，超类)
scala.collection.immutable（元素不可变容器）
scala.collection.mutable（元素可变容器）
4.序列（seq，可以按照特定顺序访问的容器）
4.1列表（list，共享相同类型的不可变对象序列）
代码示例：
val a = List(1, 2, 3) //隐式定义
println("列表a:"+a)
val b: List[Int] = List(4, 5, 6) //显式定义
println("列表b:"+b)
val c = Nil //空列表
val dim: List[List[Int]] =// 二维列表
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1))
//list具有头尾概念，并且可以判断列表是否为空
println("列表a的头部元素:" + a.head)
println("列表a的尾部元素:" + a.tail)
println("列表a是否为空：" + a.isEmpty)
//列表的连接
val d=a:::b//":::"可用于连接两个列表
println("列表d(使用“：：：”连接)："+d)
val e=300::200::100::a//"::"只可用于在已有链表前添加元素
println("列表e(使用“：：”连接)："+e)
val f=List.concat(a,b)//调用concat方法
println("列表f(使用concat连接)："+f)
val g=a:+100
println("使用“:+”向列表a尾部添加元素："+g)
val h=200+:100+:a
println("使用“+:”向列表头部添加元素："+h)
![]()
4.2 range（特殊的、带索引的不可变数字等差数列）
1 to 3:1、2、3（左闭右闭）
1 to 3 by 2：1、3步长为2
1 until 3:1、2（左闭右开）
代码示例：
val a=Range(1,5)
println("a:"+a)
![]()
5.集合（set，不重复元素的容器）
代码示例：
val a=Set(2,2,2,3,3,3,4,4,4)//元素不重复
println("集合a:"+a)
//set具有头尾概念，并且可以判断列表是否为空
println("集合a的head："+a.head)
println("集合a的tail："+a.tail)
println("集合a是否为空："+a.isEmpty)
//add与remove添加与删除元素
a.add(1)//由于a为不可变集合，所以删除后会生成一个新的set
println("添加元素“1”后的集合a(add):"+a)
a.remove(2)
println("删除元素“2”后的集合a(remove):"+a)
//+=等价于add
a+=2
println("添加元素“2”后的集合a(+=):"+a)
//-=等价于remove
a-=1
println("删除元素“1”后的集合a(-=):"+a)
![]()
虽然可变Set和不可变Set都有添加或删除元素的操作，但是有一个非常大的差别。
对不可变Set进行操作，会产生一个新的set，原来的set并没有改变，这与List一样。
而对可变Set进行操作，改变的是该Set本身，与ListBuffer类似。
6.映射（map）
代码示例：
val a=Map("1"->"a","2"->"b","3"->"c")
println("映射a："+a)
//使用圆括号对map中的元素进行访问
println("key为1的value："+a("1"))
println("映射a的keys："+a.keys)
println("映射a的keys："+a.values)
//查找map中是否含有key为1的映射：
println("是否含有key为1的映射:"+a.contains("1"))
//迭代器访问map
val b=Iterator(a)
println("迭代器访问映射a的结果：")
while(b.hasNext){//hasnext用于检测是否还有下一个元素
print(b.next+"")//next()用于遍历
}
print(b.next())//执行会报错，指针
![]()
7.迭代器（iterator，按顺序访问容器元素的数据结构）
代码示例：
val b=Iterator(1,2,3,4)
println("迭代器访问的结果：")
while(b.hasNext){//hasnext用于检测是否还有下一个元素
print(b.next+"")//next()用于遍历
}
print(b.next())//执行会报错，指针
![]()
9.scala特点（能省则省，少加精加，方法至上）
1.运行于JVM上的语言
2.面向对象的语言
3.函数式语言
4.支持柯里化（将接受多个参数的函数变为接受单一参数的函数）
5.每个函数都是一个对象
6.每个值都是一个对象
7.每个操作都是方法调用
10.类（class）
1.大写字母开头
2.字段：对象包含的变量
3.方法：使用数据对对象进行可执行的程序块（def）
4.类成员的可见性：默认public（任何作用域都可以直接访问），protected（本类型与继承类）、
private（本类型与嵌套类（内部类），外部访问通过类似java的getter与setter（value））
5.方法的参数不可用var与val来限定，因为方法的参数都是隐式的val
6.无参数的方法可省略圆括号
7.无参数的方法在定义时无括号，调用时不可添加括号；无参数的方法在定义时有括号，调用时可加可不加括号。
8.类的方法可以从方法中最后的表达式推断返回类型
9.方法允许重载
10.允许方法嵌套定义
11.构造器：整个类的定义主体
12.位于类方法外的语句都将在构造过程中执行
代码示例：
class Stu {
private var name="lsw"//私有字段，外部不能直接访问
var age=10//公有字段
protected var sex=" "//受保护的字段
def value():String={
return this.name
}//等价于def value=name,调用方法访问私有字段
def printSchool(num:Int):Unit={
println("FJUT:"+num)
}//等价于def printSchool(num:Int)=println("FJUT:"+num)
//当且仅有一条语句时，花括号可以省略
}
11.对象（object）
类是对象的抽象，对象是类的具体
1.scala中没有Static！！！（通过单例对象实现类似功能）
2.静态方法最大的特点就是，不用生成类的实例对象，直接可以用
3.静态方法只能调用静态成员或是方法
代码示例：
class Stu{//伴生类
private var name="lsw"//私有字段，外部不能直接访问
var age=10//公有字段
protected var sex=" "//受保护的字段
def value():String={
return this.name
}//等价于def value=name,调用方法访问私有字段
def printSchool(num:Int):Unit={
println("FJUT:"+num)
}//等价于def printSchool(num:Int)=println("FJUT:"+num)
//当且仅有一条语句时，花括号可以省略
//print("success")
}
object Stu{//伴生对象
private var height="187cm"
def printHeight=println(s"$height")
}
//object Stu1{//孤立对象
//private var height="187cm"
//def printHeight=println(s"$height")
//}
11.1 单例对象（第一次被访问的时候被初始化）
使用方式：定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数
11.1.1 伴生对象（与类同名）
1.伴生对象与伴生类必须位于同一个文件内
2.相互之间可以访问私有成员
3.伴生对象的方法只能通过伴生对象调用，不能通过伴生对象实例调用
![]()
11.1.2 孤立对象（与类不同名）
12.apply（类似于java的构造函数，自动调用）
定义：用括号传递给类示例或对象名一个或多个参数时，scala会在相应的类或对象中查找方法名为apply且参数列表与传入的参数一致的方法，
并用传入的参数来调用该apply方法
代码示例：
![]()
调用：
![]()
13.继承（inherit）
13.1 抽象类
1.scala抽象类无须加abstract修饰符
2.不能被实例化
代码示例：
abstract class Car {
val carBrand:String//抽象字段，未初始化
def run()
def stop(){
println("我停下来了")
}
}
13.2 类的继承
1.单一继承
2.重载只重载val字段
3.子类的主构造器必须调用父类的主构造器或辅助构造器（辅助构造器的第一个表达式）
4.不想类被继承则在定义类时加上final关键字（做绝育）
5.重载关键字：override（重载抽象成员时可省略，重载非抽象成员时不可省略）
代码示例：
abstract class Car(val name:String) {
val carBrand:String//抽象字段，未初始化
var age:Int=0
def run()
def stop(){
println("我停下来了")
}
def this(name:String,age:Int){//辅助构造器，用this定义
this(name)//调用主构造器，辅助构造器必须调用已经定义的主构造器或是辅助构造器（必须得叫爹）
this.age=age
}
}
//继承主构造器的派生类
class BMW (override val name:String) extends Car(name){
override val carBrand="BMW"//override可省略
def run(){//override可省略
println("宝马在路上跑")
}
override def stop(){//override不可省略
println("宝马停下来了")
}
}
//继承辅助构造器的派生类
class BENZ (name:String,age:Int) extends Car(name,age){
val carBrand="BENZ"
def run(){
println("奔驰在跑")
}
def info(){
println("车的牌子是："+this.carBrand+" 车龄是"+age)
}
}
13.3类层级结构
1.引用类型：class 数据类型（基本类型）：int、double……
![]()
2.scala使用null的目的：实现jvm与其他java库的兼容性，无明确需要时，能不用就不用
13.4 option类（抽象类）
1.包含具体的子类Some（有值）以及对象None（无值）
2.引入目的：避免使用兼容java库带来的bug，例如return
3.有值返回一个some对象，无值返回None
13.5 参数化类型
1.引入目的：在类定义时包含一个或几个不确定的类型参数，在实例化时再进行确定
2.方括号：“[]”
13.6 特质（trait关键字）
1.使用trait关键字定义，可同时拥有抽象与非抽象方法
2.特质的主构造器不能有参数，特质不能定义辅助构造器
3.类使用extends或with关键字继承特质（第一个继承必须使用extends关键字，剩余使用with关键字），特质继承特质只能用with关键字
4.
代码示例：
trait Bird {//定义特质
var canFly:String
def flyHeight()
def legsNum(){
println("鸟有两条腿")
}
}
trait Eagle extends Bird{//特质继承特质
def flyHeight(){
println("10000000m")
}
}
class Chicken (name:String) extends Bird with Eagle {//类继承特质
override var canFly="not fly"
def flyHeight(){
println("0m")
}
}
浙公网安备 33010602011771号