Uso e esempio del metodo replace() di HashMap Java

Metodi HashMap Java

Il metodo replace() di HashMap Java sostituisce la mappa specificata con un nuovo valore nel hashmap

La sintassi del metodo replace() è:

hashmap.replace(K key, V oldValue, V newValue)

Parametro replace()

• key　 - Chiave da sostituire nella mappa

• oldValue （opzionale）- Valore da sostituire nella mappa

• newValue - oldValue è sostituito da questo valore
  

Valore restituito da replace()

　Il metodo replace() di HashMap sostituisce la mappa e restituisce:

• Se il parametro opzionale oldValue non esiste, allora è il valore precedente associato alla chiave specificata
  

• Se esiste un parametro opzionale oldValue, allora è true
  

Attenzione: Se la chiave specificata映射到null valore, o la chiave non è presente nel hashmap, questo metodo restituisce null.

Esempio 1: Sostituzione dell'entrata in HashMap

import java.util.HashMap;
class Main {
　　public static void main(String[] args) {
　　　　// Creo HashMap
　　　　HashMap<Integer, String> languages = new HashMap<>();
　　　　//Aggiunta dell'entrata alla mappa
　　　　languages.put(1, "Python");
　　　　languages.put(2, "English");
　　　　languages.put(3, "JavaScript");
　　　　System.out.println("HashMap: " + languages);
　　　　//Sostituzione della chiave 2 nella mappa
　　　　String value = languages.replace(2, "Java");
　　　　System.out.println("Valore sostituito: " + value);
　　　　System.out.println("HashMap aggiornata: " + languages);
　　}
}

Risultato di output

HashMap: {1=Python, 2=English, 3=JavaScript}
Valore sostituito: English
HashMap aggiornata: {1=Python, 2=Java, 3=JavaScript}

Nell'esempio sopra, abbiamo creato una mappa hash chiamata languages. Qui, abbiamo utilizzato il metodo replace() per sostituire la chiave1(1=English) dell'entrata sostituita con il valore specificato Java.

In questo caso, il metodo replace() non ha un parametro opzionale oldValue. Pertanto, restituisce il valore vecchio (English).

Esempio 2: HashMap con replace() che ha un valore vecchio

import java.util.HashMap;
class Main {
　　public static void main(String[] args) {
　　　　// Crea HashMap
　　　　HashMap<String, String> countries = new HashMap<>();
　　　　// Inserisci l'elemento nel HashMap
　　　　countries.put("Washington", "America");
　　　　countries.put("Ottawa", "Canada");
　　　　countries.put("Canberra", "Australia");
　　　　System.out.println("Countries:\n" + countries);
　　　　// Sostituisci la mappatura {Washington = America}
　　　　countries.replace("Washington", "America", "USA"); // restituisce true
　　　　countries.replace("Canberra", "New Zealand", "Victoria"); // restituisce false
　　　　System.out.println("Countries dopo l'esecuzione di replace():\n" + countries);
　　}
}

Risultato di output

Countries:
{Canberra=Australia, Ottawa=Canada, Washington=America}
Countries dopo l'esecuzione di replace():
{Canberra=Australia, Ottawa=Canada, Washington=USA}

Nell'esempio sopra, abbiamo creato una mappatura hash chiamata countries. Nota questa riga,

countries.replace("Washington", "America", "USA");

In questo caso, il metodo replace() include un parametro opzionale oldValue (America). Pertanto, la mappatura del valore 'Washington' mappato alla chiave 'America' viene sostituita con il nuovo valore 'USA'.

Ma attenzione,

countries.replace("Canberra", "New Zealand", "Victoria");

In questo caso, la chiave 'Canberra' non è mappata al valore 'New Zealand' nella mappatura hash. Pertanto, il metodo replace() non sostituirà alcun valore.

AttenzionePossiamo usare　 HashMap clear() Java 　Metodo rimuove tutte le mappature dalla mappatura hash.

HashMap put() e replace()

Nella HashMap, la sintassi dei metodi put() e replace() sembra molto simile.

// Sintassi di put()
hashmap.put(key, value)
// Sintassi di replace()
hashmap.replace(key, value)

E quando la mappatura hash contiene la mappatura specificataChiaveentrambi i metodi sostituiranno il valore associato alla chiave specificata.

Ma se la mappatura hash non contiene la mappatura specificatadella chiavePer qualsiasi mappatura, se

• Il metodo put() sostituisce ilChiaveeValoreInserimento di una nuova mappatura

• Il metodo replace() restituisce null

Esempio 3: Metodi put() e replace() di HashMap

import java.util.HashMap;
class Main {
　　public static void main(String[] args) {
　　　　// Creo HashMap
　　　　HashMap<Integer, String> languages1 = new HashMap<>();
　　　　// Inserisco elementi nella HashMap
　　　　languages1.put(1, "Python");
　　　　languages1.put(2, "JavaScript");
　　　　// Creo un'altra HashMap simile a languages1
　　　　HashMap<Integer, String> languages2 = new HashMap<>();
　　　　// Inserisco tutti gli elementi da language1 in language2
　　　　languages2.putAll(languages1);
　　　　System.out.println("HashMap: " + languages1);
　　　　// Utilizzo di put()
　　　　languages2.put(3, "Java");
　　　　System.out.println("HashMap dopo put():\n" + languages2);
　　　　// Utilizzo di replace()
　　　　languages1.replace(3, "Java");
　　　　System.out.println("HashMap dopo replace():\n" + languages1);
　　}
}

Risultato di output

HashMap: {1=Python, 2=JavaScript}
HashMap dopo put():
{1=Python, 2=JavaScript, 3=Java}
HashMap successivo HashMap():
{1=Python, 2=JavaScript}

Nell'esempio sopra, abbiamo creato due mappature hash chiamate languages1 e languages2. Abbiamo utilizzatoHashMap putAll()Metodo in modo che due mappature hash abbiano le stesse mappature.

In questo caso, non esiste una chiave nel mappatura hash3Mappatura. Pertanto,

• Il metodo put() aggiunge una nuova mappatura(3 = Java) Aggiungia HashMap

• Il metodo replace() non esegue alcuna operazione

AccediHashMap put() JavaMetodi per ulteriori informazioni sull'aggiunta di elementi.

Metodi HashMap Java