【Scala】基础5：集合（二）

可变集合

Scala中集合分为可变集合和不可变集合，就像Java中的String和StringBuffer。

默认是不可变集合，在collection.immutable包下，会自动增加到Scala的当前命名空间。

创建可变的集合时，需要包含类型的完整包名或者导包。

不可变集合	可变集合
collection.immutable.List	collection.mutable.Buffer
collection.immutable.Set	collection.mutable.Set
collection.immutable.Map	collection.mutable.Map

 

 

 

 

 

collection.mutable.Buffer类型是一个通用的可变序列，支持在开头、中间或末尾增加元素。

举例1：有默认值，可以不指定泛型

val nums = Buffer(1)
for(i <- 2 to 10){
    nums += i    //向Buffer中追加元素,相当于append方法
}
println(nums)

举例2：无默认值，必须指定Buffer类型

val nums=Buffer[Int]()
for(i <- 1 to 10){
    nums += i    //向Buffer中追加元素,相当于append方法
}
println(nums)

利用toList、toSet、toMap方法，可以随时把可变的集合转换回不可变的集合

val nums = Buffer(1)

val list=nums.toList

还记得toBuffer方法吗？

使用toBuffer方法可以从不可变集合创建可变集合，而且不需要导包，也不需要写完整的包名

def coll()={
    
    val m=Map("AAPL" -> 597,"MSFT" -> 40)
    
    val n=m.toBuffer
    
    n.remove(1)    //删除第一个元素
    
    n+=("GOOD" -> 521)
    
    n.toMap
  
}

集合构造器

要为一个特定的集合类型创建构造器，可以调用这个类型的newBuilder方法，并指定集合元素的类型。

举例：

def nb() ={
    val b=Set.newBuilder[Char]
    b +='h'
    b ++= List('e','l','l','o')
    b.result()
}

数组

Array是一个大小固定的可变索引集合。

举例：

val colors = Array("red","green","blue")
colors(0) = "purple"    
for(i <- colors)     
    println(i)

一元集合

四个字拆开看，首先，是一个集合，其次，集合的大小不会超过1。

Option集合

Option类型表示一个值的存在或不存在。这个值有可能没有（例如，从未初始化，或者不能计算），因此可以包装在一个Option集合中，从而清楚地指示它有可能不存在。

Option类型本身没有实现，而是依赖两个子类型提供具体实现：Some和None，Some是一个类型参数化的单元素集合，None是一个空集合。None类型没有类型参数，因为它永远不包含任何内容。

举例1：

val x:String = "indeed"
var a = Option(x)
println(a)

val y:String = null
var b = Option(y)
println(b)

运行结果：

举例2：

def divide(amt:Double,divisor:Double):Option[Double] ={
    if(divisor==0) None
    else Some(amt/divisor)
}
val legal = divide(10,5)
val illegal = divide(10,0)
println(legal)
println(illegal)

运行结果：

举例3：

val odds = List(1,3,5)    
val firstOdd = odds.headOption    
println(firstOdd)    
val evens = odds.filter(_%2 == 0)   
println(evens.headOption)

运行结果：

常用方法：

操作名	描述	示例
fold	参数是两个参数表，一个是返回值为Some时的处理方法，一个是返回值为None时的处理方法	val res=illegal.fold(-1.0)(x => x) val res2=legal.fold(-1.0)(x => x)
getOrElse	一个参数，表示返回值为None时的处理方法。当返回值为Some时默认原样输出	val res3=illegal.getOrElse(-1.0) val res4=legal.getOrElse(-1.0)
orElse	参数为Option类型，返回值也为Option类型，作用和getOrElse相同，这样不论存不存在都可以以Some的形式输出	val res5=illegal.orElse(Some(-1)) val res6=legal.orElse(Some(-1))
匹配表达式	和fold一样，指定返回值为None或Some时的处理方法（很直观的方式）	val res7=illegal match { case Some(s) => s*2+1 case None => -10000 }

Try集合

Scala允许通过抛出异常来产生错误，抛出异常会中断程序流。

异常可能由你自己的代码抛出，也可能由你调用的库方法抛出，或者由Java虚拟机抛出。

可以使用scala.util包下的Try集合来捕获异常，和Option集合一样，Try集合也有两个子类型：Success和Failure，正常执行时Success中存放的是返回值，异常中断时Failure中存放的是异常信息

举例：

def loopAndFail(end:Int,failAt:Int) ={
    for(i <- 1 to end){
        if(i==failAt) throw new Exception("fail at here")
    }
    end
}
val result1 = Try(loopAndFail(10,3))
val result2 = Try(loopAndFail(10,30))
println(result1)
println(result2)

常用方法：

操作名	描述	示例
foreach	参数是一个函数，只有当执行成功时，遍历返回值，对每一个元素执行参数函数中的操作	val result2 = Try(loopAndFail(10,30)) result2.foreach(x=>println(s"success:${x}"))
getOrElse	一个参数，表示返回值为Failure时的处理方法。当返回值为Success时默认原样输出（以具体值的形式）	val result1 = Try(loopAndFail(10,3)) val result2 = Try(loopAndFail(10,30)) println(result1.getOrElse(-1)) println(result2.getOrElse(-1))
orElse	参数为Try类型，返回值也为Try类型，作用和getOrElse相同，这样不论成不成功都可以以Success的形式输出	val result1 = Try(loopAndFail(10,3)) val result2 = Try(loopAndFail(10,30)) println(result1.orElse(Success(-1))) println(result2.orElse(Success(-1)))
toOption	将Success转换成Some，将Failure转换成None	val op =result1.toOption val op2=result2.toOption
匹配表达式	分别指定返回值为Success和Failure时的处理方法（很直观的方式）	val res=result2 match { case Success(x) => x case Failure(y) => -1 }

例子：

val input = "123 "
	
val result = util.Try(input.toInt) orElse util.Try(input.trim.toInt)    

result foreach{r => println(s"Parsed '$input' to $r!")}
	
val x = result match{
		
    case util.Success(x) => Some(x)
		
    case util.Failure(ex) => {
			
    println(s"Couldn't parse input '$input'")
			
    None
		
    }

}