Scala

简述

Scala既是面向对象的语言，也是面向函数的语言。scala可以为你在做大量代码重用和扩展是提供优雅的层次结构，并可以通过高阶函数来实现这样的目标。（高阶函数是函数式编程里的特性之一，允许函数作为参数传递，也允许函数作为返回值来返回）

Scala语言的特点

Scala并不适于编程的初级课程。相反，它是为专业程序员定制的强力语言。
1）它是一门现代编程语言，作者是Martin Odersky（javac之父），受到Java、Ruby、Smalltalk、ML、Haskell、Erlang等语言的影响。
2）它即是一门面向对象（OOP）语言，每个变量都是一个对象，每个“操作符”都是方法。scala语言在面向对象的方面，要比java更彻底。
它同时也是一门函数式编程（FP）语言，可以将函数作为参数传递。你可以用OOP、FP，或者两者结合的方式编写代码。
3）Scala代码通过scalac编译成.class文件，然后在JVM上运行，可以无缝使用已有的丰富的Java类库。即Scala的代码会编译成字节码，运行在Java虚拟机（JVM）上。
4）接触语言的第一天你就能编出有趣的程序，但是这门语言很深奥，随着学习的深入，你会发现更新、更好的编写代码的方式。Scala会改变你对编程的看法。针对同一任务，可以有很多种不同的实现方式，并且可读性以及性能都有不一样的体现。

Scala基础语法
Var—变量
Val—常量

学习关于string类型相关的常用方法

知识点:
1.scala可以无缝衔接java类库,调用其方法
2.scala底层有一种隐式转换机制,当调用的方法不是java类所拥有时,会隐式转换成scala类型
string–>stringOps

var v1=“helloworld”
var v2=v1*3
var v3=v1.split(‘o’)
//取出前n个元素
v1.take(3)
//取出尾部n个元素
v1.takeRight(3)
//去除前n个元素,并返回声明类型
v1.drop(1)
//去除后n个元素,并返回剩余元素
v1.dropRight(1)

var v4=“a.txt”
v4.dropRight(4)
//取出头元素
v1.head
//取出最后一个元素
v1.last
//按指定分隔符分割
v1.mkString(",")
//去重
v1.distinct
//过滤器
v1.filter{world=>world!=‘o’}
//遍历方法,一般用于打印测试
v1.foreach{println}
//查看指定元素是否存在
v1.contains(‘z’)

v1.length()
//反转
v1.reverse
//类型转换
var v5=“100”
v5.toInt
v5.toDouble

学习数值类型操作,以及操作符

知识点:
1.通用的化简规则:
如果调用的方法参数只有一个,则.()可以省略
2.scala是行语句,不需要加;
如果一行写多个语句,可以用;隔开
3.scala语言中,都是对象和方法,没有基本变量,所以说,scala的面向对象比java更彻底
4.scala的类型:RichInt,RichDouble等,底层通过隐式转换而来

var v1=1 //> v1 : Int = 1
//生成一个指定区间,一般用于循环语句的范围数据生成
1.to(5) //> res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
1 to 5 //> res1: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
//生成区间,并指定步长
1.to(5,2) //> res2: scala.collection.immutable.Range.Inclusive = Range(1, 3, 5)
1 to 5 by 2 //> res3: scala.collection.immutable.Range = Range(1, 3, 5)
//不含尾元素的区间
1.until(5) //> res4: scala.collection.immutable.Range = Range(1, 2, 3, 4)
1.until(5,2) //> res5: scala.collection.immutable.Range = Range(1, 3)
1 until 5 by 2 //> res6: scala.collection.immutable.Range = Range(1, 3)

//用操作符优先顺序计算,优先级顺序同java
1+32 //> res7: Int = 7
//以方法的调用顺序来调用
1.+(3).(2) //> res8: Int = 8

//学习四种前缀操作符
val v4= +2 //> v4 : Int = 2

val v5= -2 //> v5 : Int = -2

val v6= !true //> v6 : Boolean = false

val v7= ~0xff //> v7 : Int = -256
//为了避免歧义,通过以下方式表示
val v8=2.unary_+ //> v8 : Int = 2
val v9=2.unary_- //> v9 : Int = -2
val v10=true.unary_! //> v10 : Boolean = false
val v11=0xff.unary_~ //> v11 : Int = -256

val v12=30 //> v12 : Int = 30
v12.toString() //> res9: String = 30
v12.toDouble

学习if else

知识点:
1.scala的if else是有返回值的
2.scala的Unit相当于java的void,即空类型
3.通用规则,scala会把方法体{}的最后一行代码当做返回值返回
4.pringln换行打印函数,此函数的返回值类型是Unit
5.print不换行打印,返回值类型是Unit
6.通用的化简规则:如果方法体{}只有一行代码,则方法体可以省略

val v1=5 //> v1 : Int = 5

val v2=if(v1>5){
println(“big”)
“big”
}else{
println(“small”)
“small”
200
} //> small
//| v2 : Any = 200

val v3=if(v1>5)println(“big”)else println(“small”)
//> small
//| v3 : Unit = ()

val v4=if(v1>5)“123"else"456” //> v4 : String = 456

