Comment écrivez-vous dans Scala qui a été écrit en Java? (Liste → Carte)

C'est une Scala fonctionnelle et orientée objet, mais je ne pense pas que ce soit un problème de l'utiliser si c'est un code qui dit "déplacez simplement" [^ 1]. Si vous êtes trop exigeant sur l'écriture de manière fonctionnelle et donnez un sentiment d'intimidation à ceux qui voient le code, je pense que même si vous essayez d'élargir la base de développeurs, cela ne fonctionnera souvent pas. Cela dit, l'écriture de type Java dans Scala présente certains avantages, mais je pense que c'est mieux si vous pouvez éviter d'utiliser des variables et des mutables.

Personnellement, j'essaie de modeler et d'appliquer le cas de l'écriture de l'implémentation Java dans Scala, mais j'ai pensé que ce serait utile pour quelqu'un, donc je l'écrirai à chaque fois que j'y pense. J'ai pensé. S'il te plaît, sors avec moi si tu veux.

1. Listez [élément] à mapper le motif [clé, élément]

Par exemple, j'utilise souvent des données de base dans une carte avec une valeur d'identifiant comme clé, comme un cache.

Pour Java

élément(client)

public class Customer {
  /**N ° de client. */
  public Long id;
  /**Nom du client. */
  public String name;
  /**âge. */
  public Integer age;
}

Liste des cibles

//À l'origine, la liste de clients est une brume à obtenir de DB, etc.
List<Customer> customerList = new ArrayList<Customer>(){{
    add(new Customer(){{
      this.id = 5L;this.name = "Kataoka";this.age = 39;
    }});
    add(new Customer(){{
      this.id = 3L;this.name = "Aoyama";this.age = 60;
    }});
    add(new Customer(){{
      this.id = 1L;this.name = "Fujishima";this.age = 23;
    }});
}};

Liste → Processus de conversion de carte

Map<Long, Customer> customerMap = new HashMap<>();
for(Customer customer : customerList) {
  customerMap.put(customer.id, customer);
}

Cela créera un customerMap où la clé est l'ID client et la valeur est l'instance du client.

Pour Scala

élément(client)

/**
  *client.
  * @ID de paramètre ID client
  * @nom du paramètre Nom du client
  * @âge param
  */
case class Customer(id:Long, name:String, age:Int)

Liste des cibles

//À l'origine, la liste de clients est une brume à obtenir de DB, etc.
val customerList = Seq(
  Customer(id=5L, name="Kataoka", age=39),
  Customer(id=3L, name="Aoyama", age=60),
  Customer(id=1L, name="Fujishima", age=23)
)

Liste → Processus de conversion de carte

val customerMap = (customerList map (t => t.id -> t)).toMap

Seq [(Long, Customer)] [^ 2] est créé par une opération de carte à partir de Seq [Customer]. De plus, c'est une image qui est convertie en Map [Long, Customer] par toMap. La carte générée est une carte immuable, ne vous inquiétez donc pas de sa modification.

Bien sûr, il est possible de le décrire comme Java en utilisant une carte mutable, mais je pense qu'il est plus facile de comprendre que cela génère une carte à partir d'une liste. Puisqu'il n'est pas nécessaire de décrire le processus de création d'une instance de Map vide et le processus d'ajout d'un élément à la Map, on pense que les erreurs de codage peuvent être réduites [^ 3].

2. List [élément] à mapper [clé, liste [élément]] modèle

Par exemple, sur la base de la liste des détails de facturation liée à plusieurs ID de facturation acquis par un SQL clé: ID de facturation value: liste des détails de facturation associée à l'ID de facturation Lorsque vous générez une carte de, cela ressemble à ceci.

Pour Java

élément(relevé de facturation)

/**
 *relevé de facturation.
 */
public class BillingStatement {
  /**ID de la ligne de facturation(PK). */
  public Long id;
  /**ID de facturation(FK). */
  public Long billingId;
  /**Nom du produit. */
  public String itemName;

  //Je pense qu'il y a des quantités et des prix unitaires, mais ils sont omis.
}

Liste des cibles

