The String class and Java's dependency on it

Question

So everyone knows that the shortest Java program that you can write is:

public class Program{
     public static void main(String []args){

     }
}

One would suspect that this shortest program would only consist out of language keywords, chosen names (like class name / function name / parameter name) and some syntax (brackets, etc).

But when you look closely suddenly the String class pops up. So does that mean that the language Java can not live without its String class? Or even without the complete standard library? (I thought C++ is able to exist without its standard library, no?)

Also I have been looking at the String class code but nowhere was an implementation of the operators + and += (maybe others are available?) to be found. How does this work then? Is this embedded as a special case in the compiler? Which would even bind the String class even tighter to the java language?

Are there other classes that are embedded so deeply in the Java language?

Answer 1

A Java String contains an immutable sequence of Unicode characters. Unlike C/C++, where string is simply an array of char, A Java String is an object of the class java.lang.

String is special class in Java and all String literal e.g. "abc"(anything inside double quotes) are maintained in a separate String pool, special memory location inside Java memory, more precisely inside PermGen Space.

Any time you create a new String object using String literal, JVM first checks String pool and if an object with similar content available, than it returns that and doesn't create a new object. JVM doesn't perform String pool check if you create object using new operator.

Unlike an ordinary class:

   String is associated with string literal in the form of double-quoted
   texts such as "Hello, world!". 

   You can assign a string literal directly into a String variable,
   instead of calling the constructor to create a String instance.

   The '+' operator is overloaded to concatenate two String operands.
   '+' does not work on any other objects such as your Person.java etc.

   String is immutable. That is, its content cannot be modified once it
   is created. For example, the method toUpperCase() constructs and
   returns a new String instead of modifying its existing content.

Strings receive special treatment in Java, because they are used frequently in a program. Hence, efficiency (in terms of computation and storage) is crucial.

The designers of Java decided to retain primitive types in an object-oriented language, instead of making everything an object, so as to improve the performance of the language.

Primitives are stored in the call stack, which require less storage spaces and are cheaper to manipulate. On the other hand, objects are stored in the program heap, which require complex memory management and more storage spaces.

The '+' operator, which performs addition on primitives (such as int and double), is overloaded to operate on String objects. '+' performs concatenation for two String operands. Java does not support operator overloading for software engineering consideration unlike C++ where you you can turn a '+' operator to perform a subtraction.

The '+' operator is the only operator that is internally overloaded to support string concatenation in Java. Take note that '+' does not work on any two arbitrary objects.

The JDK compiler, in fact, uses both String and StringBuffer to handle string concatenation via the '+' operator. For examples,

String msg = "a" + "b" + "c";

will be compiled into the following codes for better efficiency:

String msg = new StringBuffer().append("a").append("b").append("c").toString();

For performance reason, Java's String is designed to be in between a primitive and a class.

Answer 2

In the Java Language Specification, section 1.4:

1.4. Relationship to Predefined Classes and Interfaces

As noted above, this specification often refers to classes of the Java SE platform API. In particular, some classes have a special relationship with the Java programming language. Examples include classes such as Object, Class, ClassLoader, String, Thread, and the classes and interfaces in package java.lang.reflect, among others. This specification constrains the behavior of such classes and interfaces, but does not provide a complete specification for them. The reader is referred to the Java SE platform API documentation.

So all these classes are required to be present or it would not be considered standard Java.

The Object and String classes are fleshed out more fully by sections 4.3.2 and 4.3.3, respectively.

4.3.2. The Class Object

The class Object is a superclass (§8.1.4) of all other classes.

All class and array types inherit (§8.4.8) the methods of class Object, which are summarized as follows:

• The method clone is used to make a duplicate of an object.

• The method equals defines a notion of object equality, which is based on value, not reference, comparison.

• The method finalize is run just before an object is destroyed (§12.6).

• The method getClass returns the Class object that represents the class of the object.

  A Class object exists for each reference type. It can be used, for example, to discover the fully qualified name of a class, its members, its immediate superclass, and any interfaces that it implements.

  The type of a method invocation expression of getClass is Class<? extends |T|> where T is the class or interface searched (§15.12.1) for getClass.

• A class method that is declared synchronized (§8.4.3.6) synchronizes on the monitor associated with the Class object of the class.

• The method hashCode is very useful, together with the method equals, in hashtables such as java.util.Hashmap.

• The methods wait, notify, and notifyAll are used in concurrent programming using threads (§17.2).

• The method toString returns a String representation of the object.

4.3.3. The Class String

Instances of class String represent sequences of Unicode code points.

A String object has a constant (unchanging) value.

String literals (§3.10.5) are references to instances of class String.

The string concatenation operator + (§15.18.1) implicitly creates a new String object when the result is not a constant expression (§15.28).

---

Also consider Throwable, without which no try/catch statement could even be compiled (14.20):

Each class type used in the denotation of the type of an exception parameter must be the class Throwable or a subclass of Throwable, or a compile-time error occurs.