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
          }
      }
    }
  }
}