学习scala的循环使用

知识点:
1.while循环的使用同java
2.scala通过()操作集合的下标,不同于java[]
3.scala没有++方法用+=代替

val l1=List(1,3,5,7) //> l1 : List[Int] = List(1, 3, 5, 7)

var index=0; //> index : Int = 0

while(index<l1.length){
println(l1(index))
index+=1
} //> 1
//| 3
//| 5
//| 7

for(i<-l1)println(i) //> 1
//| 3
//| 5
//| 7

for(i<-1 to 10 by 2)println(i) //> 1
//| 3
//| 5
//| 7
//| 9

//用scala的for循环打印99乘法表
for(i<-1 to 9;j<-1 to i; val flag=if(i==j)"\r\n"else"\t"){
print(j+""+i+"="+ji+flag) //> 11=1
//| 12=2 22=4
//| 13=3 23=6 33=9
//| 14=4 24=8 34=12 44=16
//| 15=5 25=10 35=15 45=20 55=25
//| 16=6 26=12 36=18 46=24 56=30 66=36
//| 17=7 27=14 37=21 47=28 57=35 67=42 77=49
//| 18=8 28=16 38=24 48=32 58=40 68=48 78=56 88=64
//| 19=9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 9*9=81

}
for(a<-1 to 9){
for(b<-1 to a){
print(a+""+b+"="+ba+" ")
}
println
} //> 11=1
//| 21=2 22=4
//| 31=3 32=6 33=9
//| 41=4 42=8 43=12 44=16
//| 51=5 52=10 53=15 54=20 55=25
//| 61=6 62=12 63=18 64=24 65=30 66=36
//| 71=7 72=14 73=21 74=28 75=35 76=42 77=49
//| 81=8 82=16 83=24 84=32 85=40 86=48 87=56 88=64
//| 91=9 92=18 93=27 94=36 95=45 96=54 97=63 98=72 9*9=81

for(i<-1 to 9;j<-1 to i; val flag=if(i==j)"\r\n"else"\t"){
print(s"$j\ast$i=$j\ast i$flag") //> 11=1
//| 12=2 22=4
//| 13=3 23=6 33=9
//| 14=4 24=8 34=12 44=16
//| 15=5 25=10 35=15 45=20 55=25
//| 16=6 26=12 36=18 46=24 56=30 66=36
//| 17=7 27=14 37=21 47=28 57=35 67=42 77=49
//| 18=8 28=16 38=24 48=32 58=40 68=48 78=56 88=64
//| 19=9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 9*9=81
}

for(i<-1 to 10;if i>4 & i%2==0)println(i) //> 6
//| 8
//| 10

//声明map
val m1=Map(“tom”->20,“rose”->35,“jim”->30) //> m1 : scala.collection.immutable.Map[String,Int] = Map(tom -> 20, rose -> 35
//| , jim -> 30)
val a1=Array(1,2,3,4) //> a1 : Array[Int] = Array(1, 2, 3, 4)
for(i<-m1)println(i) //> (tom,20)
//| (rose,35)
//| (jim,30)

for((k,v)<-m1)println(k) //> tom
//| rose
//| jim

for((k,v)<-m1)println(v) //> 20
//| 35
//| 30
//

学习for yield表达式

//作用遍历一个集合并返回一个新集合
//scala的集合包含 Array,List Map Tuple Range等
val a2=for(i<-a1)yield{i*2} //> a2 : Array[Int] = Array(2, 4, 6, 8)

val l2=List(1,2,3,4) //> l2 : List[Int] = List(1, 2, 3, 4)
val l3=for(i<-l2)yield{i+1} //> l3 : List[Int] = List(2, 3, 4, 5)

学习异常捕获机制

知识点:
scala的异常捕获机制 是通过case语法来实现的
其他机制同java,比如finally

try{
throw new RuntimeException
}catch{
case t:NullPointerException=>{
//匹配异常后,代码处理
println(“null”)
}case t:Exception=>{
println(“other”)
}
}finally{
println(“end”)
}

val v1=“hello”;
//scala的匹配机制,类似于java的switch
val result=v1 match{
case “hello”=>{
println(“1”)
“123”
}
case “world”=>{
println(“2”)
“456”
}
}

for(i<-1 to 10){
//在breakable方法内的break相当于continue
breakable(
if(i==8){
break
}else{
println(i)
}
)
}

重点:学习scala的函数声明和调用

知识点:
scala通过def关键字来声明一个函数,def 函数名(参数列表) :返回值类型={方法体}
scala可以通过方法体的返回值自动推断出类型,注意:需要=号
scala的函数没有=,则返回值一律为Unit(空)
scala的函数默认的访问修饰符是public,可以在def前加private或protected关键字来修饰
def前加final,表示此方法不能被重写

def f1():Unit={
}

def f2():Int ={
100
}
def f3():String ={
“hello”
}

def f4()={

}

def f5(){“hello”}

def f6(a:Int,b:Int)={
a+b
}

val result=f6(2,3)

def f7(a:String,b:String)={
a+b
}

val result2=f7(“hello”,“world”)

