Is the hashcode of a Java String created when the String is created, or only at the first call for hashcode?

My question is quite simple.

When is the hashcode for a String calculated?

1. When the String is created, the hashcode is also computed, and always ready in O(1) after construction
2. The hashcode is computed only the first time the hashCode method is called and is ready in O(1) time for all subsequent calls
3. The hashcode is computed each time the hashCode method is called

Option 1 seems reasonable because Strings are immutable. The hashcode for a given string will never change. But, this slows down the creation of strings, so it also seems reasonable that option 2 would be used. Option 3 seems silly and a waste of time, but saves on space because the hashcode isn't being stored. There may also be some logical reason that Option 3 is the best approach that I'm not thinking about.

Thanks so much in advance

Option 2. It's calculated the first time hashCode is called and stored in a private field.

In OpenJDK 8 it looks like this:

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/lang/String.java#l1452

In fact, if you take a look at what fields String has, you can see it has a private int called hash.

System.out.println(String.class.getDeclaredFields());

output includes

{ ... private int java.lang.String.hash ... }

From the source code JDK 14

   /** Cache the hash code for the string */
    private int hash; // Default to 0


    @HotSpotIntrinsicCandidate
    public String(String original) {
        this.value = original.value;
        this.coder = original.coder;
        this.hash = original.hash;
    }

And then

    public int hashCode() {
        // The hash or hashIsZero fields are subject to a benign data race,
        // making it crucial to ensure that any observable result of the
        // calculation in this method stays correct under any possible read of
        // these fields. Necessary restrictions to allow this to be correct
        // without explicit memory fences or similar concurrency primitives is
        // that we can ever only write to one of these two fields for a given
        // String instance, and that the computation is idempotent and derived
        // from immutable state
        int h = hash;
        if (h == 0 && !hashIsZero) {
            h = isLatin1() ? StringLatin1.hashCode(value)
                           : StringUTF16.hashCode(value);
            if (h == 0) {
                hashIsZero = true;
            } else {
                hash = h;
            }
        }
        return h;
    }

</details>