Where is `+` implemented for Strings in the Java source code? [duplicate]

You can check with specification. The compiler have the implementation of it, not the Java source code.

Java Language Specification- 15.18.1. String Concatenation Operator +

An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression.

It shows the evidence that the implementation is depends on the compiler.

Java compilers have the implementation for +. The Javadocs says:

The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. String concatenation is implemented through the StringBuilder(or StringBuffer) class and its append method. String conversions are implemented through the method toString, defined by Object and inherited by all classes in Java. For additional information on string concatenation and conversion, see Gosling, Joy, and Steele, The Java Language Specification.

You can try to check this:

public static void main(String[] args) {
    String s1 = "s1";
    String s2 = "s2";
    String s3 = s1 + s2;
    String s4 = new StringBuilder(s1).append(s2).toString();
}

The above code generates the same bytecode for + and when using StringBuilder:

L0
LINENUMBER 23 L0
LDC "s1"
ASTORE 1

L1
LINENUMBER 24 L1
LDC "s2"
ASTORE 2

// s3 = s1 + s2

L2
LINENUMBER 25 L2

NEW java/lang/StringBuilder
DUP
ALOAD 1
INVOKESTATIC java/lang/String.valueOf(Ljava/lang/Object;)Ljava/lang/String;
INVOKESPECIAL java/lang/StringBuilder.<init>(Ljava/lang/String;)V
ALOAD 2
INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
INVOKEVIRTUAL java/lang/StringBuilder.toString()Ljava/lang/String;

ASTORE 3

// s4 = new StringBuilder(s1).append(s2).toString()

L3
LINENUMBER 26 L3

NEW java/lang/StringBuilder
DUP
ALOAD 1
INVOKESPECIAL java/lang/StringBuilder.<init>(Ljava/lang/String;)V
ALOAD 2
INVOKEVIRTUAL java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
INVOKEVIRTUAL java/lang/StringBuilder.toString()Ljava/lang/String;

ASTORE 4
L4
LINENUMBER 27 L4
RETURN

While currently most of Java compilers using StringBuilder chain, it's not specified that it should be always in this way. In particular there's a proposal to change this drastically in Java-9 replacing with single invokedynamic call and introduce new metafactory which will generate an appropriate MethodHandle in runtime to perform concatenation.

As for the language, no, it's not extensible. This is specific behavior, no other class extends the + operator.

As for where this is done, search for string_add (not a real JVM op) in the following files:

• Operator definition

• Code generator

As to why, Java was supposed to be simple, or at least simpler than C++, and a basic thing like string manipulation was kind of mandatory. However, operator overloading would add complexity.