Reading notes-string

"String" is the object that encapsulates the char[] array, consisting of three parts:

1, char array: It is a superset of the string represented by a string object;

2, 3, offset, and count, which represents the starting segment of a string object represented by the strings in a char array;

The string is specifically designed to contain the following three features:

1, invariance: Invariant mode immutable, saving the synchronization and lock waiting consumption;

2, for the "Constant Pool" optimization:

Variable memory space constant pool

String str1 = "abc" ——————— >

String str2 = "abc" ——————— > ABC

String str3 = new String ("ABC")--and str instance ——— >

Note: str1 = = Str3.intern () is TRUE;STR2, str2 directly points to the "ABC" in the constant pool and does not copy;

3, the final definition of the class;

Two construction methods for string:

public String(char value[]) {    this.value = Arrays.copyOf(value, value.length);}String(char[] value, boolean share) { this.value = value;}

The first construction method constructs a new char[] array;

The second construction method shares the original char[] array;

"Memory Leak" the construction method of a shared char[] array that is visible in the second package causes a memory leak

This construction method is a space-time-changing strategy (it is likely to be understood as a time-space, since share space, but most of the cases are GCS that block large spaces);

Calling this constructor will make the original char[] array unusable by the GC, if the original char[] is large, and the new string object references only a small part of it, which is the potential risk of substring (begin, end), Because this method uses the package-visible construction method to return a new string object that shares the old char[] array:

New String (offset + beginindex, endindex-beginindex, value);

The construction method that the package is visible, although the client code cannot be used, the constructor is called indirectly by calling the following method:

integer.tostring;

long.tostring;

String.Concat;

String.Replace;

string.substring;

String.ToLower;

String.ToUpper;

string.valueof;

Like what:

String str = new string (new char[10000000]);

String str2 = str.substring (1, 5);

1 million characters resident memory, cannot GC, because 5 strings are used;

"String Split"

String.Split provides the "regular expression" split feature:

"A;b,c:d". Split ("[; |,|:]");

StringTokenizer is an iterator that splits a string:

StringTokenizer st = new StringTokenizer (orignalstring, ";");

while (St.hasmoretokens ())

st.nextToken();

Use String.IndexOf and string.substring to split the string:

1234567891011121314

while (true) { null; Int J = orignalstr.indexof ('; '); Break ; splitstr = orignalstr.substring (//update string}

Split performance: Split < StringTokenizer < indexof&substring

"String Lookup"

IndexOf (char c) and charat (int index) are string-complementary methods;

String with Startwith and endswith;

Implement Startwith with Charat:

if (Origstr.charat (0) = = ' A ' && origstr.charat (1) = = ' B ' && Origstr.char (2) = = ' C ');

Implement EndsWith with Charat:

if (Origstr.charat (len-1) = = ' C ' && origstr.charat (len-2) = = ' B ' && origstr.char (len-3) = = ' A ');

Charat performance is higher than Startwith and endswith;

"String connection + + = concat StringBuilder StringBuffer"

The concatenated operation of a static string (string constant) is optimized by the compiler's direct operation at compile time:

String result = "ABC +" and "+" 123 "; Performance is higher than

StringBuilder builder = new StringBuilder ();

Builder.append ("abc");

...

Because the + operation of the static string is calculated at compile time, the runtime only has a string of "abcand123", not:

"ABC", "and", "123", "Abcand", "abcand123";

The connection operation of a dynamic string (string variable) is converted to a StringBuilder implementation by the compiler at compile time, and local variables in the loop are no exception:

So

String str1 = "abc";

String str2 = "and";

String STR3 = "append";

String result = str1 + str2 + str3;

Byte code is equivalent to:

String result = (new StringBuilder (String.valueof (STR1))). Append (str2). Append (STR3). toString ();

So, in fact, with + operation and StringBuilder performance is the same;

But the compiler is not smart enough to convert + to StringBuilder, often with too many new StringBuilder objects:

for (int i = 0; i < 10000; i++)

str = str + i;

will be converted by the compiler to:

for (int i = 0; i < 10000; i++)

str = (new StringBuilder(String.valueOf(str))).append(i).toString();

Therefore, you should explicitly use StringBuilder instead of relying on the compiler to convert to the StringBuilder implementation:

StringBuilder sb = new StringBuilder ();

for (int i = 0; i < 100000; i++)

sb.append(i);

StringBuffer is thread-safe, theoretically performing slightly lower than StringBuilder;

StringBuilder and StringBuffer are variable-length char[] arrays, and as with all variable-length arrays, specifying appropriate capacity can save on the cost of expansion and improve performance:

StringBuffer (int capacity) StringBuilder (int capacity);

Efficiency of string connections: StringBuilder >> concat > +

Reading notes-string