Scala Cookbook

Scala Cookbook


for(i<-Array(1,2,3)) println(i) / 遍历


//for yield


for(i<-Array(1,2,3)) yield i*2


Array(1,2,3).map(_*2)


val nums=List(1,2,3,4,5).filter(_<4)
val nums=List(1,2,3,4,5).filter(_<4).map(_*2)


"Hello World".getClass.getName
"Hello".foreach(println)


for(c<-"Hello") println(c)
s.getBytes.foreach(println)


val result="hello world".filter(_!='l')


//向封闭类添加方法
"scala".drop(2).take(2).capitalize


val s1="Hello"
val s2="Hello"
val s3="H"+"ello"


s1==s3
val s4:String=null


s1.toUpperCase==s3.toUpperCase


s1.equalsIgnoreCase(s3)


val foo="""this is a
        multiline String"""

val speech="""Four score and 
              |seven years ago""".stripMargin
  
val speech="""Four score and
              #seven years ago"""
  
val speech="""Four score and
            | seven year ago
            | our father""".stripMargin.replaceAll("\n","")



"hello world".split(" ").foreach(println)
val s="eggs,milk,butter,Coco Puffs"


s.split(",").map(_.trim)


"hello world".split("\\s+")




字符串插值
val name="job"
val age=33
val weight=300.00
println(s"$name is large")


在字符串中使用表达式
println(s"$name is ${age +1} years old")


case class Student(name:String, score:Int)
val hannah=Student("Hannel",95)
println(s"${hannah.name} has a score of ${hannah.score}")
println(f"$name is $age years old, and weight $weight%.2f pounds/")


raw 插入符
raw"foo\nbar"


val s="%s is %d years old".format(name,age)


val upper=for(c<-"hello,word") yield c.toUpper


// for /yield
val result=for {
c<-"hello,world"
if c!='l'
} yield c.toUpper


"Hello".map(c=>(c.toByte+32).toChar)
//定义方法
def toLower(c:Char):Char=(c.toByte+32).toChar 
"Hello".map(toLower)


for (c<-s)yield toLower(c)
//定义函数  注意不同点
val toLower=(c:Char)=>(c.toByte+32).toChar
"Hello".map(toLower)


//案例
package tests
object Adler32Checksum{
  val MOD_ADLR=65521
  def main(args:Array[String]): Unit ={
    val sum=adler32sum("wikipedia")
    printf("checksum(int)=%d\n",sum)
    printf("checksum(hex)=%s\n",sum.toHexString)
  }
  def adler32sum(s: String):Int={
    var a=1
    var b=0
    s.getBytes.foreach{char=>
      a=(char+a)% MOD_ADLR
      b=(b+a) % MOD_ADLR
    }
    b*65536+a
  }
}


字符串中的查找模式
val numPattern="[0-9]+".r
val address="123 Main Street Suite 101"
val match1=numPattern.findFirstIn(address)
val matches=numPattern.findAllIn(address)
matches.foreach(println)


val matches=numPattern.findALLIn(address).toArray


import scala.util.matching.Regex
val numPattern=new Regex("[0-9]+")
val result=numPattern.findFirstIn(address).getOrElse("no match")
match1.foreach{e=>
|println(s"Found a match:$e")
}




字符串中的替换模式
val address="123 Main street".replaceAll("[0-9]","x")
val regex="[0-9]".r
val newAddress=regex.replaceALLIn("123 Main Street",x)


抽取String中模式匹配的部分
val pattern="([0-9]+)([A-Za-z]+)".r
val pattern(count, fruit)="100 Bananas"




textUserTyped match{
case moviesZipRE(zip)=>getSearchResults(zip)
case _=>println("didn't match a regex")
}


访问字符串中的一个字符
“Hello".charAt(0)
"Hello"(0)
"Hello".apply(1)




在String中添加自定义方法
//隐式转换
implicit class StringImprovements(s:String){
|def increment=s.map(c=>(c+1).toChar)
|}


val result="HAL".increment




package com.alvinalexander.utils
object StringUtils {
implicit class StringImprovements(val s:String){
def increment =s.map(c=>(c+1).toChar)
}
}
//定义隐式转换，然后在其它地方使用


package foo.bar
import com.alvinalexander.utils._
object Main extends App{
println("HAL".increment)
}


