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


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值