scala學習六：scala函數式編程進階

scala學習六：scala函數式編程進階

標籤（空格分隔）： scala

---

一，集合

不可變集合：集合的元素是不可以改變的

val math=scala.collection.immutable.Map("alice"->80)

可變集合：

val math=scala.collection.mutable.Map("alice"->80)

二，列表：

不可變列表（List）

//字符串列表
val nameList:List[String]=List("mary","mike","bob")
//空列表
val empty:List[Nothing]=List()
//二維列表，通過列表的列表來實現
val dim:List[List[Int]]=List(List(1,2,3),List(2,3,4))
//列表的方法
//head
//tail:除去第一個元素的剩餘元素
println(nameList.head)
println(nameList.tail)
println(nameList.isEmpty)

可變列表（LinkedList）

import scala.collection.mutable
//定義一個可變列表
val mylist=mutable.LinkedList(1,2,3,4)

var cur=mylist
while(cur!=Nil){
  cur.elem=cur.elem*2

  cur=cur.next
}
println(mylist)

三，序列

常用的序列：Vector和Range
Vector是ArrayBuffer的不可變版本，是一個帶下標的序列

//爲了提高List集合隨機存取效率而引入的新的集合類型
//最大的特點就是支持快速的查找和更新
var v=Vector(1,2,3,4,5,6)
v.find(_>3)
v.updated(2,100)

Range表示一個整數序列
有序的通過空格分隔的Int序列

println("1:"+Range(0,5))
println("2:"+(0 until 5))
println("3:"+(0 to 5))

//Range可以相加
('0' to '3') ++ ('A' to 'C')
//Range可以轉換爲List
1 to 5 toList

四，集

集Set是不重複元素的集合
和列表不同，集不保留元素插入的順序。默認以Hash集實現

//定義
var s1=Set(2,1,6)                         
//> s1  : scala.collection.immutable.Set[Int] = Set(2, 1, 6)
s1+1                                      
//> res2: scala.collection.immutable.Set[Int] = Set(2, 1, 6)
s1+10                                     
//> res3: scala.collection.immutable.Set[Int] = Set(2, 1, 6, 10)


var weekday=LinkedHashSet("one","two","three")
//weekday  : scala.collection.mutable.LinkedHashSet[String] = Set(one, two, three)

var sorteds=SortedSet(1,3,4,7,2)
//TreeSet(1, 2, 3, 4, 7)

集的操作

var weekday=LinkedHashSet("one","two","three")
//添加元素
weekday + "four"
//判斷元素是否存在
weekday contains "one"
//判斷一個集合是否另一集的子集
Set("one").subsetOf(weekday)

var set1=Set(1,2,3,4,5,6,7)
var set2=Set(5,6,7,8,9,10)
//union 並集
set1 union set2 //Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 8)
//交集
set1 intersect set2   //Set(5, 6, 7)

//差集
set1 diff set2  Set(1, 2, 3, 4)

五，模式匹配

scala有一個強大的模式匹配機制，可以應用在很多場合：switch語句，類型檢查
scala還提供了樣本類（case class）,對模式匹配進行優化

//更好的switch
var sign=0                                        //> sign  : Int = 0
var ch1:Char='-'                                  //> ch1  : Char = -
ch1 match{
    case '+' => sign=1
    case '-' => sign=2
    case _ => sign=0
}
println(sign)                                     //> 2

scala的守衛
對某一類型的所有數字進行匹配

//scala的守衛
var sign=0                                        //> sign  : Int = 0
var ch1:Char='1'                                  //> ch1  : Char = 1
ch1 match{
    case '+' => sign=1
    case '-' => sign=2
    case _ if Character.isDigit(ch1) => sign=Character.digit(ch1,10)
    case _ => sign=0
}
println(sign)                                     //> 1

模式匹配中的變量

var str3:String="hello world"
str3(6) match{
    case '+' => println("這是一個字符+")
    case '-' => println("這是一個字符-")
    case ch => println("這是一個字符"+ch)
}

類型匹配

var v4:Any=100
v4 match{
    case x:Int => println("這是一個整數")
    case x:String => println("這是一個字符串")
    case _ => println("其他類型")
}

匹配數組和列表

var myArray=Array(1,2)
myArray match{
    case Array(0) => println("數組中包含一個0")
    case Array(x,y) => println("數組中包含2個數，和是"+(x+y))
    case Array(x,y,z) => println("數組中包含3個數")
    case Array(x,_*) => println("數組中包含多個數")
}

var mylist=List(1,2)
mylist match{
    case List(0) => println("包含一個0")
    case List(x,y) => println("包含2個數，和是"+(x+y))
    case List(x,y,z) => println("包含3個數")
    case List(x,_*) => println("數組中包含多個數")
}

六，Case Class

就是在普通的類定義前家case這個關鍵字，然後你就可以對這些類來進行模式匹配
case class帶來的最大好處是他們支持模式識別

//判斷某個變量是否是某個類的對象？ isInstanceOf
class Fruit(name:String)
class Apple extends Fruit(name)
class Banana extends Fruit(name)

var apple:Fruit=new Apple
println("apple 是水果麼？"+apple.isInstanceOf[Fruit])
println("apple 是蘋果麼？"+apple.isInstanceOf[Apple])
println("apple 是香蕉麼？"+apple.isInstanceOf[Banana])

//判斷某個變量是否是某個類的對象？ isInstanceOf
class Vichael
case class car(name:String) extends Vichael
case class bicycle(name:String) extends Vichael

var vcar:car=new car("tom car")
vcar match{
    case car(name) => println(name)
    case bicycle(name) => println("i am bicycle")
    case _ => println("others")
}