Interpret the String class in java

String a="aa";

String is not a basic data type, but a reference type. For the above simple sentence, the Java compiler can determine it in the recompilation stage. Then store the "aa" object in the constant pool area of ​​the current class file (note that it is not the heap, specifically the Perm area). The constant pool can also be expanded at runtime, such as the call of "XXX".intern() , that is, injecting data into the constant pool of the class during runtime. Continuous injection can lead to the java.lang.OutofMemory:PermGen space exception. The process is probably to first compare this string with each string in the constant pool for equals. If there is a match, return a reference to the constant pool. If neither exists, inject the constant value and return the current address. You can see String.intern( ) is not very efficient.

private static void test1(){
String a = “a” + “b” +1;
Stirng b = “ab1”;
System.out.println(a==b);
}

Obviously the return result is True

About "==": For basic data types == is to compare the values ​​of basic data types such as (byte, short, int, float, char , double, long, boolean), and for reference types, what is compared is the logical address of the two reference objects

About equals and hashcode(): The equals method of the Object class defaults to the reference of the two objects being compared. Logical address (return (this == obj);), the design of equels is to require subclasses to implement the comparison between two identical subclasses (it makes no sense to compare different subclasses, so I see many equels In the implementation, it is first judged whether the two objects belong to the same class) and whether the objects are equal. Here, it is not whether the reference addresses are equal. Java's default hashcode method provides the hash value of the object. It is a native method (the cost of calling native methods is still very high). Its return value is consistent with the return value of the System.identifyHashCode(Object) method. Usually it is A part of the binary number in the object header. The hashcode method can be said to identify the object and is used to hash the object in the hash algorithm. The String class overrides the HashCode method. It needs to traverse all the chars in char[] to generate the corresponding hashcode of the String class. In fact, the equals method of the object has nothing to do with the hashcode itself. It is just the use of some classes that makes everyone think that rewriting is The equals() method must override the hashcode() method. For example, in HashMap (and HashSet, but HashSet is implemented using HashMap), the process of putting an element in HashMap is to first call the key's hashcode method, and calculate the Entity index based on the return value of this method and the length of the Entity array in HashMap. , if there is already an element on this index, call the equals method of the key for comparison. If there is a reasonable element, replace it. If it does not exist, insert it into the linked list.

About compile-time optimization: For the compiler, the principle of compile-time optimization is to optimize what can be determined (such as final), and do not process what cannot be determined. Optimize final type variables, and optimize methods. The call is not optimized. Note that String a="a" + "b" is optimized to a="ab" at compile time, and String a="a" String b=a+"b" is optimized to the splicing of Stringbuffer at compile time.

The above is the detailed content of Interpret the String class in java. For more information, please follow other related articles on the PHP Chinese website!