如何在Scala中创建一个带有额外字段的枚举？

4 浏览
0 Comments

如何在Scala中创建一个带有额外字段的枚举？

在Java中我有这样一个东西

public enum FlatFileHeaderMapping {
   HEADER_EL(1),
   HEADER_RESERVED1(5),
   HEADER_RESERVED2(2),
   HEADER_MESSAGE_TYPE(4)
   public final int fieldSize;
    private FlatFileHeaderMapping(int fieldSize) {
        this.fieldSize = fieldSize;
   }
}

我可以将每行放入一个映射中，稍后通过此枚举（如符号）访问地图中的键。

据我所知，枚举不具备这种特性，而案例类的订单不像枚举声明那样有序，因此不能用于匹配如上所示的记录布局。 至少没有有序收集的支持。

我可能会错过一些显而易见的东西，因此有问题！

谢谢

雷

admin 更改状态以发布 2023年5月24日
0

2 答案

0 Comments

你可以尝试使用case object：

sealed trait FlatFileHeaderMapping { val fieldSize: Int }                                                                                                                                                                          
case object HEADER_EL extends FlatFileHeaderMapping { val fieldSize = 1 }                                                                                                  
case object HEADER_RESERVED1 extends FlatFileHeaderMapping { val fieldSize = 5 }                                                                                           
case object HEADER_RESERVED2 extends FlatFileHeaderMapping { val fieldSize = 2 }                                                                                           
case object HEADER_MESSAGE_TYPE extends FlatFileHeaderMapping { val fieldSize = 4 }

然后你可以这样使用枚举：

object Test {                                                                                                                                                              
  def foo(x: FlatFileHeaderMapping) {                                                                                                                                      
    val result =                                                                                                                                                           
      x match {
        case HEADER_EL => "it's a HEADER_EL!"                                                                                                                              
        case other => "its field size is: " + other.fieldSize                                                                                                             
      }                                                                                                                                                                    
    println(result)                                                                                                                                                        
  }                                                                                                                                                                        
  def main(args: Array[String]) {                                                                                                                                          
    foo(HEADER_EL)                                                                                                                                                         
    foo(HEADER_MESSAGE_TYPE)                                                                                                                                               
  }                                                                                                                                                                        
}

这里的主要好处是，编译时检查所有枚举值是否被处理。即在上述x match { ... }代码中，如果你没有"case other => ..."条款，你将会得到一个编译错误。

我基本上只是在重申这个答案，这个答案列出了这种方法的优缺点。

0
0 Comments

overthink说的没错，但是声明case对象的方法也可以更简洁:

sealed abstract class FlatFileHeaderMapping(val fieldSize: Int)
case object HEADER_EL extends FlatFileHeaderMapping(1)
case object HEADER_RESERVED1 extends FlatFileHeaderMapping(5)
case object HEADER_RESERVED2 extends FlatFileHeaderMapping(2)
case object HEADER_MESSAGE_TYPE extends FlatFileHeaderMapping(4)

0