//À l'origine, billingStatementList est un brouillard à obtenir de DB, etc.
List<BillingStatement> billingStatementList = new ArrayList<BillingStatement>(){{
    add(new BillingStatement(){{
      this.id = 1L;this.billingId = 1L;
      this.itemName = "Facturation 1 Produit 1";
    }});
    add(new BillingStatement(){{
      this.id = 2L;this.billingId = 1L;
      this.itemName = "Facturation 1 Produit 2";
    }});
    add(new BillingStatement(){{
      this.id = 3L;this.billingId = 2L;
      this.itemName = "Facturation 2 Produit 1";
    }});
    add(new BillingStatement(){{
      this.id = 4L;this.billingId = 3L;
      this.itemName = "Facturation 3 Produit 1";
    }});
    add(new BillingStatement(){{
      this.id = 5L;this.billingId = 3L;
      this.itemName = "Facturation 3 Produit 2";
    }});
    add(new BillingStatement(){{
      this.id = 6L;this.billingId = 3L;
      this.itemName = "Facturation 3 Produit 3";
    }});
}};

Liste → Processus de conversion de carte

Map<Long, List<BillingStatement>> billingStatementsMap = new HashMap<>();
for(BillingStatement billingStatement : billingStatementList) {
  List<BillingStatement> billingStatements = billingStatementsMap.get(billingStatement.billingId);
  if(billingStatements == null) {
    billingStatements = new ArrayList<>();
    billingStatementsMap.put(billingStatement.billingId, billingStatements);
  }

  billingStatements.add(billingStatement);
}

Cela créera une carte de la liste des détails de facturation avec la clé associée à l'ID de facturation et la valeur associée à l'ID de facturation. Traitement lorsque la liste associée à l'ID de facturation n'existe pas ... Avez-vous l'impression d'incorporer par inadvertance un bogue?

Pour Scala

élément(relevé de facturation)

/**
  *relevé de facturation.
  *Je pense qu'il y a des quantités et des prix unitaires, mais ils sont omis.
  * @ID de paramètre ID de la ligne de facturation(PK)
  * @param billingId ID de facturation(FK)
  * @param itemName Nom du produit
  */
case class BillingStatement(id:Long, billingId:Long, itemName:String)

Liste des cibles

//À l'origine, billingStatementList est un brouillard à obtenir de DB, etc.
val billingStatementList = Seq(
  BillingStatement(id=1L, billingId=1L, itemName="Facturation 1 Produit 1"),
  BillingStatement(id=2L, billingId=1L, itemName="Facturation 1 Produit 2"),
  BillingStatement(id=3L, billingId=2L, itemName="Facturation 2 Produit 1"),
  BillingStatement(id=4L, billingId=3L, itemName="Facturation 3 Produit 1"),
  BillingStatement(id=5L, billingId=3L, itemName="Facturation 3 Produit 2"),
  BillingStatement(id=6L, billingId=3L, itemName="Facturation 3 Produit 3")
)

Liste → Processus de conversion de carte

val billingStatementsMap = billingStatementList.foldLeft(Map[Long, Seq[BillingStatement]]()){(map,value) => {
  val key = value.billingId
  map.updated(key, map.getOrElse(key, Seq()) :+ value)
}}

La carte générée est une carte immuable. le soulagement. map.getOrElse (key, Seq ()) est Si la valeur associée à la clé spécifiée dans la mappe est enregistrée, cette valeur est renvoyée, et si elle n'est pas enregistrée, un Seq vide est renvoyé. Ajoute une valeur d'élément à cette séquence et renvoie une nouvelle carte avec des éléments mis à jour associés à la clé. FoldLeft, qui n'était utilisé que pour ajouter des éléments, peut être utilisé pour éviter de créer des bogues [^ 4].

Résumé

Un codage minutieux peut réduire les bogues et les erreurs. Mais les gens sont des créatures qui font des erreurs. Je pense que si vous combinez de nombreuses variables et opérations sur celles-ci pour obtenir le résultat, vous êtes plus susceptible d'incorporer "par inadvertance" un bogue. En utilisant les fonctions fournies par le langage de développement, pourquoi ne pas consacrer du temps et de la concentration à «faire attention» aux «choses que seuls les humains peuvent faire»?

[^ 1]: Bien sûr, si vous essayez de créer un FW ou une classe de base pour votre projet, cela peut poser problème ... [^ 2]: Seq avec l'élément Tuple2 [^ 3]: Au fait, jusqu'à il y a quelque temps, j'ai écrit un processus pour ajouter un élément à Map.newBuilder et le faire entrer dans la portée du bloc. [^ 4]: Si vous souhaitez renvoyer plusieurs résultats dans une boucle, vous pouvez passer Tuple.