Uso e esempio di Java HashMap computeIfAbsent()

Metodi HashMap Java

Il metodo computeIfAbsent() di Java HashMap calcola un nuovo valore, se la chiave non è associata a nessun valore nell'hash mapping, allora la associa al chiave specificato.

La sintassi del metodo computeIfAbsent() è:

hashmap.computeIfAbsent(K key, Function remappingFunction)

Parametri computeIfAbsent()

computeIfAbsent() metodo ha due parametri:

• key - Correlata al valore di calcolo

• remappingFunction - Per la chiave specificatachiaveFunzione per calcolare un nuovo valore

AttenzioneLa funzione di rimappatura non può accettare due parametri.

Valore restituito da computeIfAbsent()

• restituisce il nuovo valore o il valore vecchio associato alla chiave specificata

• funzione per calcolare un nuovo valore specificato per la chiave

AttenzioneAttenzione: se il risultato di remappingFunction è null, verrà eliminato il valore specificatochiavemappatura.

Esempio 1: Java HashMap computeIfAbsent()

import java.util.HashMap;
class Main {
　　public static void main(String[] args) {
　　　　//Crea una HashMap
　　　　HashMap<String, Integer> prices = new HashMap<>();
　　　　//Inserisci un elemento nella HashMap
　　　　prices.put("Shoes", 200);
　　　　prices.put("Bag", 300);
　　　　prices.put("Pant", 150);
　　　　System.out.println("HashMap: " + prices);
　　　　//Calcola il valore della camicia
　　　　int shirtPrice = prices.computeIfAbsent("Shirt", key -> 280);
　　　　System.out.println("Prezzo della camicia: " + shirtPrice);
　　　　//Stampa la HashMap aggiornata
　　　　System.out.println("HashMap aggiornato: " + prices);
　　}
}

Risultato di output

HashMap: {Pant=150, Bag=300, Shoes=200}
Prezzo della camicia: 280
HashMap aggiornata: {Pant=150, Shirt=280, Bag=300, Shoes=200}

Nell'esempio sopra, abbiamo creato una mappa hash chiamata prices. Nota l'espressione

prices.computeIfAbsent("Shirt", key -> 280)

Ecco,

• key -> 280 - È un'espressione lambda. Restituisce il valore 280. Per ulteriori informazioni sulle espressioni lambda, visitaEspressioni Lambda Java.

• prices.computeIfAbsent() - Asocia il nuovo valore restituito dall'espressione lambda alla mappatura di Shirt. È possibile farlo perché Shirt non è mappato a nessun valore nel hashmap.
  

Esempio 2: se la chiave esiste già, usa computeIfAbsent()

import java.util.HashMap;
class Main {
　　public static void main(String[] args) {
　　　　//Crea una HashMap
　　　　HashMap<String, Integer> prices = new HashMap<>();
　　　　//Inserisci un elemento nella HashMap
　　　　prices.put("Shoes", 180);
　　　　prices.put("Bag", 300);
　　　　prices.put("Pant", 150);
　　　　System.out.println("HashMap: " + prices);
　　　　//Esiste già la mappatura di Shoes
　　　　//Non calcolare il nuovo valore di Shoes
　　　　int shoePrice = prices.computeIfAbsent("Shoes", (key) -> 280);
　　　　System.out.println("Prezzo delle scarpe: " + shoePrice);
　　　　//Stampa la HashMap aggiornata
　　　　System.out.println("HashMap aggiornato: " + prices);
　　}
}

Risultato di output

HashMap: {Pant=150, Bag=300, Shoes=180}
Prezzo delle scarpe: 180
HashMap aggiornato: {Pant=150, Bag=300, Shoes=180}

Nel esempio sopra, la mappatura di Shoes esiste già nella mappa hash. Pertanto, il metodo computeIfAbsent() non calcolerà un nuovo valore per Shoes.

Leggi di più

• HashMap compute() - Calcola il valore specificato della chiave

• HashMap computeIfPresent() - Se la chiave specificata è già mappata a un valore, calcola quel valore

• Metodo merge() di HashMap Java - Esegue la stessa operazione di compute()

Metodi HashMap Java