一：操作符
这一章几乎是Java操作符的简单介绍，大佬们可以直接跳过，看第二章。
标识符
val ** = "as" //**也可以是变量名称
println(**)
val `【】四川省` = "abcd" //``内可以写任意的字符串
println(`【】四川省`)
中置操作符
for(i <- 1 to 10){ println(i)} //其实就是调用的1.to(10)方法
一元操作符
//只有一个参数的操作符称为一元操作符
//1.toString()
赋值操作符
val data = "abcd" //赋值操作符，很常见的
优先级
//这一章节建议大家多使用()来确定优先级，只需要记住*/高于+-，<> 高于&^|。这两种就可以了
结合性
//这一章的意思是，操作符相关是按照从左到右的顺序的。例子：1+2+3计算方法是第一个加号操作的是1和2，第二个加号操作的是2和3。
//基本上和数学是一样的
apply和update方法
val data = scala.collection.mutable.Map("a"->1,"b"->2,"c"->3,"d"->4)
data("a") = 11 //其实调用的是data.update("a",11)
val a = data("a") //其实调用的是 data.apply("a")
//apply方法常用到new对象中
val data = Array.apply("abcd") //其实调用的是方法new Array
println(data.mkString("|"))
提取器
//提取器是apply的反向操作名称为unapply，参数为一个对象，将构造对象的参数提取出来
//例子：上一节中通过abcd构造了一个Array对象，而unapply方法就是传递进去data，返回abcd字符串。其实Array是没有这个方法的
单个参数或无参数的提取器
//该提取器的方法是将字符串提取成数字
object Number {
def unapply(inputString:String):Option[Int]={
try{
Some(Integer.parseInt(inputString.trim()))
}catch{
case ex:NumberFormatException => None
}
}
}
unapplySeq方法
//上述的方法只能提取一个数字，但是真正在提取过程中提取一般是提取一个Seq
object Number {
def unapply(inputString:String):Option[Array[String]]={
try{
Some(inputString.trim().split("\|").toArray)
}catch{
case ex:NumberFormatException => None
}
}
}
object FastLearnScala{
def main(args: Array[String]): Unit = {
println(Number.unapply("1 9 7 8"))
}
}
二：高阶函数
作为值的函数
val num = 3.1415926
val fun = scala.math.max _ //_说明的是用fun指向这个函数
println(fun(1,3))
匿名函数
val num = (num:String)=>{num + "abcd"} //这种方法就是一个匿名函数
println(num("1234"))
val array = num("1234|").split("\|") //其实使用最多的还是map方法，如下也是一个匿名函数
array.map { x => println(x) }
带函数参数的函数
object FastLearnScala{
//传递的是一个函数，输入是Double,输出也是Double。最终调用的是函数，传递的参数是0.25
def valueAtOneQuatter(f:(Double)=>Double) = { f(0.25) }
def main(args: Array[String]): Unit = {
println(valueAtOneQuatter(scala.math.ceil _))
}
}
//一般情况下不这样使用。直接调用函数就行了
参数类型推断
//scala会将一些自动推断出来，你需要的类型
val data = 3 * 1//scala会自动推断出来data是Int类型的，在函数中也是一样的
一些有用的高阶函数
val data = Array(1,2,3,4,5)
//map函数 针对数组每一个元素都进行+10的操作
data.map { x => x+10 }
//过滤出来>5的元素
data.filter(_ > 5)
//reduceLeft接受一个二元函数，并将它应用到所有元素
data.reduceLeft(_*_) //其实是(((1*2)*3)*4)*5
//sortWith排序函数
data.sortWith((x,y)=>x>y).mkString("|")
闭包
//函数可以在变量不在处于作用域时被调用，简单说就是函数可以帮你暂存你的数据，因为你的数据指向函数导致了函数不会被回收
object FastLearnScala{
def mulby(x:Int) = (y:Int) => x*y //该函数将x作为一个参数，x作为第二个参数，计算x*y的值
def main(args: Array[String]): Unit = {
val a = mulby(10)
val b = a(3)
println(b)
}
}
SAM转换
//其实是单个抽象方法，就是只有一个抽象方法。
//如下是一个计数的方法
import javax.swing.JButton
import java.awt.event.{ActionListener,ActionEvent}
object FastLearnScala{
def main(args: Array[String]): Unit = {
var counter = 0
val button = new JButton("increate")
button.addActionListener(new ActionListener{
override def actionPerformed(event:ActionEvent){
counter += 1
}
})
}
}
//其实在真正的使用过程中，更多的是需要一个new ActionListener的封装，只需要调用即可，那我们可以进行改造
var counter = 0
implicit def makeAction():ActionListener = {
new ActionListener{
override def actionPerformed(event:ActionEvent){
counter += 1
}
}
}
val button = new JButton("increate")//调用使用
button.addActionListener(makeAction)
柯里化
//上一个章节的闭包就是柯里化
object FastLearnScala{
def mulby(x:Int) = (y:Int) => x*y //该函数将x作为一个参数，x作为第二个参数，计算x*y的值
def main(args: Array[String]): Unit = {
val a = mulby(10)
val b = a(3)
println(b)
}
}
//上面的过程可以分解为：传入x的时候返回一个函数(y:Int)=>x*y
控制抽象
//没有看懂，后面再补充吧
return表达式
//scala写法支持return，但是不建议使用。默认是将最后一个变量返回
def mm():Int = {
var data = 0
if(1 > 3) data = 0 else data = 0
data
}