Il metodo Java HashMap replace () sostituisce la mappatura per la chiave specificata con il nuovo valore specificato in una hashmap.
La sintassi del replace()metodo è:
hashmap.replace(K key, V oldValue, V newValue)
In questo caso, hashmap è un oggetto della HashMapclasse.
sostituire () parametri
Il replace()metodo può richiedere 3 parametri.
- key - chiave la cui mappatura deve essere sostituita
- oldValue (opzionale) - valore da sostituire nella mappatura
- newValue - oldValue viene sostituito con questo valore
sostituire () Valori di ritorno
Il replace()metodo HashMap sostituisce la mappatura e restituisce:
- il valore precedente associato alla chiave specificata, se il parametro opzionale oldValue non è presente
true, se è presente il parametro facoltativo oldValue
Nota : il metodo restituisce null, se la chiave specificata è mappata su un valore nullo o la chiave non è presente nella hashmap.
Esempio 1: sostituire una voce in HashMap
import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap languages = new HashMap(); // add entries to HashMap languages.put(1, "Python"); languages.put(2, "English"); languages.put(3, "JavaScript"); System.out.println("HashMap: " + languages); // replace mapping for key 2 String value = languages.replace(2, "Java"); System.out.println("Replaced Value: " + value); System.out.println("Updated HashMap: " + languages); ) )
Produzione
HashMap: (1 = Python, 2 = inglese, 3 = JavaScript) Valore sostituito: inglese HashMap aggiornato: (1 = Python, 2 = Java, 3 = JavaScript)
Nell'esempio precedente, abbiamo creato una hashmap denominata languages. In questo caso, abbiamo utilizzato il metodo replace () per sostituire la voce per la chiave 1 (1 = inglese) con il valore Java specificato.
Qui, il replace()metodo non ha il parametro oldValue opzionale. Quindi, restituisce il vecchio valore (inglese).
Esempio 2: HashMap replace () con Old Value
import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap countries = new HashMap(); // insert items to the HashMap countries.put("Washington", "America"); countries.put("Ottawa", "Canada"); countries.put("Canberra", "Australia"); System.out.println("Countries:" + countries); // replace mapping (Washington = America) countries.replace("Washington", "America", "USA"); // return true countries.replace("Canberra", "New Zealand", "Victoria"); // return false System.out.println("Countries after replace():" + countries); ) )
Produzione
Paesi: (Canberra = Australia, Ottawa = Canada, Washington = America) Paesi dopo la sostituzione (): (Canberra = Australia, Ottawa = Canada, Washington = USA)
Nell'esempio sopra, abbiamo creato una hashmap denominata paesi. Notare la linea,
countries.replace("Washington", "America", "USA");
Qui, il metodo replace () include il parametro facoltativo oldValue (America). Quindi, la mappatura in cui Washington mappa chiave per valutare l'America viene sostituita con il nuovo valore USA.
Tuttavia, nota la linea,
countries.replace ("Canberra", "Nuova Zelanda", "Victoria");
Qui, nella hashmap, la chiave di Canberra non viene mappata per valutare la Nuova Zelanda. Quindi, il metodo replace () non sostituisce alcun valore.
Nota : possiamo utilizzare il metodo Java HashMap clear () per rimuovere tutte le mappature dalla hashmap.
HashMap put () vs. sostituire()
La sintassi del metodo put()e replace()è abbastanza simile in HashMap.
// syntax of put() hashmap.put(key, value) // syntax of replace() hashmap.replace(key, value)
E, quando l'hashmap contiene la mappatura per la chiave specificata , entrambi i metodi sostituiscono il valore associato alla chiave specificata.
Tuttavia, se l'hashmap non contiene alcuna mappatura per la chiave specificata , allora
- il
put()metodo inserisce la nuova mappatura per la chiave e il valore specificati - il
replace()metodo ritornanull
Esempio 3: HashMap put () vs. sostituire()
import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap languages1 = new HashMap(); // insert entries to HashMap languages1.put(1, "Python"); languages1.put(2, "JavaScript"); // create another HashMap similar to languages1 HashMap languages2 = new HashMap(); // puts all entries from languages1 to languages2 languages2.putAll(languages1); System.out.println("HashMap: " + languages1); // use of put() languages2.put(3, "Java"); System.out.println("HashMap after put():" + languages2); // use of replace() languages1.replace(3, "Java"); System.out.println("HashMap after replace():" + languages1); ) )
Produzione
HashMap: (1 = Python, 2 = JavaScript) HashMap dopo put (): (1 = Python, 2 = JavaScript, 3 = Java) HashMap dopo sostituire (): (1 = Python, 2 = JavaScript)
Nell'esempio sopra, abbiamo creato due hashmap denominate languages1 e languages2. Abbiamo utilizzato il metodo putAll () di HashMap in modo che entrambe le hashmap abbiano le stesse mappature.
Qui, la mappatura per la chiave 3 non è presente nella hashmap. Quindi,
- il
put()metodo aggiunge la nuova mappatura (3 = Java) aHashMap - il
replace()metodo non esegue alcuna operazione
Per ulteriori informazioni sull'aggiunta di voci, visitare Java HashMap put ().