在2.10 版本之前
class StringImprovements(val s:String){
def increment=s.map(c=>(c+1).toChar
}
implicit def stringToString(s:String)=new StringImprovements(s)
"HAL".increment


implicit class StringImprovements(val s:String){
def increment:String=s.map(c=>(c+1).toChar)
def decrement:String=s.map(c=>(c-1).toChar)
def hideAll:String=s.replaceAll(".","*")
}


注意此处带了类型，是显示申明的


第二章 数值


Short.MinValue
Short.MaxValue
Float.MinValue




从字符串到数值
“100”.toInt
"100".toDouble
val b=BigInt("1")


进制方法


Integer.parseInt("1",2)


也可以用隐式转换的类来解决
implicit class StringToInt(s:String){
|def toInt(radix:Int)=Integer.parseInt(s,radix)
|}


def toInt(s:String):Option[Int]={
try {
Some(s.toInt)
} catch {
case e:NumberFormatException=>None
}
}


println(toInt("1").getOrElse(0))
val x=toInt(aString).getOrElse(0)


val a=1000L
a.isValidByte
a.isValidShort


重载默认数值类型
val a=0:Byte
val a=0:Int
val a:Byte=0
val a:Int=0
val a=0x20
val a=ox20l




class Foo{
var a:Short=0
val b:Short=_ //默认为零


var i=1
i*=2
i-=1


浮点数比较，近似相等
def ~=(x:Double,y:Double,precisiion:Double)={
if((x-y).abs<-precisioin) true else false
}


val a=0.3
val b=0.2+0.1
~=(a,b,0.0001)




if(b.isValidInt) b.toInt
随机数生成
val r=scala.util.Random
r.nextInt
r.nextInt(100)


var range=0 to r.nextInt(10)
range=0 to r.nextInt(10)
var range=0 to r.nextInt(10)
for (i<-0 to r.nextInt(10)) yield i*2
for(i<-0 to r.nextInt(10)) yield (i*r.nextFloat)


创建一个数值区间
val r=1 to 10
val r=1 to 10 by 2
for(i<-1 until 5) println(i)
val x=1 to 10 toArray
val x=1 to 10 toList
val x=(1 to 10).toList
val range=0 to scala.util.Random.nextInt(10)
for (i<-1 to 5) yield i*2
for(i<-1 to 5)yield i.toDouble


格式化数值和金额
val pi=scala.math.Pi
println(f"$pi%1.5f")


val formatter=java.text.NumberFormat.getInstance
println(formatter.format(123.456789)




for {
line<-source.getLines
char<-line
if char.isLetter
}


//for 和 foreach
val a=Array("apple","banana","orange")
for(e<-a) println(e)


for(e<-a){
|val s=e.toUpperCase
|println(s)
|}
//如上无返回
//从For循环中返回值
val newArray=for(e<-a) yield e.toUpperCase


val newArray=for (e<-a) yield {
| val s=e.toUpperCase
| s
}


for 循环计数器
for (i<-0 until a.length) {
println(s"$i is ${a(i)}")
}


for ((e,count)<-a.zipWithIndex){
| println(s"$count is $e")
|}




生成器与语句
for( i<-1 to 10 if i<4) println(i)
遍历一个map
val names=map("fname"->"Robert", "Lname"->"Goren")
for ((k,v)<-names) println(s"key:$k, value:$v")


a.foreach(println)
a.foreach(e=>println(e.toUpperCase))
带有yield表达式和卫语被理解为在结合上调用withFilter方法，紧接着一个map方法调用


在for循环中使用多个计数器
for(i<-1 to 2;j<-1 to 2) println(s"i=$i,j=$j")
val array=Array.ofDim[Int](2,2)
for{
| i<-0 to 1
| j<-0 to 1
} println(s"($i)($j)=${array(i)(j)}")
在for循环中增加卫语
for(i<-1 to 10 if i%2==0) println(i)


for {
i<-1 to 10
if i>3
if i<6
if i%2==0
} println(i)


val fruits=scala.collection.mutable.ArrayBuffer[String]()
fruits+="apple"
fruits+="banana"
fruits+="orange"


val out=for (e<-fruits) yield e.toUpperCase
val fruits=“apple"::"banana"::"orange"::Nil
val out=for (e<-fruits) yield e.toUpperCase
val out=fruits.map(_.toUpperCase)




实现break 和continue
scala.util.control.Breaks
import util.control.Break._
object BreakAndContinueDemo extends App{
println("\n===Break ExAPLE===")
breakable{
for (i<-1 to 10){
println(i)
if(i>4)
}
}
//continue的例子 外层用for，如果发生break了，breakable函数退出，但循环继续
val searchMe="peter piper picked a peck of pickled peppers"
var numPs=0
for (i<-0 until searchMe.length){
breakable{
if (searchMe.charAt(i) !='p'){
break
} else {
numPs +=1
}
}
}


循环嵌套和有标签的break
object LabeledBreakDemo extends App {
import scala.util.control._
val Inner=new Breaks
val Outer=new Breaks
Outer.breakable{
for(i<1 to 5){
Outer.Breakable{
for (i<-1 to 5) {
Inner.breakable{
for (j<-'a' to 'e'){
if (i==1&&j=='c' Inner.break else println(s"i:$i,j:$j")
if (i==2&&j=='b') Outer.break}
}
}
}
}






import scala.util.control._
val Exit=new Breaks
Exit.breakable{
   for(j<-'a' to 'e'){
   if (j=='c') Exit.break else println(s"j:$j")
   }
   }
   
   
break的另外实现形式
for (monkey<-monkeyCollection if !barrelIsFull) {  //加入卫语
addMonkeyBarrel(monkey)
barreIsFull=checkIfBarrelIsFull
}


//满足条件的话return 
def sumToMax(arr:Array[Int],limit:Inyt):Int={
var sum=0
for(i<-arr){
sum+=i
if(sum>limit) return limit
}
sum}










@tailrec 注释用来增强算法是递归的
def factorial(n:Int):Int={
@tailrec def factorialAcc(acc:Int,n:Int):Int={


if(n==1) 1 acc
else factorialAcc(n*acc,n-1)
}
factorialAcc(1,n)
}




三元运算符
def  abs(x:Int)=if(x>=0) x else -x


匹配表达式
@switch 需要匹配表达式时，最好使用此注释, 防止错误编译为：tableswitch或lookupswitch
class Switch Demo {
val i=1
val x=(i:@switch) match{
case 1=>"One"
case 2=>"Two"
case _=>"Other"
}
}




一条case 语句匹配多个条件
val i=5
i match {
case 1|2|3|4=> println("ddd")
case 7|8|9|10=> println("even")




访问匹配表达式缺省的，捕获一切的case指,指定变量名可以是任何合法的名字 whoa


i match {
case 0=> println("1")
case default=> println("you gave me:"+ default)
}


使用模糊匹配
case List(0,_,_)=>"uuu"
case Vector(1,_*)=>"ccc"
case Person(first)=>....
case s:String =>
case i:Int => 
case m:Map[_,_]=>




case list @ List(1,_8) =>s"$list" //增加一个变量绑定的模式 @ 不然可能会出错，由于不知道是list类型


在匹配表达式中使用case类
def determinType(x:Animal):String=x match {
case Dog(moniker)=>"Got a Dog,name="+moniker
case _=>"That was something else"




给case语句添加if表达式, 注意i和a，b不同
i match{
case a if 0 to 9 contains a => println("0-9 range:"+a)
case b if 10 to 19 contains b=>println("10-19 range:" +b)
}


使用匹配表达式代替isInstanceOf
def isPerson(x:Any):Boolean=x match{
case p:Person=> true
case _=>false
}


在匹配表达式中使用List
val y=1::2::3::Nil


try/catch/finally


object CopyBytes extends App{
var in =None:Option[FileInputDtream]
var out=None:Option[FileOutputStream]
try{
in=Some(new FileInputStream("/tmp/Test.class"))
out=Some(new FileOutputStream("tmp/Test.class.copy")) var c=0
while ({c=in.get.read;c!=1){
out.get.write(c)
}
} catch {
case e:IOException=>e.printStackTrace
} finally{
println("entered finally...")
}


class Person(var firstName:String,var lastName:String) {
println("the constructor begins")
private val Home=System.getProperty("user.home")
var age=0


override defr toString=s"$firstName $lastName is $age years old"
def printHome{println(s"HOME=$HOME")}
def printFullName {println(this)}
}


控制构造函数字段的可见性
Case类的构造函数参数默认是val
定义辅助构造函数，类内部以this为名的方法定义辅助构造函数


class Pizza (var crustSize:Int,var crustType:Sting){
def this (crustSize:Int){
this(crustSize,Pizza.DEFAULT_CRUST_TYPE)
}
def this(crustType:String){
this(Pizza.DEFAULT_CRUST_TYPE,crustType)
}
override def toString=s"A $crustSize inch pizza with a $crustType crust"
}


object Pizza {
val DEFAULT_CRUST_SIZE =12}  // 注意在上面的class类里面没有定义参数，但是用了


case类构造函数 使用了伴生对象里面的apply方法
case class Person(var name:String, var age:Int)
object Person{
def apply()=new Person("<no name>",0)
def apply(name:String)=new Person(name,0)




定义私有的主构造函数
在Scala中简单地实现单例模式的方法就是把主构造函数变为私有，然后在类的伴生对象中实现一个getInstance


class Brain private{
override def toString="This is the brain"
}
object Brain{
val brain=new Brain
de getInstance=brain
}


object SingletonTest extend App {
val brain =Brain.getInstance
println(brain)
}




构造函数默认参数
class Socket (val timeout:Int=10000)
class Socket(val timeout:Int){
def this()=this(10000)
override def toString=s"timeout:$timeout"}


覆写默认的访问和修改方法 构造函数中参数
在参数前面增加一个下划线，然后根据约定声明getter和setter方法
class Person(private var _name:String){
def name=_name                                           //accessor
def name_=(aName:String){_name=aName}                    // mutator


阻止生成getter和setter方法
用private或者private访问修饰符的字段
private[this] 不像private，字段无法被同类型的其他实例访问，让字段比普通的private更加私有化
调用父类的构造方法
抽象类中的具体val


abstract class Animal{
val greeting="Hello" // provide an initial value
def sayHello{ println(greeting)}
def run 
}


class Dog extends Animal{
override val greeting="Woof" //override the value
def run {println("Dog is running")}
为了防止积累中的val字段被子类覆写 写成 final val
abstract class Animal {
finall val greeting="Hello"
}
class Dog extends Animal {
val greeting="Woof"
}




trait Animal {
val greeting :Option[String]
val age:Option[Int]=None
override def toString=s'I say $greeting, and I'm $age years old."
}




class Dog extends Animal {
val greeting=Some("Woof")
age=Some(2)