Scala 开发环境搭建和基础教程

最新推荐文章于 2024-09-20 12:11:07 发布

阿Chen_

最新推荐文章于 2024-09-20 12:11:07 发布

阅读量1k

点赞数

1_为什么选择 Scala?

表达能力
- 函数是一等公民
- 闭包
简洁
- 类型推断
- 函数创建的文法支持
Java互操作性
- 可重用Java库
- 可重用Java工具
- 没有性能惩罚

Scala 如何工作?

编译成Java字节码
可在任何标准JVM上运行
- 甚至是一些不规范的JVM上，如Dalvik
- Scala编译器是Java编译器的作者（Martin OderSky）写的

用 Scala 思考

Scala不仅仅是更好的Java。你应该用全新的头脑来学习它，你会从这些课程中认识到这一点的。

2_创建一个 scala 项目

（1）下载 Intellij IDEA，不要求用破解版：http://www.jetbrains.com/idea/

如果习惯使用 eclipse 可以下载：http://scala-ide.org/

（2）安装插件

如上图，点击右下角的 Configure -> Plugins -> 搜索scala -> 点击蓝色链接Search in xxx -> 安装下图的插件

下载不动就取消了试一下，完成后重启 idea

（3）配置环境，如下图，重启后，点击 Configure -> Project Defaults -> Project Structure

点击 SDKs -> "+" 增加全局 JDK

下载 scala 2.11.11 并安装，因为 spark 最新版用 2.11 编译

https://www.scala-lang.org/download/2.11.11.html

（4）点击初始界面的 Create New Project

如下图，选择左侧的 scala，中部的 IDEA，点击 NEXT

选择 JDK -> 点击 Create... 选择 Scala SDK -> Browse...

完成配置，创建项目，等待 indexing 完成

进入 idea 后，在 src 目录下右击 -> New -> Scala Worksheet，接下来可以学习基本用法

比如：输入 val i = 1 + 2 -> 点击绿色的三角执行

3_Scala 基本用法

值

你可以给一个表达式的结果起个名字赋成一个不变量（val）。

scala> val two = 1 + 1
two: Int = 2

变量

如果你需要修改这个名称和结果的绑定，可以选择使用var。

scala> var name = "steve"
name: java.lang.String = steve

方法

方法是一个以def开头的带有参数列表（可以无参数列表）的一个逻辑操作块，这正如object或者class中的成员方法一样。

scala> def addOne(m: Int): Int = m + 1
addOne: (m: Int)Int

如果方法不带参数，你可以不写括号。

scala> def three() = 1 + 2
three: ()Int

scala> three()
res2: Int = 3

scala> three
res3: Int = 3

函数

函数是一个赋值给一个变量（或者常量）的匿名方法（带或者不带参数列表），并且通过=>转换符号跟上逻辑代码块的一个表达式。=>转换符号后面的逻辑代码块的写法与method的body部分相同。

scala> val f1 = (x: Int) => x+3
f1: Int => Int = <function1>

匿名函数

你可以创建匿名函数。

scala> (x: Int) => x + 1
res2: (Int) => Int = <function1>

这个函数为名为x的Int变量加1。

scala> res2(1)
res3: Int = 2

你可以传递匿名函数，或将其保存成不变量。

scala> val addOne = (x: Int) => x + 1
addOne: (Int) => Int = <function1>

scala> addOne(1)
res4: Int = 2

如果你的方法有很多表达式，可以使用{}来格式化代码，使之易读。

def timesTwo(i: Int): Int = {
  println("hello world")
  i * 2
}

对匿名函数也是这样的。

scala> { i: Int =>
  println("hello world")
  i * 2
}
res0: (Int) => Int = <function1>

在将一个匿名函数作为参数进行传递时，这个语法会经常被用到。

参考函数和方法的区别：
http://www.cnblogs.com/shihuc/p/5082701.html

集合

在 scala.collection.mutable 和 scala.collection.immutable 包下的集合的区别是：是否可以修改集合里面的数据。

序列 Seq 或 List

现版本中，他们指同一个不可变单向链表, 也就是 List。所谓序列，指的是一类具有一定长度的可迭代访问的对象，其中每个元素均带有一个从0开始计数的固定索引位置。

详见 http://docs.scala-lang.org/zh-cn/overviews/collections/seqs.html

scala> val seq = Seq(1, 2, 3)
seq: Seq[Int] = List(1, 2, 3)

链表 scala.collection.mutable.MutableList（可修改的）

相当于 java 的 LinkedList

