scala语法

最新推荐文章于 2025-07-09 16:52:53 发布

王里扬洛夫

最新推荐文章于 2025-07-09 16:52:53 发布

阅读量1.7k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： scala

本文链接：https://blog.youkuaiyun.com/sinat_22336563/article/details/72900264

scala 专栏收录该内容

1 篇文章

订阅专栏

根据documents记录一些零碎的知识点，学习一定程度后再总结一下。

1 basic

1.1 Variables and Values

Variables和Values分别用var和val表示，他们之间的区别是var可以重复赋值，而val赋值后不可改变，相当于const。

val x = 1+1
var y: Int = 1 + 1
y = 3

变量的type类似c++11中auto会自己推断，同时也可以显式地标明：

val x: Int = 1+1

用{}将表达式圈起来就是一个blocks，相当于一个作用域，最后的一行表达式的输出就是blocks的输出：

println({
  val x = 1 + 1
  x + 1
}) // 3

1.2 function

带参数的表达式就是函数。

匿名函数：
()括号内是参数：

(x: Int) => x + 1

named函数：

val getAns = () => 4

单个参数：

val add = (x: Int) => x + 1
println(add(1))

多个参数

val add = (x: Int, y: Int) => x + y

=>右边就是带有参数的表达式

高阶函数

高阶函数：其他函数做参数或者是其结果的函数。

c++只能调用函数指针，来实现上述形式。

def apply(f: Int => String, v: Int) = f(v)

1.3 method

method结构： def关键字，方法名，多个参数列表或者没有参数列表，返回类型，body

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier

如果返回类型是Unit，那么就表示viod，只是scala每个表达式必须返回一个值，所以用Unit，表示没有什么信息。

1.4 Classes

类的构成：

类名，构造参数

