String s1 = new StringBuilder(” Go “).append(” od “).toString();
System.out.println(s1.intern() == s1); String s2 = new
StringBuilder(” ja “).append(” va “).toString(); String s2 = new
StringBuilder(” ja “).append(” va “).toString();
System.out.println(s2.intern() == s2); Output is true or false
in the search on the net, have explained string constants in the pool a Java this string constants, and so the example below would be false.

String sb =new StringBuilder(” Go “).append(” OD “).toString();
String sb =new StringBuilder(” Go “).append(” OD “).toString();
String s1 = new String(” Good “);
System.out.println(sb.intern()==sb);
returns false!!
originally used in intern method, will first judgment in the constant pool have the corresponding string, have put the string, not words

The intern() implementation in JDK 1.7 does not copy the instance any more, it just records the instance reference that first appears in the constant pool, so the reference returned by the intern() is the same as the instance of the string created by the StringBuilder

Access characteristics of constructors in Java inheritance
The

subclass constructor has a default implicit “super()” call, so it must be the parent constructor called first and the subclass constructor executed later. Subclass constructs can be invoked with the super keyword to call superclass overloaded constructs. Super’s superclass constructor call must be the first statement of the subclass constructor. A subclass construct cannot call the super construct more than once.

Conclusion:
subclasses must call the superclass constructor, don’t write gives super (); You can only have one super, and it has to be the first one.

The compareTo() method is used to compare the two approaches:
String is compared to an object.
compares two strings in dictionary order.
syntax
int compareTo(Object o)
or
Int compareTo(String anotherString)
parameter
o – object to compare.
AnotherString – The string to compare.
Return value
the return value is the integer, it is first to compare the size of the corresponding character (ASCII), if the first character and the parameters of the first character, end of comparison, return the difference between them, if the first character is equal to the parameters of the first character, with the second character and parameter of the second character, and so on, until the comparison of character or character one end are being compared.
If the parameter string is equal to this string, the value 0 is returned;
returns a value less than 0 if the string is smaller than the string argument;
returns a value greater than 0 if the string is greater than the string argument.
instance
public class Test {

public static void main(String args[]) {
    String str1 = "Strings";
    String str2 = "Strings";
    String str3 = "Strings123";

    int result = str1.compareTo( str2 );
    System.out.println(result);
  
    result = str2.compareTo( str3 );
    System.out.println(result);
 
    result = str3.compareTo( str1 );
    System.out.println(result);
}

}
above program execution result is:
0
-3
3