Quelle est la meilleure façon de boucle sur un tableau dans scala

Question

Je suis nouveau à scala et j'essaie de refactor le code ci-dessous.Je veux éliminer "index" utilisé dans le code ci-dessous et boucle sur le tableau pour récupérer des données.

subgroupMetricIndividual.instances.foreach { instanceIndividual => 
    val MetricContextListBuffer: ListBuffer[Context] = ListBuffer() 
    var index = 0 
    contextListBufferForSubGroup.foreach { contextIndividual => 
     MetricContextListBuffer += Context(
       entity = contextIndividual, 
       value = instanceIndividual(index).toString 
     ) 
     index += 1 
    } 
} 

Par exemple, si les valeurs des variables sont les suivantes:

contextListBufferForSubGroup = ("context1","context2") 
subgroupMetricIndividual.instances = {{"Inst1","Inst2",1},{"Inst3","Inst4",2}} 

Ensuite, Contexte devrait être quelque chose comme:

{ 
    entity: "context1", 
    value: "Inst1" 
    }, 
    { 
    entity: "context2", 
    value: "Inst2" 
    }, 
    { 
    entity: "context1", 
    value: "Inst3" 
    }, 
    { 
    entity: "context2", 
    value: "Inst4" 
    } 

Note:

instanceIndividual peut avoir plus éléments que ceux de contextListBufferForSubGroup. Nous devons ignorer les derniers éléments supplémentaires dans instanceIndividual dans ce cas

Answer 1

Vous pouvez compresser deux listes dans une liste de tuples, puis les mapper par-dessus. par exemple.

subgroupMetricIndividual.instances.foreach { instanceIndividual => 
    val MetricContextListBuffer = contextListBufferForSubGroup.zip(instanceIndividual).map { 
    case (contextIndividual, instanceIndividualIndex) => Context(
     entity = contextIndividual, 
     value = instanceIndividualIndex.toString 
    ) 
    } 
} 

Si Context peut être appelé comme une fonction à savoir Context(contextIndividual, instanceIndividualIndex.toString) alors vous pouvez écrire encore plus court.

subgroupMetricIndividual.instances.foreach { instanceIndividual => 
    val MetricContextListBuffer = contextListBufferForSubGroup 
    .zip(instanceIndividual.map(_.toString)).map(Context.tupled) 
} 

Answer 2

Sans connaître vos exactement les types, je suis moqué de quelque chose qui est probablement proche de ce que vous voulez, et est un peu plus fonctionnel en utilisant des cartes et collections immuables

case class Context(entity:String, value:String) 

val contextListBufferForSubGroup = List("context1","context2") 
val subgroupMetricIndividualInstances = List(List("Inst1","Inst2",1),List("Inst3","Inst4",2)) 

val result: List[Context] = subgroupMetricIndividualInstances.map { instanceIndividual => 
contextListBufferForSubGroup.zip(instanceIndividual) map { case v: (String, String) => 
    Context(
     entity = v._1, 
     value = v._2 
    ) 
    } 
}.flatten