//定义一个函数,接收一个参数,类型Array[Int],作用是遍历数组并打印

def f8(a:Array[Int])={
for(i<-a) println(i)
}
val a1=Array(1,2,3,4)
f8(a1)

//scala的默认参数
def f9(a:String,b:String="[",c:String="]")={
b+a+c

}
f9(“hello”)
f9(“hello”,"$")

//scala的可变参数,即在声明的类型后加*
//可变参数本质上是一种集合类型,可以调用集合相关方法
def f10(a:String*)={
for(i<-a)print(i)
}
//可变参数需要位于参数列表的最后,同java
def f11(b:Int,a:String*)={
}

最重要:学习匿名函数和高阶函数

1.匿名函数没有函数名,有参数列表以及方法体,注意此符号:=>
2.匿名函数最大作用在于:可以把匿名函数当做参数赋值或进行传递
3.高阶函数,将函数作为参数传递
4.通用化简规则:
(1)如果方法体只有一行,则{}可以省略
(2)如果匿名函数参数类型可以推断出,则类型可以省略
(3)如果匿名函数参数列表只有一个,则()可以省略
(4)最终极的化简规则:通过占位符_

def f1(a:Int,b:Int)={a+b} //> f1: (a: Int, b: Int)Int

val f2=(a:Int,b:Int)=>{a+b} //> f2 : (Int, Int) => Int =

f2(2,3) //> res0: Int = 5

//定义了一个高阶函数,特点是允许将函数作为参数传递
//这种机制来自于函数式编程语言
def f3(a:Int,b:Int,f:(Int,Int)=>Int)={
f(a,b)
} //> f3: (a: Int, b: Int, f: (Int, Int) => Int)Int

//调用f2,实现两个数的乘法运算,比如算:2*3

f3(2,3,(a:Int,b:Int)=>{a*b}) //> res1: Int = 6

def f4(a:String,b:Int,f:(String,Int)=>String)={
f(a,b)
} //> f4: (a: String, b: Int, f: (String, Int) => String)String
f4(“hello”,3,(a:String,b:Int)=>{a*b}) //> res2: String = hellohellohello

def f5(a:String,b:String,f:(String,String)=>Array[String])={
f(a,b)
} //> f5: (a: String, b: String, f: (String, String) => Array[String])Array[String
//| ]
val func1=(a:String,b:String)=>{a.split(b)}
//> func1 : (String, String) => Array[String] =
f5(“hello,world”,",",func1) //> res3: Array[String] = Array(hello, world)

f3(2,3,(a,b)=>a*b) //> res4: Int = 6

def f6(a:String,f:(String)=>String)={
f(a)
} //> f6: (a: String, f: String => String)String

f6(“hello”,(a:String)=>{a.take(2)}) //> res5: String = he
f6(“hello”,a=>a.take(2)) //> res6: String = he

val a1=Array(1,2,3,4) //> a1 : Array[Int] = Array(1, 2, 3, 4)

a1.filter{(x:Int)=>{x>3}} //> res7: Array[Int] = Array(4)
a1.filter{x=>x>3} //> res8: Array[Int] = Array(4)

a1.foreach{(x:Int)=>{println(x)}} //> 1
//| 2
//| 3
//| 4
a1.foreach{x=>println(x)} //> 1
//| 2
//| 3
//| 4

//reduce是一个迭代方法
//第一次:a=1 b=2 a+b=3
//第二次:a=3 b=3 a+b=6
//第三次:a=6 b=4 a+b=10
a1.reduce{(a:Int,b:Int)=>{a+b}} //> res9: Int = 10
a1.reduce{(a,b)=>ab} //> res10: Int = 24
a1.reduce{_} //> res11: Int = 24
a1.filter{>3} //> res12: Array[Int] = Array(4)

学习递归函数的声明

//用递归判断裴波那契数列的第n项数字是多少
//2 3 5 8 13
//技巧:1.找递归函数的结束条件 2.找函数关系
//函数关系: f(n)=f(n-1)+f(n-2)
//结束条件:f(0)=2:f(1)=3
//scala的递归函数
//要求1:需要显示的声明函数的返回值类型
//要求2:结束条件的返回值需要加return关键字
def f1(n:Int):Int={
if(n0)return 2
if(n1)return 3
else f1(n-1)+f1(n-2)
} //> f1: (n: Int)Int

f1(3) //> res0: Int = 8

//2 3 4 9 8 27 16 81
//函数关系:当n为偶数项时,f(n)=2f(n-2)
//当n为奇数项时,f(n)=3f(n-2)
//结束条件:f(0)=2;f(1)=3
def f2(n:Int):Int={
if(n0)return 2
if(n1)return 3
if(n%2==0) 2f2(n-2)
else 3f2(n-2)
} //> f2: (n: Int)Int
f2(4) //> res1: Int = 8

//2 3 4 9 16 81 256
//函数关系:f(n)=f(n-2)*f(n-2)
//结束条件f(0)=2 f(1)=3
def f3(n:Int):Int={
if(n0)return 2
if(n1)return 3
else f3(n-2)*f3(n-2)
} //> f3: (n: Int)Int
f3(7 ) //> res2: Int = 6561