Es ist eine funktionale und objektorientierte Scala, aber ich denke nicht, dass es ein Problem ist, sie zu verwenden, wenn es sich um einen Code handelt, der "nur bewegen" sagt [^ 1]. Wenn Sie zu sehr auf funktionale Weise schreiben und denjenigen, die den Code sehen, ein Gefühl der Einschüchterung vermitteln, denke ich, dass dies oft nicht funktioniert, selbst wenn Sie versuchen, die Basis der Entwickler zu erweitern. Das Schreiben von Java-ähnlich in Scala hat zwar einige Vorteile, aber ich denke, es ist besser, wenn Sie die Verwendung von Vars und Mutables vermeiden können.
Persönlich versuche ich, den Fall des Schreibens der Java-Implementierung in Scala zu strukturieren und anzuwenden, aber ich dachte, es wäre für jemanden nützlich, also schreibe ich es jedes Mal, wenn ich daran denke. Ich dachte. Bitte geh mit mir aus, wenn du magst.
Zum Beispiel verwende ich häufig Stammdaten in einer Map mit einem ID-Wert als Schlüssel, wie z. B. einem Cache.
Element(Klient)
public class Customer {
/**Kundennummer. */
public Long id;
/**Kundenname. */
public String name;
/**Alter. */
public Integer age;
}
Zielliste
//Ursprünglich ist die Kundenliste ein Dunst von DB usw.
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 → Kartenkonvertierungsprozess
Map<Long, Customer> customerMap = new HashMap<>();
for(Customer customer : customerList) {
customerMap.put(customer.id, customer);
}
Dadurch wird eine Kundenkarte erstellt, in der der Schlüssel die Kunden-ID und der Wert die Kundeninstanz ist.
Element(Klient)
/**
*Klient.
* @param id Kunden-ID
* @Parametername Kundenname
* @param Alter Alter
*/
case class Customer(id:Long, name:String, age:Int)
Zielliste
//Ursprünglich ist die Kundenliste ein Dunst von DB usw.
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 → Kartenkonvertierungsprozess
val customerMap = (customerList map (t => t.id -> t)).toMap
Seq [(Long, Customer)] [^ 2] wird durch Kartenoperation von Seq [Customer] erstellt. Darüber hinaus handelt es sich um ein Bild, das von toMap in Map [Long, Customer] konvertiert wird. Die generierte Karte ist eine unveränderliche Karte. Machen Sie sich also keine Sorgen, dass sie sich ändert.
Natürlich ist es möglich, es wie Java mit einer veränderlichen Map zu beschreiben, aber ich denke, es ist einfacher zu verstehen, dass dies eine Map aus einer Liste generiert. Da es nicht notwendig ist, den Prozess des Erstellens einer leeren Map-Instanz und den Prozess des Hinzufügens eines Elements zur Map zu beschreiben, wird angenommen, dass Codierungsfehler reduziert werden können [^ 3].
Zum Beispiel basierend auf der Liste der Rechnungsdetails, die mit mehreren von einem SQL erfassten Rechnungs-IDs verknüpft ist Schlüssel: Abrechnungs-ID Wert: Liste der Rechnungsdetails, die der Rechnungs-ID zugeordnet sind Es sieht so aus, wenn Sie eine Karte von erstellen.
Element(Abrechnung)
/**
*Abrechnung.
*/
public class BillingStatement {
/**Abrechnungsposten-ID(PK). */
public Long id;
/**Abrechnungs-ID(FK). */
public Long billingId;
/**Produktname. */
public String itemName;
//Ich denke, es gibt Mengen und Stückpreise, aber sie werden weggelassen.
}
Zielliste
//Ursprünglich ist billingStatementList ein Dunst von DB usw.
List<BillingStatement> billingStatementList = new ArrayList<BillingStatement>(){{
add(new BillingStatement(){{
this.id = 1L;this.billingId = 1L;
this.itemName = "Abrechnung 1 Produkt 1";
}});
add(new BillingStatement(){{
this.id = 2L;this.billingId = 1L;
this.itemName = "Abrechnung 1 Produkt 2";
}});
add(new BillingStatement(){{
this.id = 3L;this.billingId = 2L;
this.itemName = "Abrechnung 2 Produkt 1";
}});
add(new BillingStatement(){{
this.id = 4L;this.billingId = 3L;
this.itemName = "Abrechnung 3 Produkt 1";
}});
add(new BillingStatement(){{
this.id = 5L;this.billingId = 3L;
this.itemName = "Abrechnung 3 Produkt 2";
}});
add(new BillingStatement(){{
this.id = 6L;this.billingId = 3L;
this.itemName = "Abrechnung 3 Produkt 3";
}});
}};
Liste → Kartenkonvertierungsprozess
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);
}
Dadurch wird eine Karte der Liste der Rechnungsdetails mit dem Schlüssel für die Rechnungs-ID und dem Wert für die Rechnungs-ID erstellt. Verarbeitung, wenn die mit der Rechnungs-ID verknüpfte Liste nicht vorhanden ist ... Haben Sie das Gefühl, dass Sie versehentlich einen Fehler einfügen könnten?
Element(Abrechnung)
/**
*Abrechnung.
*Ich denke, es gibt Mengen und Stückpreise, aber sie werden weggelassen.
* @Parameter-ID Abrechnungszeilen-ID(PK)
* @param billingId Billing ID(FK)
* @param itemName Produktname
*/
case class BillingStatement(id:Long, billingId:Long, itemName:String)
Zielliste
//Ursprünglich ist billingStatementList ein Dunst von DB usw.
val billingStatementList = Seq(
BillingStatement(id=1L, billingId=1L, itemName="Abrechnung 1 Produkt 1"),
BillingStatement(id=2L, billingId=1L, itemName="Abrechnung 1 Produkt 2"),
BillingStatement(id=3L, billingId=2L, itemName="Abrechnung 2 Produkt 1"),
BillingStatement(id=4L, billingId=3L, itemName="Abrechnung 3 Produkt 1"),
BillingStatement(id=5L, billingId=3L, itemName="Abrechnung 3 Produkt 2"),
BillingStatement(id=6L, billingId=3L, itemName="Abrechnung 3 Produkt 3")
)
Liste → Kartenkonvertierungsprozess
val billingStatementsMap = billingStatementList.foldLeft(Map[Long, Seq[BillingStatement]]()){(map,value) => {
val key = value.billingId
map.updated(key, map.getOrElse(key, Seq()) :+ value)
}}
Die generierte Karte ist eine unveränderliche Karte. Linderung.
map.getOrElse (key, Seq ()) ist
Wenn der Wert, der dem in der Karte angegebenen Schlüssel zugeordnet ist, registriert ist, wird dieser Wert zurückgegeben, und wenn er nicht registriert ist, wird eine leere Seq zurückgegeben.
Fügt dieser Seq einen Elementwert hinzu und gibt eine neue Map mit aktualisierten Elementen zurück, die dem Schlüssel zugeordnet sind.
Mit FoldLeft, das früher nur zum Hinzufügen von Elementen verwendet wurde, können Fehler vermieden werden [^ 4].
Eine sorgfältige Codierung kann Fehler und Irrtümer reduzieren. Aber Menschen sind Wesen, die Fehler machen. Ich denke, wenn Sie viele Variablen und Operationen kombinieren, um das Ergebnis zu erhalten, ist es wahrscheinlicher, dass Sie einen Fehler "versehentlich" einbetten. Warum nicht die Zeit und Konzentration aufwenden, um "vorsichtig" mit "Dingen umzugehen, die nur Menschen tun können", indem sie die Funktionen der Entwicklungssprache nutzen?
[^ 1]: Wenn Sie versuchen, eine FW oder eine Basisklasse für Ihr Projekt zu erstellen, kann dies natürlich ein Problem sein ... [^ 2]: Seq mit Element Tuple2 [^ 3]: Übrigens habe ich bis vor einiger Zeit einen Prozess geschrieben, um Map.newBuilder ein Element hinzuzufügen und es in den Blockbereich zu führen. [^ 4]: Wenn Sie mehrere Ergebnisse in einer Schleife zurückgeben möchten, können Sie Tuple übergeben.
Recommended Posts