scala学习笔记(9-12)

2017-07-31  本文已影响35人  zlcook

目录

9.文件和正则表达式

val source = Source.fromFile("myfile.txt","UTF-8")
source.getLines

访问目录

  def subdirs(dir:File):Iterator[File]={
    val children = dir.listFiles().filter(_.isDirectory)
    children.toIterator ++ children.toIterator.flatMap(subdirs(_))
  }

  def main(args: Array[String]): Unit = {
    val dirStr = "C:\\Users\\zhouliang6\\Desktop\\项目";
    val dir = new File(dirStr)
    for( d <- subdirs(dir)) println(d.toString)
  }

序列化

序列化反序列化

进程控制

import sys.process._
"ls -al .."!

正则表达式组

image.png

《快学Scala》第九章习题解答

10.特质

叠加在一起的特质

带有特质的对象


trait Logged {
  def log (msg :String){ } //有实现，非抽象方法  
}

class SavingAccount extends  Logged{
  def withdraw(ammount:Double): Unit ={
    log("withdraw :"+ammount)
  }
}

trait ConsLogger extends Logged{                  //重写特质Logged的log方法
  override def log(msg:String){println(msg)}
}

object SavingAccount{
  def main(args: Array[String]): Unit = {
    val acct = new SavingAccount with ConsLogger      //构造对象时候加入特质
    acct.withdraw(100)
  }
}

特质中抽象字段和具体字段

trait ShortLogger{
  val maxLength:Int      //注：该抽象字段并没有在特质的构造器中使用，如果在构造器中使用了，则下面方法有误
}
class SavingAccount extend Account with ShortLogger{
  val maxLength = 20 //不需要override
}
val acct1 = new SavingsAccount 
val acct2 = new SavingsAccount with ShrotLogger{ 
   val maxLength = 20 
}

特质构造顺序

初始化特质中的字段

抽象字段在构造中使用后，在子类中如何初始化抽象字段 方法二：定义类时提前定义 方法三：使用懒值

扩展类的特质

trait PropertyChange extends PropertyChangeSupport{
}
class MyPoint extends PropertyChange{
}
class  Test extends  App{
  val myp = new MyPoint
}

class MyPoint extends Exception with PropertyChage            //错误，因为Exception不是PropertyChangeSupport的子类

自身类型

　this:类型 =>
image.png

快学scala第十章习题答案

11.操作符

apply和update方法

案例

提取器

* Name对象，其unapply方法返回一个Option[(String,String)]
object Name{
  def unapply(input:String)={
  val pos = input.indexOf(" ")
  if( pos == -1 ) None
  else Some( (input.substring(0,pos) , input.substring(pos+1) )
  }
}

1.变量定义时使用，如下first、last变量
val author ="Cay Horstmann"   
val Name(first,last) =author 
// 实际调用Name.unapply(author )并返回(Cay,Horstmann)元组，然后将元组值赋给first、last

2.模式匹配中使用
author match{
   case Name(a,b) => ...a,b分别绑定到Option的值上

}

带单个参数或无参数的提取器

使用unapply提取单值，则返回一个目标类型Option
object Number{

 def unapply(input: String ):Option[Int] ={
   try{
    Some(  Integer.parseInt( input.trim ) )
   }catch{
    case ex :NumberFormatException => None
   }
 }
}

使用：定义变量n
val Number( n ) = "123"

// unapply返回Boolean,
object IsCompond{
 def unapply(input: String )= input.contains(" ")
}

使用：
author match{
   case Name(a, last @ IsCompound() ) => ...a,b分别绑定到Option的值上,

}

unapplySeq方法

object Name{
   def unapplySeq(input:String):= Option[ Seq[String] ]={
     if( input.trim == "" ) None
     else Some( input.trim.split( "\\s+" ) )
  }
}

12.高阶函数

作为值得函数

import scala.math._
val num =3.14
val fun = ceil _    //函数
fun(num)       // 4

匿名函数

带函数参数的函数

valueAtOneQuarter(ceil _)
def valueAtOneQuarter( f:(Double) => Double ) = f(0.25)

 def mulBy(factor：Double) = (x :Double) => factor * x

参数（类型）推断

def valueAtOneQuarter( f:(Double) => Double ) =f(0.25)

常用高阶函数

def map[B](f: (A) ⇒ B): [Array][B]

(1 to 9).map("*" * _).foreach(println _)

传入的匿名函数的非简写形式：(x:Int)=>"*" * x

 Array("z","liang").map( "jd" + _).foreach(println _)
 Array("z","liang").map( (x:String)=>"jd" + x ).foreach(println _)

传入的匿名函数的非简写形式：(x:String)=>"jd" + x

柯里化

def mul(x:Int ,y:Int) =x * y

定义柯里化函数

def mulOneAtAtime(x:Int ) = (y: Int) => x * y

调用:mulOneAtAtime(6)(7) ，
调用过程mulOneAtAtime(6)结果是(y :Int)=>6 * y ,这个函数被应用到7,最终得到42

def mulOneAtAtime(x: Int)(y: Int) = x * y

目的：可以把某个函数参数单领出来，已提供更多用于类型推断的信息。

柯里化典型案例

控制抽象

def box(){
println("hi");
Thread.sleep(1000)
}

def runInThread(block: ()=>Unit){
  new Thread{
   override def run(){ block() }
  }.start()
}

runInThread{ ()=> println("hi"); Thread.sleep(1000); }

def runInThread(block: =>Unit){
  new Thread{
   override def run(){ block }
  }.start()
}

runInThread{  println("hi"); Thread.sleep(1000); }

柯里化

var  x =10
until( x== 0) {
  x -= 1
 println(x)
}
上一篇 下一篇

猜你喜欢

热点阅读