Scala学习笔记

写在前面：

之前接触Spark还在研一的时候，看了原始论文+学习Scala+跑了简单demo，现在已经忘得差不多了，实验室没有什么应用场景就荒废掉了。过去大半年主要学习数据挖掘理论知识与实践比赛，对于大数据计算框架的学习搁置了，鉴于今年就要找工作了，决定重拾Haoop、Spark等相关技术，并结合数据做些数据挖掘工作。Spark是基于Scala语言的，虽然也有Python接口，但是还是想体验下这门神奇的语言（兼具函数式编程和面向对象编程优势、代码相当简洁、可以用spark-shell交互式实时查询等等）。

注：本文为个人学习笔记，不定期更新。

---

基础学习：

1.Scala 非常简洁：比较Java 和 Scala 里是如何写类及构造函数的。

// 在 Java 里class MyClass {private int index;private String name;public MyClass(int index, String name) {this.index = index;this.name = name;}}
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

//在 Scala 里class MyClass(index: Int, name: String)
1
2
1
2

根据这段代码,Scala编译器将制造有两个私有字段的类,一个名为 index 的 Int 类型和一个叫做 name 的 String 类型,还有一个用这些变量作为参数获得初始值的构造函数。这个构造函数还将用作为参数传入的值初始化这两个字段。

有助于 Scala 的简洁易懂的另一个因素是它的类型推断。重复的类型信息可以被忽略,因此程序变得更有条理和易读。

2.函数式风格：Scala 允许你用指令式风格编程,但是鼓励你采用一种更函数式的风格。

通向更函数式风格路上的第一步是识别这两种风格在代码上的差异。 
如果代码包含了任何 var 变量,那它大概就是指令式的风格。如果代码根本就没有var ——就是说仅仅包含 val ——那它大概是函数式的风格。因此向函数式风格推进的一个方式,就是尝试不用任何 var 编程。

指令式风格:

def printArgs(args: Array[String]): Unit = {var i = 0while (i < args.length) {println(args(i))i += 1}}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

可以通过去掉 var 的办法把这个代码变得更函数式风格:

def printArgs(args: Array[String]): Unit = {for (arg <- args)println(arg)}
1
2
3
4
1
2
3
4

或这样:

def printArgs(args: Array[String]): Unit = {args.foreach(println)}
1
2
3
1
2
3

3.面向对象 :Scala 是纯粹格式的面向对象语言:每个值都是对象,每个操作都是方法调用。

Scala 比 Java 更面向对象的一个方面是 Scala 没有静态成员。Scala 有单例对象: singleton object。除了用 object 关键字替换了 class 关键字以外,单例对象的定义看上去就像是类定义。

import scala.collection.mutable.Mapobject ChecksumAccumulator {private val cache = Map[String, Int]()def calculate(s: String): Int =if (cache.contains(s))cache(s)else {val acc = new ChecksumAccumulatorfor (c <- s)acc.add(c.toByte)val cs = acc.checksum()cache += (s -> cs)cs}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

类和单例对象间的一个差别是,单例对象不带参数,而类可以。因为你不能用 new 关键字实例化一个单例对象,你没机会传递给它参数。每个单例对象都被作为由一个静态变量指向的虚构类:synthetic class的一个实例来实现,因此它们与Java静态类有着相同的初始化语法。 特别要指出的是,单例对象会在第一次被访问的时候初始化。