理解case class的用法

case class PiecewiseInfo(separateValues: List[Double]=List(0.0),
                         allowedValues: List[(Int, Int)]=List((-1,1))
                   )

以此 case class 为例，探讨一些特性。

知识结构来自 https://blog.csdn.net/hellojoy/article/details/81034528

当你声明了一个 case class，Scala 编译器为你做了这些事情：

1.创建 case class 和它的伴生 object

2.实现了 apply 方法让你不需要通过 new 来创建类实例

scala> case class PiecewiseInfo(separateValues: List[Double]=List(0.0),
                           allowedValues: List[(Int, Int)]=List((-1,1)))
defined class PiecewiseInfo
 
scala> val p = PiecewiseInfo(a,b)
p: PiecewiseInfo= PiecewiseInfo(a,b)

3.默认为主构造函数参数列表的所有参数前加 val

scala> println( p.separateValues)
a
 
scala> p.separateValues= c
<console>:10: error: reassignment to val
   p.lastname = c

4.添加天然的 hashCode、equals 和 toString 方法。由于 == 在 Scala 中总是代表 equals，所以 case class 实例总是可比较的

scala> val p_1 = new PiecewiseInfo( separateValues: List[Double]=List(0.0),
                           allowedValues: List[(Int, Int)]=List((-1,1))
p_1: PiecewiseInfo= PiecewiseInfo(a,b)
 
scala>val p_2 = new PiecewiseInfo( separateValues: List[Double]=List(0.0),
                           allowedValues: List[(Int, Int)]=List((-1,1)))
p_2: PiecewiseInfo= PiecewiseInfo(c,d)
 
scala> p_1.hashCode
res1: Int = -1362628729
 
scala> p_1.toString
res2: String = Person(a,b)
 
scala> p_1.equals(p_2)
res3: Boolean = false
 
scala> p_1 == p_2
res4: Boolean = false

4.生成一个 copy 方法以支持从实例 a 生成另一个实例 b，实例 b 可以指定构造函数参数与 a 一致或不一致

//< 保留 lastname 一致，修改 firstname 和 birthYear
scala> val p_3 = p.copy(firstname = "Michele", birthYear = 1972)
p_3: Person = Person(Lacava,Michele,1972)

5.由于编译器实现了 unapply 方法，一个 case class 支持模式匹配

scala> case class A( a: Int )
defined class A
 
scala> case class B( b: String )
defined class B
 
scala> def classMath( x: AnyRef ): Unit = {
     |   x match {
     |     case A(a) => println( "A:" + a )
     |     case B(b) => println( "B:" + b )
     |     case A => println( A.apply(100) )
     |   }
     | }
classMath: (x: AnyRef)Unit
 
scala> val a = A( 1 )
a: A = A(1)
 
scala> val b = B( "b" )
b: B = B(b)
 
scala> classMath( a )
A:1
 
scala> classMath( b )
B:b

  //电芯跳变特征所需参数读取
  val cellJump: PiecewiseInfo =
    (cursor.downField("cell_jump").downField("separateValues").as[List[Double]],
     cursor.downField("cell_jump").downField("allowedJumpValues").as[List[List[Int]]]) match {
      case (Right(s), Right(a)) if s.length == a.length - 1 => PiecewiseInfo(s, list2tuple(a))
      case _ => println("WARN invalid cellJump parameters"); PiecewiseInfo()
    }

除了在模式匹配中使用之外，unapply 方法可以让你结构 case class 来提取它的字段，如：

scala> val Person(lastname, _, _) = p
lastname: String = Lacava

6.获取一个函数接收一个 tuple 作为参数，该 tuple 的元素类型与个数与某 case class 相同，那么可以将该 tuple 作为 case class 的 tuple 方法参数来构造 case class 实例

scala> val meAsTuple: (String, String, Int) = ("Lacava", "Alessandro", 1976)
meAsTuple: (String, String, Int) = (Lacava,Alessandro,1976)
 
scala> Person.tupled( meAsTuple )
res2: Person = Person(Lacava,Alessandro,1976)

7.相对用 tuple 来创建 case class 实例，还可以从 case class 实例中解构并提取出 tuple 对象

scala> val transform: Person => Option[ (String, String, Int) ] = {
 |   Person.unapply _
 | }
transform: Person => Option[(String, String, Int)] = <function1>
 
scala> transform( p )
res0: Option[(String, String, Int)] = Some((Lacava,Alessandro,1976))

 

我这里有个代码展示一下

package General.Objects

import io.circe._
import io.circe.parser._

class FeaturePara(source: Json) {
  private val cursor: HCursor = source.hcursor

  case class PiecewiseInfo(separateValues: List[Double]=List(0.0),
                           allowedValues: List[(Int, Int)]=List((-1,1))
                     )

  private def list2tuple(i: List[List[Int]]): List[(Int, Int)] ={
    i.map {
      case x if x.length == 2 => (x.head, x.last)
      case _ => (0, 0)
    }
  }

  //电芯跳变特征所需参数读取
  val cellJump: PiecewiseInfo =
    (cursor.downField("cell_jump").downField("separateValues").as[List[Double]],
     cursor.downField("cell_jump").downField("allowedJumpValues").as[List[List[Int]]]) match {
      case (Right(s), Right(a)) if s.length == a.length - 1 => PiecewiseInfo(s, list2tuple(a))
      case _ => println("WARN invalid cellJump parameters"); PiecewiseInfo()
    }

  //探针跳变特征所需参数读取
  val probeJump: PiecewiseInfo =
    (cursor.downField("probe_jump").downField("separateValues").as[List[Double]],
      cursor.downField("probe_jump").downField("allowedJumpValues").as[List[List[Int]]]) match {
      case (Right(s), Right(a)) if s.length == a.length - 1 => PiecewiseInfo(s, list2tuple(a))
      case _ => println("WARN invalid probeJump parameters"); PiecewiseInfo()
    }

  //接近充满的电压所需参数读取
  val almost_full_cell_voltage: Double = cursor.downField("almost_full_cell_voltage").as[Double] match {
    case Right(x) => x
    case _ => 4.05
  }
}

object FeaturePara {
  /**
    * 获得特征所需要的参数
    * @param fileName
    * @return
    */
  def load(fileName: String): FeaturePara ={
    val jsonFile =  scala.io.Source.fromFile(fileName)
    val jsonContent = jsonFile.mkString
    jsonFile.close()
    parse(jsonContent) match {
      case Right(json) => new FeaturePara(json)
      case Left(_) =>
        println("WARN FeaturePara.json invalid, use default feature parameters")
        new FeaturePara(Json.fromString(""))
    }
  }
}