scala> val mutableList = mutable.MutableList(1, 2, 3)
mutableList: scala.collection.mutable.MutableList[Int] = MutableList(1, 2, 3)

Set

Set 没有重复

scala> val set = Set(1, 2, 3)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

Seq、List、Set 等都从父类里继承了许多相同的增删改查方法，如： seq :+ 1 在序列 seq 的后方追加 1 得到 新序列。

ArrayBuffer

数组缓冲器，可当做 java 的 ArrayList 使用。

scala> val ab = new ArrayBuffer[Int]()
ab += 1             ----在末尾追加一个数字，结果是 1
ab ++= Seq(2,3,4)   ----在末尾追加一个 seq，结果是 1,2,3,4

元组 Tuple

元组是在不使用类的前提下，将元素组合起来形成简单的逻辑集合。

scala> val hostPort = ("localhost", 80)
hostPort: (String, Int) = (localhost, 80)

与样本类不同，元组不能通过名称获取字段，而是使用位置下标来读取对象；而且这个下标基于1，而不是基于0。

scala> hostPort._1
res0: String = localhost

scala> hostPort._2
res1: Int = 80

元组可以很好得与模式匹配相结合。

hostPort match {
  case ("localhost", port) => ...
  case (host, port) => ...
}

在创建两个元素的元组时，可以使用特殊语法：->

scala> 1 -> 2
res0: (Int, Int) = (1,2)

参考 Effective Scala 对解构绑定（“拆解”一个元组）的观点。

映射 Map

它可以持有基本数据类型。

Map(1 -> 2)
Map("foo" -> "bar")

这看起来像是特殊的语法，不过不要忘了上文讨论的->可以用来创建二元组。

Map()方法也使用变参列表：Map(1 -> "one", 2 -> "two")将变为 Map((1, "one"), (2, "two"))，其中第一个参数是映射的键，第二个参数是映射的值。

映射的值可以是映射甚或是函数。

Map(1 -> Map("foo" -> "bar"))

Map("timesTwo" -> { timesTwo(_) })

选项 Option

Option 是一个表示有可能包含值的容器。

Option基本的接口是这样的：

trait Option[T] {
  def isDefined: Boolean
  def get: T
  def getOrElse(t: T): T
}

Option本身是泛型的，并且有两个子类： Some[T] 或 None

我们看一个使用Option的例子：

Map.get 使用 Option 作为其返回值，表示这个方法也许不会返回你请求的值。

scala> val numbers = Map("one" -> 1, "two" -> 2)
numbers: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)

scala> numbers.get("two")
res0: Option[Int] = Some(2)

scala> numbers.get("three")
res1: Option[Int] = None

现在我们的数据似乎陷在Option中了，我们怎样获取这个数据呢？

直觉上想到的可能是在isDefined方法上使用条件判断来处理。

// We want to multiply the number by two, otherwise return 0.
val result = if (res1.isDefined) {
  res1.get * 2
} else {
  0
}

我们建议使用getOrElse或模式匹配处理这个结果。

getOrElse 让你轻松地定义一个默认值。

val result = res1.getOrElse(0) * 2

模式匹配能自然地配合Option使用。

val result = res1 match {
  case Some(n) => n * 2
  case None => 0
}

参考 Effective Scala 对使用Options的意见。

函数组合子（Functional Combinators）

List(1, 2, 3) map squared对列表中的每一个元素都应用了squared平方函数，并返回一个新的列表List(1, 4, 9)。我们称这个操作map 组合子。他们常被用在标准的数据结构上。

map

map对列表中的每个元素应用一个函数，返回应用后的元素所组成的列表。

scala> numbers.map((i: Int) => i * 2)

或 scala> numbers.map(_ * 2)

res0: List[Int] = List(2, 4, 6, 8)

foreach

foreach很像map，但没有返回值，无法改变内部数据，常用作输出到外部，如 hbase。

numbers.foreach(println(_)) 或  numbers.foreach(println)

什么也没有返回。

你可以尝试存储返回值，但它会是Unit类型（即void）

scala> val doubled = numbers.foreach(_ * 2)
doubled: Unit = ()

filter

filter移除任何对传入函数计算结果为false的元素。返回一个布尔值的函数通常被称为谓词函数[或判定函数]。

scala> numbers.filter(_ % 2 == 0)
res0: List[Int] = List(2, 4)

scala> def isEven(i: Int): Boolean = i % 2 == 0
isEven: (i: Int)Boolean

scala> numbers.filter(isEven _)
res2: List[Int] = List(2, 4)

官方中文教程：点击打开链接

我的 Spark SQL 本地开发基础教程