Home / Questions / 183236
Accepted
Orici
Asked: 2020-07-24 02:40:28 +0800 CST 2020-07-24 02:40:28 +0800 CST

String in java, is it more efficient to create or assign?

  • 772

Let's imagine that I have a Stringthat I am going to assign a value to repeatedly within a loop, what would be more efficient to declare it previously and assign a value to it in each interaction or to do it directly within each iteration?

Example A:

String temp;
for (...) {
   temp = algo;

   // hacer algo
}

Example B:

for (...) {
   String temp = algo;

   // hacer algo
}
java

2 Answers

  1. Best Answer

    In principle, good practices tell us that the ideal is for the variables to have the smallest scope possible , to avoid undesired effects, so all other things being equal, it is advisable to declare the variables within the loop.

    In terms of performance, the Java compiler is smart enough that declaring the variable inside or outside has the same cost, so it is not a parameter to take into account.

    There is one case where I would recommend declaring outside, but this is the exception:

    for (...) {
    String s=calcularValor();
    ... //operaciones con s
};

    The function calcularValor always returns the same value. If the calculation is an expensive operation (reading a file, for example), it is preferable to use it once, even if we do not use the variable outside the loop afterwards.

    • 10

  2. Let's approach the problem from the point of view of the bytecode

    I have created a test class, called Test:

    public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            String temp = String.valueOf(i);
        }
    }
}

    If we compile it and view its bytecode using javac Test.javaand javap -c Test.classrespectively, we will see:

    Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1          // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0
       1: istore_1
       2: iload_1
       3: sipush        1000
       6: if_icmpge     20
       9: iload_1
      10: invokestatic  #2          // Method java/lang/String.valueOf:(I)Ljava/lang/String;
      13: astore_2
      14: iinc          1, 1
      17: goto          2
      20: return
}

    Now, let's change the code of Test:

    public class Test {
    public static void main(String[] args) {
        String temp;
        for (int i = 0; i < 1000; i++) {
            temp = String.valueOf(i);
        }
    }
}

    And let's see the resulting bytecode again:

    Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1              // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0
       1: istore_2
       2: iload_2
       3: sipush        1000
       6: if_icmpge     20
       9: iload_2
      10: invokestatic  #2              // Method java/lang/String.valueOf:(I)Ljava/lang/String;
      13: astore_1
      14: iinc          2, 1
      17: goto          2
      20: return
}

    The only thing that changes is the order of variables. Specifically, from tempand iinside the loop. That is, the bytecode is the same . Knowing this, it is best to follow the best practices, which as already mentioned is to reduce the scope of the variable in question as much as possible. The best option is B.

    • 8