class Greeter(prefix: String, suffix: String) {
  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!

默认构造函数

class Point(var x: Int = 0, var y: Int = 0)
val origin = new Point  // x and y are both set to 0
val point1 = new Point(1)
println(point1.x)  // prints 1

默认构造下只想手动赋值非第一个的参数，需要指明参数名称

class Point(var x: Int = 0, var y: Int = 0)
val point2 = new Point(y=2)
println(point2.y)  // prints 2

private，将变量与类外隔离；与c++类似可以用def方法读取私有变量

private[A]会增加可见范围到A。

val修饰的变量默认为公有的，没有val即为私有；

class Point {
  private var _x = 0
  private var _y = 0
  private val bound = 100
  def x = _x
  def x_= (newValue: Int): Unit = {
    if (newValue < bound) _x = newValue else printWarning
  }
  def y = _y
  def y_= (newValue: Int): Unit = {
    if (newValue < bound) _y = newValue else printWarning
  }
  private def printWarning = println("WARNING: Out of bounds")
}

抽象类：

abstract class Element {  //abstract表示抽象类
    def contents: Array[String]  //没有函数体表示声明抽象方法
}

无参函数和属性, 统一访问模式

abstract class Element {
   def contents: Array[String]  //组合Array[] 
   def height: Int = contents.length //无参函数
   def width: Int = if (height == 0) 0 else contents(0).length
}
//等同于
abstract class Element {
    def contents: Array[String]
    val height = contents.length //属性
    val width = if (height == 0) 0 else contents(0).length
}

1.5 case

该类在类前加case关键字，不可修改并且之间可以比较大小

case 类最基本形式：
case calss + 名字 + 参数列表

实例化不需要new，因为该类有默认的apply方法构造。

case class Message(sender: String, recipient: String, body: String)//变量类型为val public
val message1 = Message("guillaume@quebec.ca", "jorge@catalonia.es", "Ça va ?")//实例化该类不需要new关键字

message1.sender = "travis@washington.us"  // val是immutable的

case实例的比较：比较基于结构而不是引用，虽然两者明显指向的对象不一样，但是仍然可以进行比较。

case class Message(sender: String, recipient: String, body: String)
val message2 = Message("jorge@catalonia.es", "guillaume@quebec.ca", "Com va?")
val message3 = Message("jorge@catalonia.es", "guillaume@quebec.ca", "Com va?")
val messagesAreTheSame = message2 == message3  // true

case的复制：

case class Message(sender: String, recipient: String, body: String)
val message4 = Message("julien@bretagne.fr", "travis@washington.us", "Me zo o komz gant ma amezeg")
val message5 = message4.copy(sender = message4.recipient, recipient = "claire@bourgogne.fr")
message5.sender  // travis@washington.us
message5.recipient // claire@bourgogne.fr
message5.body  // "Me zo o komz gant ma amezeg"

因为可变和不可变的区别，所以使用val相对case来说更安全。

1.6 Traits

traits相当于Java接口，但是功能更加强大，因为他还可以定义属性和方法。

与generic class和abstract method结合：

trait Iterator[A] {
  def hasNext: Boolean
  def next(): A
}

因为scala的类仅继承单一父类，但是特征却可以多重继承。

extend和with

extend, implicitly inherit the trait’s superclass

class Frog extends Philosophical { //mix in Philosophical trait
    override def toString = "green"//override子类覆写父类方法
}

with, 需要显式的指明超类

class Animal
trait HasLegs
class Frog extends Animal with Philosophical with HasLegs {//继承Animal,并mix in两个traits
    override def toString = "green"
}

1.7 type

类型体系：
这里写图片描述

类型转换顺序：
这里写图片描述

编译时Scala自动对应到Java原始类型，提高运行效率。Unit对应java的void

隐式转换

implicit def foo(s:String):Int = Integer.parseInt(s) // 需要时把String->Int
def add(a:Int, b:Int) = a+b
add("100",8) // 108, 先把"100"隐式转换为100

1.8 各种关键字

1.8.1 require

def f(n:Int) = { require(n!=0, "n can't be zero"); 1.0/n }

1.8.2 application

不带命令行参数的简化main方法：
object app1 extends Application {
    println("hello world")
}

1.8.3 for循环

for (i <- 0 to n) foo(i) // 包含n，即Range(0,1,2,...,n,n+1)
for (i <- 0 until n) foo(i)  // 不包含n，即Range(0,1,2,3,...,n)

1.8.4 reduceLeft /foldLeft /scanLeft

def fac(n: Int) = 1 to n reduceLeft(_*_)
fac(5) // 5*4*3*2 = 120
相当于：
    ((((1*2)*3)*4)*5)

def sum(L: Seq[Int]) = L.foldLeft(0)(_ + _)//累加
def multiply(L: Seq[Int]) = L.foldLeft(1)(_ * _)//累积

List(1,2,3,4,5).scanLeft(0)(_+_) // (0,1,3,6,10,15)
相当于：
(0,(0+1),(0+1+2),(0+1+2+3),(0+1+2+3+4),(0+1+2+3+4+5))

注：
@ (z /: List(a, b, c))(op) 相当于 op(op(op(z, a), b), c)
简单来说：加法用0，乘法用1
@ (List(a, b, c) :\ z) (op) equals op(a, op(b, op(c, z)))
此处省略一万字。。。。。。。。。。。。。。。

1.8 pattern matching

1.8.1 定义

value match expression，起作用类似if else

def matchTest(x: Int): String = x match {
  case 1 => "one"
  case 2 => "two"
  case _ => "many" //类似case中的default
}
matchTest(3)  // many
matchTest(1)  // one

1.8.2 与case class

def showImportantNotification(notification: Notification, importantPeopleInfo: Seq[String]): String = {
  notification match {
    case Email(email, _, _) if importantPeopleInfo.contains(email) =>
      "You got an email from special someone!"
    case SMS(number, _) if importantPeopleInfo.contains(number) =>
      "You got an SMS from special someone!"
    case other =>
      showNotification(other) // nothing special, delegate to our original showNotification function
  }
} 



val importantPeopleInfo = Seq("867-5309", "jenny@gmail.com")
val someSms = SMS("867-5309", "Are you there?")
val someVoiceRecording = VoiceRecording("Tom", "voicerecording.org/id/123")
val importantEmail = Email("jenny@gmail.com", "Drinks tonight?", "I'm free after 5!")
val importantSms = SMS("867-5309", "I'm here! Where are you?")
println(showImportantNotification(someSms, importantPeopleInfo))
println(showImportantNotification(someVoiceRecording, importantPeopleInfo))
println(showImportantNotification(importantEmail, importantPeopleInfo))
println(showImportantNotification(importantSms, importantPeopleInfo))

1.8.3 Matching on type only

abstract class Device
case class Phone(model: String) extends Device{
  def screenOff = "Turning screen off"
}
case class Computer(model: String) extends Device {
  def screenSaverOn = "Turning screen saver on..."
}
def goIdle(device: Device) = device match {
  case p: Phone => p.screenOff
  case c: Computer => c.screenSaverOn
}

1.8.4 Sealed classes

sealed abstract class Furniture
case class Couch() extends Furniture
case class Chair() extends Furniture
def findPlaceToSit(piece: Furniture): String = piece match {
  case a: Couch => "Lie on the couch"
  case b: Chair => "Sit on the chair"//不需要catch all了
}

1.9 Regular Expression Patterns

任何string对象都可以转换成正则表达式：

import scala.util.matching.Regex
val numberPattern: Regex = "[0-9]".r//在string后加.r

1.10 For Comprehensions

for (enumerators) yield e

enumerators：可以是generator，或者是filter；

满足要求的就可以将e加入到一个list中

def foo(n: Int, v: Int) =
   for (i <- 0 until n;
        j <- i until n if i + j == v)
   yield (i, j)
foo(10, 10) foreach {
  case (i, j) =>
    print(s"($i, $j) ")  // prints (1, 9) (2, 8) (3, 7) (4, 6) (5, 5)
}

1.11 Variances

Covariance

如果有class List[+A]，则表示该类是covariance。那么如果A是B的subtype，那么List[A]也是List[B]的subtype。

那么就可以在有List[B]的情况下用List[A]替换掉。

Contravariance

如果有class List[-A]，那么如果A是B的subtype，那么List[B]是List[A]的subtype。

Invariance

正常情况下，A和B的关系不影响其List之间的关系

type bounds

class PetContainer[P <: Pet](p: P) {
  def pet: P = p
}

[P <: Pet]表示，该类的参数必须是Pet的subtype

1.12 Abstract Types

抽象的type意味着具体的type需要根据实现来定义：

trait Buffer {
  type T
  val element: T//element的类型是T
}

抽象类extends了traits：
SeqBuffer 类的新类型必须是

abstract class SeqBuffer extends Buffer {
  type U
  type T <: Seq[U]
  def length = element.length
}

Compound Types

def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
  //...
}

