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