Scala学习笔记之Scala标准库

IO

  1.打开Source.fromFile(filename,encoding)

  2.关闭source.close

  3.获取所有行，getLines

  4.迭代行用source.getLines

  5.迭代字符用source

  5.buffered不移动文件指针但是可以读取字符

  @注意文件读取有一个文件的指针，如果文件都到结尾就不能在读到文件了。

隐式转换

定义

隐式转换：是编译器在发生类型不匹配时自动插入的用户自定义的转换函数

语法

1.隐式转换是一个函数，由关键字implicit

implicit def intToString(x: Int) = x.toString

2.命名规则

如果是转换类型

int2Integer

intToInteger

如果是包装

intWrapper

使用

使用已有的类型

转换对象已接受特定类型方法

implicit def stringWrapper(s: String):IndexedSeq[Char] = ...

abc.exists()//string 没有exist方法，但是IndexedSeq有，因此要用隐式转换。

得到的结果如下

stringWrapper("abc").exists()

1.可以把一个简单的类型转换为它的包装类型，这样简单的类可以是丰富的方法，使用完之后又可以转化回来

例如scala中的richInt，RichBoolean以及String和StringOps

Map的魔法

Map中使用的->是一个类，定义在Predef中

package scala

object Predef {

class ArrowAssoc[A](x: A) {

    def ->[B](y: B): Tuple2[A, B] = Tuple2(x, y)

}

implicit def any2ArrowAssoc[A](x: A): ArrowAssoc[A] =new ArrowAssoc(x)

...

}

每次写a->b时，scala都会把a转换为ArrowAssoc,然会调用->方法，得到的结果是一个元祖

隐式参数

Scala集合

数组

var a = Array[int](10)

var s = Array("hello","World")

for yeild 创建一个Array,注意直接使用for不可以

引用元素时用圆括号，事实上由于Array是一个类，因此圆括号表示一个方法，事实上调用的是类中的apply方法

  #多维数组

  var s = Array[Double](10,10)

  var s = Array[Array[Int]](10),注意这儿的第二维没有固定长度，可以在下面赋值

列表

ArrayBuffer

ArrayBuffer用数组实现列表

  var s = new ArrayBuffer[int](10);

  s+=1

  s.toArray

  s.toArray.toBuffer

List

List使用链表来实现队列，在Java中相当于LinkedList

另一种创建方法:val oneTwoThree = 1 :: 2 :: 3 :: Nil

这儿需要Nil的原因是Nil表示空队列，而::定义在队列上，故如果不用3，scala就不知道::是什么的方法

方法

:::

连接两个列表

::

把一个元素添加到列表头，注意他的调用方法，1::List(1,2,3,4)

count

接受一个单参数布尔函数，计算返回值为true的元素

 

drop

从头开始丢弃元素

dropRight

从后面开始丢弃元素

exists

检测符合某个条件的元素是否存在

 

forAll

检测是否所有的列表元素都满足一个条件

 

head

获取头元素

 

tail

得到除头元素以外的所有元素

last

最后一个元素

length

长度

sort

flatmap

使用map可能会产生一个有列表组成的列表，flatMap会把它门重新变成一个列表

partion

partion会把列表中false和true的元素分成两个列表。

scala> List(1, 2, 3, 4, 5) partition (_ % 2 == 0)

res42: (List[Int], List[Int]) = (List(2, 4),List(1, 3, 5))

Nil

Nil表示空队列，和list.isempty相同

空列表

空列表的类型是List[Nothing]

res:ListNothing == List() == Nil

模式匹配

val List(a, b, c) = fruit

val a :: b :: rest = fruit

//其中reset还是一个，列表

语法糖

1.在scala中以冒号结束的操作符调用时要反序

 

元组

在scala中，元祖中可以存储不同类型的对象，且大小不可变，注意从1开始

  声明:(1,"sksk",10.3)

  引用：tuple._2,tuple._1,

  最有用的地方是函数返回多个值

     var (first,second,third) = tuple

使用不同的方法来访问元组中不同的元素的原因是：元组的类型不同。

集合

 

通用规则

  1.不可变的集合在scala.collection.immutable,可变的集合在scala.collection.mutable中

  2.三种数据类型都是iteratable的子类，这意味着所有的集合类型都可以用在for迭代

  3.所有的集合类型都实现了apply和update方法，因此可以不加new创建以及使用()引用元素

  4.Range和Python中的Range类似

  5.对集合使用view方法可以得到一个懒运算的集合，这意味着对集合的运算都是在元素在引用时才得到的，而其他的方法都是一次得到一个集合。

  6.scala提供了线程安全的特质，在构造常规集合时混入即可

  7.使用par方法可以得到一个并行化的集合，对于这个集合的操作都是分块执行的，因此可以并行执行

  @注意不能改变并行计算时的元素

   8.集合都可以使用模板

   9.在集合定义中如果在定义的时候传递了一些初始数据，那么就不用在写明他的类型。但是如果没有那么就要写明类型。

映射

 

例子

import scala.collection.mutable.Map

val treasureMap = Map[Int, String]()

treasureMap += (1 ->"Go to island.")

treasureMap += (2 ->"Find big X on ground.")

treasureMap += (3 ->"Dig.")

println(treasureMap(2))

   1.不可变：

      var score = Map("Alice"->10,"Bob"->12)

   2.可变

      var scores = scala.collection.mutable.Map("Aclic"->10...)

      var scores = new scala.collection.mutable.HashMap[String,Int];//可以用其他Map，如SortedMap

      引用同Python

      更新同Python，不过还有另一种方法，即+=和-=

         score += ("Aclice"->10)

         score -= "Aclice"

   3.迭代

      for((k,v)<-map)

      或使用keyset和values分别引用

XML

表示

Actor

注意

变与不变

scala中的val声明的是不变的引用并不是对象不变，因此要使用不变的类而不是引用。

http://blog.csdn.net/ssjssh/article/details/12126685