Scala进阶

发表于
字数统计:

Scala的设计理念

简单的说就是讲不同语言中的多个概念融合在一起

Scala的函数式编程和面向对象编程

略

六大特征

  1. Java和Scala混编
  2. 类型推断
  3. 并发和分布式(Actor)
  4. 特质,特征(类似java中的接口和抽象类)
  5. 模式匹配
  6. 高阶函数

类和对象

对象object

  1. 方法和变量都是静态的
  2. 定义常量用val
  3. object不可以传参

类 class

  1. 变量用var, 常量用val
  2. 一行代码不需要分号分割
  3. 驼峰命名方法
  4. 类可以传参, 就有了默认的构造函数, 勒种默认属性就有了getter和setter方法
  5. 当创建一个class, 除了方法不执行其他都会执行
  6. scala中class和object同名, 这个class叫做这个object的伴生类, object是这个class的伴生对象, 就可以互相访问私有变量.
  7. 同一个包里面,类名不能重复

scala版九九乘法表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
object NineNineMultiplicationTable {

  def main(args: Array[String]): Unit = {

    for (a <- 1 until 10; b <- 1 to 10) {
      if (a >= b) {
        print(a + "x" + b + "=" + a*b + "\t")
      }
      if (a == b) {
        println()
      }
    }
  }

}

// 结果

1x1=1	
2x1=2	2x2=4	
3x1=3	3x2=6	3x3=9	
4x1=4	4x2=8	4x3=12	4x4=16	
5x1=5	5x2=10	5x3=15	5x4=20	5x5=25	
6x1=6	6x2=12	6x3=18	6x4=24	6x5=30	6x6=36	
7x1=7	7x2=14	7x3=21	7x4=28	7x5=35	7x6=42	7x7=49	
8x1=8	8x2=16	8x3=24	8x4=32	8x5=40	8x6=48	8x7=56	8x8=64	
9x1=9	9x2=18	9x3=27	9x4=36	9x5=45	9x6=54	9x7=63	9x8=72	9x9=81

函数

函数返回值

  • 如果需要函数返回值可以在最后写 “=”

递归函数

  • 递归函数返回值需要显示声明

参数有默认值的函数

  • 直接在函数参数写”=”

可变参数函数

1
2
3
def fun(array: String*) {
    println(array)
}

匿名函数

1
2
3
()=> {
	println("hell0 world")
}

嵌套函数

1
2
3
4
5
6
7
8
9
10
11
def f1(a: Int) {
    def f2(num: Int) {
        if (num == 1) {
            1
        } else {
            num * f2(num - 1)
        }
    }
    f2(a)
}
f1(5)

偏应用函数

  • 固定函数不变的参数,可变的参数将其用”_”表示,并复制给一个变量,这是只需要传可变的参数即可

高阶函数

  1. 函数的参数是函数
  2. 函数的返回值是函数
  3. 函数的参数和返回值是函数
1
2
3
4
5
6
7
def f1(a: Int, b: Int): Int = {
    a+b
}

def f2(s: String, f: (Int, Int) => Int) {
    
}

集合列表数组

数组

1
2
3
4
5
//Array
val arr = Array[Int](1,2,3,4)
arr.foreach(println)

val arr2 = new Array[String](3)

列表

1
2
3
4
5
6
7
8
9
10
// list
val list = List("hi 1", "hi 2", "hi 3")
val result = list.map( f => {
    f.split(" ")
})

result.foreach(a => {
    println("+++++++++")
    a.foreach(println)
})

map和flatmap的区别?

  • 前者是处理返回下一个处理结果的数组类型, split返回List[Array[String]], 一对一
  • 后者直接返回List[String], 一对多

Set, 去重无序

map键值对

1
2
3
4
val map = Map(1 -> "a", 2 -> "b")
val value = map.get(2) //返回值是Option, 包含null和some, 无值和有值
val keys = map.keys
val values = map.values

元组

  • 最多支持22个元素

  • new可写可不写

  • 迭代器便利 productIterator

特质 Trait

  • 不可以传参
  • 可以被多继承 extends

模式匹配

1
2
3
4
5
6
7
8
def matchTest(a: Any) {
    a match {
        case 1 => println("1")	//匹配值
        case i: Int => println("int")//匹配类型
        case s: String => println("string")
        case _ => println("default")
    }
}

Actor 是通信模型, Spark底层节点之间的通信就是Akka, Akka是通信模型, Akka是Actor实现的.

Actor相当于Java线程-Thread, 解决了锁的机制

  • 消息队列, 异步

注意引入的时候,actor已经被遗弃, 用akka取代

akka下载引入

1
2
//sbt方式
libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.5.21"

简单使用

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyActor extends Actor {
    override def receive: Receive = {
        case s: String => println(s)
    }
}


object ActorApp {
    def main(args: Array[String]): Unit = {
        val a = ActorSystem("main").actorOf(Props[MyActor])
        a ! "hello"
    }
}
Donate comment here