Is there performance gain using . replace() instead of . put() in a Map?

Question

Is there any performance gain using the method .replace() instead of using .put() in a Map.

Studying Maps I noticed that the method .put() and .replace() have practically the same function. I made a simple code and tested and the resulting was the same in both cases:

public static HashMap<String, String> Lista = new HashMap<String, String>();

public void methodTeste(String teste, String outra) {
    if (Lista.containsKey(teste)) {
        Lista.replace(teste, outra);
    } else {
        Lista.put(teste, outro);
    }
}

public void methodTeste(String teste, String outra) {
    Lista.put(teste, outro);
}

Which of the two codes will get better performance?

Answer 1

replace() is more efficient in cases where there is no key being used in it. It can only replace a value from an existing key, executes nothing if it does not have the key. Already the put() will place a value there, if the key exists it will be equal to the replace(), but if it does not exist you will have to create the key on the map, which has extra cost.

But performance should not be considered, the important thing is the semantics that wants to give, they give different results in certain circumstances, as shown above, so I use what you need.

In this example the test makes no sense (obviously that the first will be slower, it does much more and gives different result to the second, it makes no sense to compare these two things). If you only want to change the value if the key exists and not create a new one, use the replace(). To get the same result with put() would have to do so:

if (Lista.containsKey(teste)) lista.put(teste, outro);

which is the same as:

lista.replace(teste, outra);

Documentation.

The proper test would be thus:

import java.util.*;

class Main {
    public static HashMap<String, String> lista = new HashMap<>();
    
    private static void Put(String teste, String outra) {
        for (int i = 0; i < 100000; i++) if (lista.containsKey("antonio")) lista.put(teste, outra);
    }
    
    private static void Replace(String teste, String outra) {
        for (int i = 0; i < 100000; i++) lista.replace(teste, outra);
    }
    
    public static void main(String[] args) {
        long inicio = System.currentTimeMillis();
        Put("antonio", "antonio");
        System.out.println("Put: " + (System.currentTimeMillis() - inicio)  + " ms");
        inicio = System.currentTimeMillis();
        Replace("antonio", "antonio");
        System.out.println("Replace: " + (System.currentTimeMillis() - inicio) + " ms");
    }
}

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.

Answer 2

If you use put() with an existing key, it will be overwritten. The map doesn’t have duplicate keys. You use replace to overwrite and put to add, but put does both.

Answer 3

Take this simple test:

public static HashMap<String, String> Lista = new HashMap<>();

private static void methodTeste1(String teste, String outra) {
    for (int i = 0; i < 100000; i++) {
        if (Lista.size() > 0) {
            Lista.replace(teste, outra);
        } else {
            Lista.put(teste, outra);
        }
    }
}

private static void methodTeste2(String teste, String outra) {
    for (int i = 0; i < 100000; i++) {
        Lista.put(teste, outra);
    }

}

public static void main(String[] args) {
    long inicio, fim;

    inicio = System.currentTimeMillis();
    methodTeste1("antonio", "antonio");
    fim = System.currentTimeMillis();
    System.out.println("Replace: " + (fim-inicio)  + " ms");


    inicio = System.currentTimeMillis();
    methodTeste2("antonio", "antonio");
    fim = System.currentTimeMillis();
    System.out.println("Put: " + (fim-inicio) + " ms");
}

Answer 4

After several tests I came to a conclusion: The .replace It should only be used when you’re sure the KEY already exists. If you are not sure of the existence of KEY (like my case) is more advantageous the use of . put right.

In the test where the existence of KEY was right and there was no need for checks on the .replace won easily:

public static HashMap<String, String> Lista = new HashMap<>();

private static void methodTeste1(String teste, String outra) {
    for (int i = 0; i < 100000; i++) {
        Lista.replace(teste, outra);    
    }
}

private static void methodTeste2(String teste, String outra) {
    for (int i = 0; i < 100000; i++) {
        Lista.put(teste, outra);
    }
}

public static void main(String[] args) {
    long inicio, fim;
    Lista.put("antonio", "antonio");

    inicio = System.currentTimeMillis();
    methodTeste1("antonio", "antonio");
    fim = System.currentTimeMillis();
    System.out.println("Replace: " + (fim-inicio)  + " ms");

    inicio = System.currentTimeMillis();
    methodTeste2("antonio", "antonio");
    fim = System.currentTimeMillis();
    System.out.println("Put: " + (fim-inicio) + " ms");
}

In the test where the existence of KEY was not certain and we were obliged to make checks the .put achieved a significantly higher performance:

public static HashMap<String, String> Lista = new HashMap<>();

private static void methodTeste1(String teste, String outra) {
    for (int i = 0; i < 100000; i++) {
        if (Lista.containsKey("antonio")) {
            Lista.replace(teste, outra);
        } else {
            Lista.put(teste, outra);
        }
    }
}

private static void methodTeste2(String teste, String outra) {
    for (int i = 0; i < 100000; i++) {
        Lista.put(teste, outra);
    }

}

public static void main(String[] args) {
    long inicio, fim;

    inicio = System.currentTimeMillis();
    methodTeste1("antonio", "antonio");
    fim = System.currentTimeMillis();
    System.out.println("Replace: " + (fim-inicio)  + " ms");

    inicio = System.currentTimeMillis();
    methodTeste2("antonio", "antonio");
    fim = System.currentTimeMillis();
    System.out.println("Put: " + (fim-inicio) + " ms");
}

Completion: .replace has greater performance than .put but everything will depend on the situation.