数组:Array,列表:List,集:Set,映射:Map
1.列表缓存:ListBuffer,数组缓存:ArrayBuffer
2.队列:Queue···先进先出
import scala.collection.immutable.Queue
val empty = new Queue[Int]
val has1 = empty.enqueue(1) //为不可变队列添加元素Queue(1)
val has123 = has1.enqueue(List(2, 3))
//Queue(1, 2, 3)
val (element, has23) = has123.dequeue//队列头部移除元素Queue(2, 3)
//
import scala.collection.immutable.Queue
//可变队列与不可变队列类似
val queue = new Queue[String]
queue += "a"
queue ++= List("b", "c")
//Queue(a, b, c)
3.栈:Stack···后进先出
分可变与不可变,入栈Push,出栈Pop,top:只获取栈顶元素而不移除
import scala.collection.mutable.Stack
val stack = new Stack[Int]
stack.push(1) //Stack(1)
stack.push(2) //Stack(1, 2)
stack.top //Int = 2, Stack(1, 2)
stack.pop //Int = 2, Stack(1)
4.字符串:经RichString隐式转换
5.Set,Map
默认情况下使用“Set”或“Map”时,获得的是不可变对象,可变版本需要先写明引用
集的关键特性在于它可以使用对象的 == 操作检查
scala> val text = "See Spot run.Run, Stop.Run!"
scala> val WordsArray = text.split("[ !,.]+")//有空格
Array(See,Spot,run,Run,Stop,Run)
正则表达式“[” !,.]+"表明字符串应该在每个存在一到多个空格和/或标点符号的地方分割开来
6.集的操作P222,映射的操作P223
7.数组与列表之间的互换
scala> treeSet.toList //List(blue,green,red,yellow)
scala> treeSet.toArray //Array(blue,green,red,yellow)
8.类型参数化:
queues:函数式队列
head:返回队列的第一个元素
tail:返回除第一个元素之外的队列
append:返回尾部添加了指定元素的新队列
/
package ll
/**
* Created by sendoh on 2015/4/17.
*/
class sendoha1 { //快速排序
def sort(xs: Array[Int]): Unit ={
def swap(i: Int, j: Int): Unit ={
val t = xs(i); xs(i) = xs(j); xs(j) = t
}
def sort1(l: Int, r: Int): Unit ={
val pivot = xs((l + r) / 2)
val i = l; var j = r
while (i <= j){
while (xs(i) < pivot)
i += l
while (xs(j) > pivot)
j -= l
if (i <= j){
swap(i, j)
i += l
j -= l
}
}
if (l < j)
sort1(l, j)
if (j < r)
sort1(i, r)
}
sort1(0, xs.length - 1)
}
}
//
package ll
/**
* Created by sendoh on 2015/4/17.
*/
class sendoha2 { //快速排序2
def sort(xs: Array[Int]): Unit ={
if (xs.length <= 1) xs
else{
val pivot = xs(xs.length / 2)
Array.concat(
sort(xs filter(pivot >)), xs filter(pivot ==), sort(xs filter(pivot <))
)
}
}
}
///
ScalaByExample书上的列子
package ll
import java.util.Date
import org.omg.CORBA.TIMEOUT
import scala.actors.Actor
/**
* Created by sendoh on 2015/4/16.
*/
class sendoha3{}
abstract class AuctionMessage
case class Offer(bid: Int, client: Actor) extends AuctionMessage
case class Inquire(client: Actor) extends AuctionMessage
abstract class AuctionReply
case class Status(asked: Int, expire: Date) extends AuctionReply
case object BestOffer extends AuctionReply
case class BeatenOffer(maxBid: Int) extends AuctionReply
case class AuctionConcluded(seller: Actor, client: Actor) extends AuctionReply
case object AuctionFailed extends AuctionReply
case object AuctionOver extends AuctionReply
class Auction(seller: Actor, minBid: Int, closing: Date) extends Actor {
val timeToShutdown = 36000000 //msec
val bidIncrement = 10
def act(): Unit ={
var maxBid = minBid - bidIncrement
var maxBidder: Actor = null
var running = true
while (running){
receiveWithin((closing.getTime() - new Date().getTime())) {
case Offer(bid, client) =>
if (bid >= maxBid + bidIncrement){
if (maxBid >= minBid)
maxBidder ! BeatenOffer(bid)
maxBid = bid; maxBidder = client; client ! BestOffer
} else {
client ! BeatenOffer(maxBid)
}
case Inquire(client) =>
client ! Status(maxBid, closing)
case TIMEOUT =>
if (maxBid >= minBid){
val reply = AuctionConcluded(seller, maxBidder)
maxBidder ! reply; seller ! reply
} else {
seller ! AuctionFailed
}
receiveWithin(timeToShutdown){
case Offer(_, client) => client ! AuctionOver
case TIMEOUT => running = false
}
}
}
}
}