Why cannot modify a String field with Reflection?

Question

JDK version: 1.8.0_291

Target class:

package reflectionStackoverflow.test;

public class ClassA {
    private final static StringBuilder nameStringBuilder = new StringBuilder("1");
    private final static String nameString = "1";
 
    public static void printNameStringBuild() {
        System.out.println("nameStringBuilder: " + nameStringBuilder);
    }
    public static void printNameString() {
        System.out.println("nameString: " + nameString);
    }
}

Test Code:

package reflectionStackoverflow.test;

import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ReflectionTest {
    @Test
    public void test() throws NoSuchFieldException, IllegalAccessException, InstantiationException {
        Class c = ClassA.class;

        Field nameStringBuilder = c.getDeclaredField("nameStringBuilder");
        nameStringBuilder.setAccessible(true);
        Field nameStringBuilderModifiers = nameStringBuilder.getClass().getDeclaredField("modifiers");
        nameStringBuilderModifiers.setAccessible(true);
        nameStringBuilderModifiers.setInt(nameStringBuilder, nameStringBuilder.getModifiers() & ~Modifier.FINAL);
        nameStringBuilder.set(c, new StringBuilder("2"));
        nameStringBuilderModifiers.setInt(nameStringBuilder, nameStringBuilder.getModifiers() & ~Modifier.FINAL);

        Field nameString = c.getDeclaredField("nameString");
        nameString.setAccessible(true);
        Field nameStringModifiers = nameString.getClass().getDeclaredField("modifiers");
        nameStringModifiers.setAccessible(true);
        nameStringModifiers.setInt(nameString, nameString.getModifiers() & ~Modifier.FINAL);
        nameString.set(c, "2");
        nameStringModifiers.setInt(nameString, nameString.getModifiers() & ~Modifier.FINAL);

        ClassA.printNameStringBuild();
        ClassA.printNameString();
    }
}

Test result:

nameStringBuilder: 2
nameString: 1

Conclusion:

StringBuilder field can be modified with reflection, but String field can not be modified.

Question:

Why String can not be modified with reflection？

Is there any way to modify a private final static String value like above StringBuilder case?

Answer 1

The Java compiler is required (by the Java Language Specification) to inline constant variables (see https://docs.oracle.com/javase/specs/jls/se17/html/jls-13.html#jls-13.1-110-C for the current version, but the same requirement was already in the JLS for Java 1.6).

You can work around this by making nameString a so called "blank final" (https://docs.oracle.com/javase/specs/jls/se6/html/typesValues.html#10931):

    private static final String nameString;
    static {
        nameString =  "1";
    }

This solves your current problem, but it will get you into trouble if you ever want to upgrade your Java version. Java 12 and later do no longer allow setting the modifier field of the Field class. If your code depends on this hack it will forever be locked to Java versions 11 or lower.

Update to the preceding paragraph: In this case (only running some tests) it might solve your problem but: the JVM is free to optimize the access to the field (even in the case of a blank final field it is declared as final and the JIT optimizer can do optimizations it cannot do with non-final fields)

To show the problem:

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {

    public static void main (String[] args) throws Exception {
        System.out.println("Before:");
        System.out.println("Field1: "+Class2.getField1());
        System.out.println("Field2: "+Class2.getField2());
        System.out.println("Field3: "+Class2.getField3());
        System.out.println("Field3: "+Class2.getField3());
        System.out.println();

        Class c = Class2.class;
        Field f1 = c.getDeclaredField("field1");
        Field f2 = c.getDeclaredField("field2");
        Field f3 = c.getDeclaredField("field3");
        changeField(f1);
        changeField(f2);
        changeField(f3);

        System.out.println("After:");
        System.out.println("Field1: "+Class2.getField1());
        System.out.println("Field2: "+Class2.getField2());
        System.out.println("Field3: "+Class2.getField3());
    }

    private static void changeField(Field field) throws Exception {
        field.setAccessible(true);
        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);
        modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
        field.set(null, "changed");
    }
}

class Class2 {
    private static final String field1 = "no change"; // constant variable, read access must be inlined
    private static final String field2; // blank final
    private static final String field3; // blank final
    static {
        field2 = "no change";
        field3 = "no change";
    }
    public static String getField1() { return field1; }
    public static String getField2() { return field2; }
    public static String getField3() {
        for (int i = 0; i < 1_000_000; i++) {
            if (!field3.equals("no change")) {
                return field3;
            }
        }
        return field3;
    }
}

It will print out

Before:
Field1: no change
Field2: no change
Field3: no change
Field3: no change

After:
Field1: no change
Field2: changed
Field3: no change

So the JIT changed (at runtime) the code method getField3 to no longer access the field field3 but to load the constant "no change" directly. Since field3 is declared as final this is a perfectly legal optimization.

If you try to run it with Java 17 it will throw an exception:

Exception in thread "main" java.lang.NoSuchFieldException: modifiers
  at java.base/java.lang.Class.getDeclaredField(Class.java:2610)
  at Main.changeField(Main.java:xx)
  at Main.main(Main.java:xx)