晓新's Blog

Scala学习笔记(一)----基本数据结构和操作符

用eclipse创建工程

  • 在Eclipse中创建一个Scala Project，名称为Helloworld
  • 在projet中创建一个Package
  • 然后在package里新建一个Scala Object,在Scala Object中编写程序。
package test

object HelloWorld {
    def main(args: Array[String]) = println("Hello world!")
}

在命令行编译scala程序

scalac test.scala
scala test

值与变量

值val:赋值后不可变 变量var:赋值后可以改变

val name : type = xxx
var name : type = xxx

一般不需要显式指定类型，因为可以从赋值中推断出来类型。

方法定义

def function(parameter_name : parameter_type) : return_type = {
    //block内最后一行为返回值
}
def function(parameter_name : parameter_type){
    //没有返回值，此时返回值类型是unit，类似于java里的void
}
  • 没有参数的方法可以不带圆括号调用。
  • scala没有静态方法，它是通过object来实现的。
  • 默认参数
  • 带名参数（赋值时顺序可以与定义时顺序不一致）

lazy value

延迟加载的变量，只有到用到时才会去初始化，对于那些很大的对象，这是一个非常有效的初始化方式。

lazy val val_name = val_value

数组

定长数组：

val array_name = new Array[T](length)
val array_name = Array("",""),

通过()访问，这点跟c++，java不同，不是用[]。 变长数组

import scala.collection.mutable.ArrayBuffer
val buff = ArrayBuffer[T]()
+=/++=/insert/remove/toArray/sum/max/reverse

遍历数组

for(i <- 0 until array_name.length)
for(elem <- array_name)

Map

不可变map

val age = Map("Jack" -> 10,"Lucy" -> 20)

可变map

val counts = scala.collection.mutable.Map[String,Int]()

操作： 

map(key)

map.getOrElse(key,default)

map(key)=value

for((k,v) <- map){
    }

for(k <- map.keySet){

for(k <- map.values){
    }

for((k,_) <- map){
    }

元组

元组是()里包含一系列的值，跟数组不同。通过._取值，下标从1开始，例如t._1

操作符

中置操作符

中置操作符实际上是一个方法调用。

1 to 10
1.to(10)

一元操作符

1 toString
1.toString()

结合性

在scala中所有操作符都是左结合的，除了：

  • 以冒号结尾的操作符
  • 赋值操作符
1 :: 2 :: Nil

apply,update方法

apply,update方法在对expre(args)表达式求值时被调用。 apply方法经常用在伴生对象中，用来构造对象而不显示的使用new。当你有大量Fraction的值要构造时，这个改进还是很有用的。

class Fraction(n : Int,d : Int){
    ...
}
object Fraction{
    def apply(n :Int ) = new Fraction(n,d)
}
val result = Fraction(3,4) *Fraction(2,5)

val scores = new scala.collection.mutable.HashMap[String,Int]
scores("Bob")=100//调用scores.update("Bob",100)
val bobsScore = scores("Bob")//调用scores.apply("Bob")

提取器

提取器就是一个带有unapply方法的对象，你可以把unapply方法当做是伴生对象中apply方法的反向操作。apply方法接受构造参数，然后把它们变成对象。而unapply方法接受一个对象，然后从中提取值--通常这些值就是当初用来构造该对象的值。

object Fraction{
    def unapply(input : Fraction) = {
        if(input.den ==0)None else Some ((input.num,input.den))
        }
}
var Fraction(a,b)= Fraction(3,4) *Fraction(2,5)
//a，b被初始化为运算结果的分子和分母

apply和unapply互为反向，但并不是必须的，你也可以用提取器提取对象中的任何信息。

Comments !