Polymorphic Methods

与generic class相似，[A]表示某个type

def listOfDuplicates[A](x: A, length: Int): List[A] = {
    if (length < 1)
        Nil
    else
        x :: listOfDuplicates(x, length - 1)
}
println(listOfDuplicates[Int](3, 4))  // List(3, 3, 3, 3)
println(listOfDuplicates("La", 8))  // List(La, La, La, La, La, La, La, La)

Local Type Inference

类型推断，编译器可以根据表达式进行类型推断，而不用每次都显式地标明。

Polymorphic Methods或者generic class中也可以进行类型推断。

object InferenceTest1 extends App {
  val x = 1 + 2 * 3         // the type of x is Int
  val y = x.toString()      // the type of y is String
  def succ(x: Int) = x + 1  // method succ returns Int values
}

但是如果返回值是一个递归调用方法，那么类型推断将失效。

以下情况类型推断将会出错：

object InferenceTest4 {
  var obj = null
  obj = new Object()
}

By-name Parameters与By-value Parameters

def calculate(input: => Int) = input * 37//By-name

By-name在不需要的时候不会evaluated，
By-value 在一开始就会且仅会evaluated一次。

2 OO

2.1 Generic Classes

将type作为一个参数的类

类名后加[A]，将type A作为参数传入

