scala

第一个Scala程序

从Hello World开始

object Hello extends App {
  println("Hello, world")
}

Scala REPL

REPL( read - evaluate - print - loop ) 命令行解释器。理解起来就是我们浏览器开发工具中的console.
它能根据我们的输入进行计算,然后将计算结果输出到终端,并等待用户的下一步输入

可以借助scala repl工具,快速验证我们的代码逻辑,我比较喜欢这种即时反馈的方式。

scala> val x = 1
x: Int = 1

scala> val y = x + 1
y: Int = 2

变量声明(val 和 var)

val 使用val声明的变量为不可变变量, 等同于Java中使用final修饰的变量(比较推荐使用,-- 函数式编程中,不可变原则)
var 使用var声明的变量为可被修改的变量,在scala中,一般更加推荐使用val来修饰变量,除非有特殊原因,才选择var。

var creates a mutable variable, and should only be used when there is a specific reason to use it

val x = 1   //immutable
var y = 0   //mutable

定义变量类型

在scala中,创建变量时并不需要指定他们的类型。Scala能够帮我们处理类型映射。
此功能称为类型推断,它是确保代码简洁的好方法。
比如:

val x = 1
val s = "a string"
val p = new Person("Regina")

也可以显式声明变量的类型,但是,写多Scala代码之后,会觉得并无必要显式声明变量的类型:

val x: Int = 1
val s: String = "a string"
val p: Person = new Person("Regina")

流程控制

if / else

Scala的 if/else 和其他语言相似

if (test1) {
  doA()
} else if (test2) {
  doB()
} else if (test3) {
  doC();
} else {
  doD();
}

但是,与其他语言有所区别的是,if/else 会返回值,所以,我们可以像下面这样写:

val x = if (a < b)  a else b

在Scala中,不支持三目运算符哦.

match expressions

就像是switch . case 的用法,同样,它也是可以返回值的情况.

val result = i match {
    case 1 => "one"
    case 2 => "two"
    case _ => "not 1 or 2"
}

代码中,用于匹配的数据类型,可以为任意的数据类型.

val booleanAsString = bool match {
    case true => "true"
    case false => "false"
}

以下是另一个处理不同类型匹配的方法代码:

def getClassAsStrin (x: Any): String = x match {
    case s: String => s + " is a String"
    case i: Int=> "Int"
    case f: Float=> " Float"
    case l: Listp[_]=> "List"
    case s: Person=> "Person"
    case _ => "Unknown"
}

强大的匹配表达式,也是Scala的一大特性。

try/catch

用于异常捕获。功能与Java相似,不同的是其语法。

try {
    writeToFile(text)
} catch {
    case fnfe: FileNotFoundException => println(fnfe)
    case ioe: IOException => println(ioe)
}

for循环

要掌握一个符号 <- ,这个符号的右边是一个数据集合,符号的左边是当前循环变量。

for (arg <- args) println(arg)

// "x to y" syntax
for (i <- 0 to 5) println(i)

// "x to y by" syntax
for (i <- 0 to 10 by 2) println(i)

yield 可以令每一次循环的结果都记录返回。比如:

val x = for (i <- 1 to 5) yield i * 2

另一个例子:

val fruits = List("apple", "banana", "lime", "orange")
val fruitsLengths = for {
    f <- fruits
    if f.length > 4
} yield f.length

while 和 do..while

// ( while loop )
while(condition) {
    statement(a)
    statement(b)
}

// ( do-while )
do {
   statement(a)
   statement(b)
}  while(condition)

定义一个类

class Person(var firstName: String, var lastName: String) {
  def printFullName () = println(s"$firstName $lastName")
}

类的使用

val p = new Person("J", "Paul")
println(p.firstName)
println(p.lastName)
p.printFullName()

方法

方法声明

Scala的类也同样可以拥有方法,定义scala方法的方式如下:

def sum(a: Int, b: Int) = a + b
def concatenate(s1: String, s2: String) = s1 + s2

方法调用

val x = sum(1, 2)
val y = concatenate("foo", "bar")

scala的方法参数还支持提供默认值哦.

Traits

trait 用于特征,它包含的是一组方法,这组方法的功能围绕其定义的特征。让您将代码分解为小型模块化单元。

下面我们定义两种行为特征:

trait Speaker {
  def speak(): String  // has no body, so it’s abstract
}
trait Runner {
  def startRunning(): Unit = println("I'm running")
  def stopRunning(): Unit = println("Stopped running")
}

class Dog(name: String) extends Speaker with Runner {
    def speak(): String = "Woof!"
}


如果 trait 中包含抽象方法,则继承该 trait 的非抽象类需要提供该方法的方法实现。

集合类

如果您是从Java来的Scala,并且已经准备好真正地学习Scala,则可以在Scala中使用Java集合类,有些人会花几个星期或几个月的时间来熟悉Scala。
但是强烈建议您学习基本的Scala集合类

List, ListBuffer, Vector, ArrayBuffer, Map, and Set

Scala集合类的一大优点是,它们提供了许多强大的方法,让我们编写出更加简化的代码。

List - 添加元素

可以有多种添加元素的方式,比如:

val nums = List.range(0, 10)
val nums = (1 to 10 by 2).toList
val letters  = ('a' to 'f').toList
val letters = ('a' to 'f' by 2).toList

集合 - 操作

集合遍历的方式有多种,这些遍历方式适用的集合类型有 Array, ArrayBuffer, Vector, List,还有更多其他的..

数据准备:

val nums = (1 to 10).toList
val names = List("joel", "ed", "chris", "maurice")

遍历 - foreach

foreach 循环比遍历元素.

names.foreach(println)

// 输出结果:
/*
  joel
  ed
  chris
  maurice
*/

条件过滤 - filter

对集合元素过滤.得到新的集合.
使用filter,我们需要提供一个布尔表达式.
在集合中满足该表达式的元素将被筛选下来,这些被选中的元素数据,将作为集合形式由filter方法返回。

nums.filter(_ < 4).foreach(println)
/*
输出结果:
1
2
3
*/

元素映射 - map

集合的map函数,提供了一种根据当前元素衍生成另一种元素的方式。
使用map函数,我们需要提供处理(转换)元素的方法,。这个方法将作为map函数的参数,在map内部中会令每一个元素都根据我们提供的方法转换数据,最后转换结果数据以新集合的形式由map方法返回。

// 每个元素值乘以2后返回
scala> val doubles = nums.map(_ * 2)
doubles: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

// 每个元素处理成首字母大写情况后返回
scala> val capNames = names.map(_.capitalize)
capNames: List[String] = List(Joel, Ed, Chris, Maurice)

// 每个元素处理成布尔值后返回
scala> val lessThanFive = nums.map(_ < 5)
lessThanFive: List[Boolean] = List(true, true, true, true, false, false, false, false, false, false)

Scala 的集合类还提供了更多使用的方法,后面继续发掘。
可以从这些教程中获得更多Scala集合类的使用方法
the Scala Book collections lessons

the Mutable and Immutable collections overview

元组 - Tuples

元组,也是存放元素的集合类型,它的语法如下:

val t = (11, "Eleven", new Person("Eleven"))

我们可以通过元素在元组中的序号来访问,也可以为元组中元素分配到具名的变量中。

val (num, string, person) = (11, "Eleven", new Person("Eleven"))

你可能感兴趣的:(scala)