Je suis nouveau à Scala, j'essaie de transformer et d'ajouter un objet tout en itérant une liste à Scala, mais de la lutte contre la syntaxe et probablement le concept.
Je veux atteindre quelque chose comme celui-ci que nous faire en Java. p>
private def promoteEmployee (newManagers : Set[Manager], employee: Employee){
if(employee.getExprience() > 5) {
managers+.(new Manager(employee));
}
}
4 Réponses :
Vous avez donc une liste code> des employés et que vous souhaitez une liste code> de nouveaux gestionnaires. def processEmployeePromotion(employees :List[Employee]) :List[Manager] =
employees.collect{case emp if emp.getExprience() > 5 => promoteEmployee(emp)}
+1 pour collecter au lieu de Filtre + plan . À raj: si vous voulez toujours obtenir définir [gestionnaire] au lieu d'une liste , vous pouvez utiliser .toset ou simplement changer le retour. Type de la méthode et ajoutez (scala.collectio.breakout) à la fin de l'appel.
in Scala, Set code> est immuable par défaut, donc la méthode + code> sur définir code> renvoie un nouvel ensemble. private def promoteEmployee(employee: Employee): Option[Manager] =
if (employee.getExperience > 5) {
Option(new Manager(employee))
} else {
None
}
private def promotedEmployees(employees: Iterable[Employee]): Set[Manager] =
employees.flatMap(promoteEmployee).toSet // NB: might not work if Manager doesn't obey the equality contract...
private def processEmployeePromotion(employees: List[Employee]): Unit = {
saveNewManagers(promotedEmployees(employees.asScala).toArray)
}
Lorsque vous commencez à travailler avec SCALA, vous devez vous habituer à travailler avec des structures de données immuables, des plombés, des expressions ... etc. Vous pouvez toujours travailler avec mutable comme vous l'aviez l'habitude de faire avec Java si vous le souhaitez, mais le premier est ce que vous devriez faire.
Regardez cet exemple à l'aide de Refinblez de la liste: P>
case class Employee(id: String, name: String, experience: Int)
case class Manager(employee: Employee)
object Your_Code extends App {
def promoteEmployee(employee: Employee) =
Manager(employee)
def promoteEmployeesToManager(list: List[Employee]) : Set[Manager] = {
list.foldLeft(Set[Manager]())((a, b) => if(b.experience > 5) a + promoteEmployee(b) else a)
}
val employess = List(Employee("id1", "name1", 6), Employee("id1", "name1", 4))
println(promoteEmployeesToManager(employess))
}
val managers: Set[Manager] = employees .iterator .filter(_.getExperience > 5) .map(promoteEmployee) .toSet
Y a-t-il des avantages que .itéator ajoute dans ce cas? Aussi, je crois que d'utiliser scala.collection.breakout , vous pouvez éviter .Tomap étape.
@Serggr ggr itérateurs sont paresseux, donc, l'avoir ici empêche de construire des collections intermédiaires à chaque étape. Il utilise également l'utilisation de Breakout inutile.
Dans votre méthode de promotionPemployee, vous ajoutez les nouveaux gestionnaires à une collection inexistante, est ce nom correct?