scala Option类入门解析

是什么

是个class

sealed abstract class Option[+A] extends Product with Serializable

目的

模式匹配时,有结果的时候进行一种处理,没结果的时候进行另一种处理.

用法

scala> val map=Map("key1"->"value1")
map: scala.collection.immutable.Map[String,String] = Map(key1 -> value1)

scala> map.get("key1")
res18: Option[String] = Some(value1)

scala> map.get("key2")
res19: Option[String] = None

scala> res18.get
res20: String = value1

scala> res19.get
java.util.NoSuchElementException: None.get
  at scala.None$.get(Option.scala:347)
  at scala.None$.get(Option.scala:345)
  ... 32 elided

get返回的可能是Some类型,也可能是None类型.这俩其实都是Option类的子类

final case class Some[+A](x: A) extends Option[A] {
  def isEmpty = false
  def get = x
}

case object None extends Option[Nothing] {
  def isEmpty = true
  def get = throw new NoSuchElementException("None.get")
}

如果返回时Some类型的话,就可以用get进一步获取了.

还可以用于模式匹配,有结果的时候进行一种处理,没结果的时候进行另一种处理.

object Testoption {
  def main(args: Array[String]): Unit = {
    val map = Map("a" -> 1, "b" -> 2)
    val x: Unit = map.get("b") match {
      case Some(i) => println(i)
      case None => println(0)
    }
  }
}

Option其实也可以看做一种集合

Option其实也可以看做一种集合,不过集合里面只能有一个元素
然后,Option类也是可以用map这些算子的

object Test2 extends App {
  private val s: Option[Int] = updateFunc(Seq(1, 2, 3), Option(1))
  println(s.getOrElse(0))//7
  private val maybeTuple: Option[(Int, Int)] = s.map((_, 1))
  println(maybeTuple)//Some((7,1))

  def updateFunc(seq:Seq[Int],option: Option[Int]): Option[Int] ={
    println(s"option: $option + seq: ${seq.mkString(",")}")
    Option(seq.sum + option.getOrElse(0))
  }
}

option甚至可以转为List

 println(Option(1).toList)//List(1)

option是some类型的爸爸,如下两种写法都没错

object Test2 extends App {
  private val someTuple: Option[(Int, Int)] = Some(1, 2)
  println(someTuple)//Some((1,2))
}

object Test2 extends App {
  private val someTuple: Some[(Int, Int)] = Some(1, 2)
  println(someTuple)//Some((1,2))
}

Option类型的模式匹配

//对Option类型进行模式匹配取值
object Test extends App {
  val p1 = Person("liming", 23)
  val x = Option[Person](p1)
  x match {
    case Some(x)=>println(x.name)
    case None=>
  }
}

case class Person(name: String, age: Int) {}

运行结果

liming

再比如,
Option类型用于模式匹配时,可以针对有值和没有值采取不同的操作! 具体就是如果匹配到有值,就是Some,执行Some后面的操作,否则执行None后面的操作.

//对Option类型进行模式匹配取值
object Test extends App {
  val p1 = Person("liming", 23)
  val p2=Person("dufu",18)
  val map=Map("libai"->p1,"difu"->p2)

  val x = map.get("test")
  x match {
    case Some(x)=>println(x.name)
    case None=>println("nothing")
  }
}

case class Person(name: String, age: Int) {}

运行结果

nothing

当然,也可以不用模式匹配,但是取不到值得时候会报错,所以用模式匹配的时候,程序比较稳健

object Test extends App {
  val p1 = Person("liming", 23)
  val p2=Person("dufu",18)
  val map=Map("liming"->p1,"difu"->p2)

  val x = map("liming").name
  println(x)//liming
  private val maybePerson: Option[Person] = map.get("liming")
  println(maybePerson.get.name)//liming
  private val maybePerson1: Option[Person] = map.get("none")
  //会报错
  //in thread "main" java.util.NoSuchElementException: None.get
  println(maybePerson1.get.name)
}

case class Person(name: String, age: Int) {}

总结

• option你可以看做是一个只有一个元素的集合
• 在scala中尽量不用用null
• option类解析的时候可以用模式匹配,程序比较稳健