spark：学习杂记+快速排序--26

数组：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
}
}
}
}
}