class Stack[A] {//以下操作都只对type A有用
  private var elements: List[A] = Nil
  def push(x: A) { elements = x :: elements }
  def peek: A = elements.head
  def pop(): A = {
    val currentTop = peek
    elements = elements.tail
    currentTop
  }
}

如果type下面还有subtype，那么对于subtype同样适用

class Fruit
class Apple extends Fruit
class Banana extends Fruit
val stack = new Stack[Fruit]
val apple = new Apple
val banana = new Banana
stack.push(apple)
stack.push(banana)

2.2 singleton object

用object代替class
现在，sum可以通过import test .Blah.sum导入了

package test
object Blah {
  def sum(l: List[Int]): Int = l.sum
}

Scala不能定义静态成员, 所以用Singleton对象来达到同样的目的

import ChecksumAccumulator.calculate
  object Summer {
    def main(args: Array[String]) {
      for (arg <args)
        println(arg +": "+ calculate(arg))
    }
}

2.3 继承

超类的私有成员不会被子类继承.
抽象成员, 需要被子类实现(implement)
一般成员, 可用被子类重写(override)

重写方法和属性，两者不能重名，但是可以转换。

参数化属性

class ArrayElement( val contents: Array[String] ) extends Element //实现属性

final成员

加在method前，表示成员函数禁止被任何子类override
加在class前，表示该类禁止被任何子类继承

2.4 Extractor Objects

用法

import scala.util.Random
object CustomerID {
  def apply(name: String) = s"$name--${Random.nextLong}"//apply方法创造一个实例
  def unapply(customerID: String): Option[String] = {
    val name = customerID.split("--").head
    if (name.nonEmpty) Some(name) else None
  }//unapply做了反操作，提取出name
}
val customer1ID = CustomerID("Sukyoung")  // 创造了实例

val customer2ID = CustomerID("Suhal") //等价于val name = CustomerID.unapply(customer2ID).get

val CustomerID(name) = customer2ID//用于赋值


customer1ID match {
  case CustomerID(name) => println(name)  // prints Sukyoung
  case _ => println("Could not extract a CustomerID")
}

返回值

仅仅是测试，返回 Boolen即可；
返回一个子值，返回Option[T]；
返回多个子值，返回Option[(T1,…,Tn)]。

None：Option的两个子类之一，另一个是Some，用于安全的函数返回值

数据结构

数组

可变的同类对象序列, 适用于OO场景

val greetStrings = new Array[String](3) //greetStrings为val, 但是内部的数组值是可变的
greetStrings(0) = "Hello"  //greetStrings.apply(0)，所以用()
greetStrings(1) = ", "
greetStrings(2) = "world!\n"
//简单初始化
val numNames = Array("zero", "one", "two")

对应可变的：

val ab = collection.mutable.ArrayBuffer[Int]()
ab += (1,3,5,7)
ab ++= List(9,11) // ArrayBuffer(1, 3, 5, 7, 9, 11)
ab toArray // Array (1, 3, 5, 7, 9, 11)
ab clear // ArrayBuffer()

List

List为不可变对象序列

对于List最常用的操作符为::, cons, 把新的elem放到list最前端
:::, 两个list的合并

Nil：长度为0的List

Queues

import scala.collection.immutable.Queue //不可变Queue

val has1 = empty.enqueue(1)//入队
val has123 = has1.enqueue(List(2, 3)) //添加多个元素
val (element, has23) = has123.dequeue //取出头元素,返回两个值, 头元素和剩下的queue

import scala.collection.mutable.Queue //可变Queue

queue += "a"  //添加单个
queue ++= List("b", "c") //添加多个
queue.dequeue //取出头元素, 只返回一个值

Stacks

import scala.collection.mutable.Stack

Tuple

tuple和list一样是不可变的, 不同是, list中的elem必须是同一种类型, 但tuple中可以包含不同类型的elem

val pair = (99, "Luftballons")
println(pair._1) //从1开始的！

Set和Map

Scala需要兼顾OO和FP, 所以需要提供mutable和immutable版本
默认是Immutable, 如果需要使用mutable版本, 需要在使用前显示的引用

Sorted Set and Map

基于红黑树实现的有序的Set和Map