Differences in string, StringBuffer, StringBuilder, StringTokenizer in Java

In the Java language, there are 4 classes that can manipulate characters or strings, which are character, string, StringBuffer, StringTokenizer, where character is used for a single character operation, string for string manipulation, is an immutable class, and StringBuffer is also used for string manipulation, but the difference is that StringBuffer belongs to a mutable class.

A string is an immutable class, that is, when a string object is created, its value cannot be changed, and StringBuffer is a mutable class, and its value can still be modified when the object is created. Because string is immutable, it is suitable for use in situations where it needs to be shared, and it is best to use StringBuffer when a string is often required to be modified. If you use string to hold a string that is often modified, the string is modified with a lot more additional operations than StringBuffer, and many useless objects are generated, because these useless objects are recycled by the garbage collector, which can affect the performance of the program.

2. Package test;
6. Public class test{
8. public static void TestString () {
10. String s="Hello";
12. String s1="World";
14. long Start=system.currenttimemillis ();
16. For (int i=0;i<10000;i++) {
18. S+=S1;
20. }
22. long End=system.currenttimemillis ();
24. long Runtime= (End-start);
26. System.out.println (RunTime);
28. }
30. public static void Teststringbuffer () {
32. StringBuffer s=New StringBuffer ("Hello");
34. String s1="World";
36. long Start=system.currenttimemillis ();
38. For (int i=0;i<10000;i++) {
40. S.append (S1);
42. }
44. long End=system.currenttimemillis ();
46. long Runtime= (End-start);
48. System.out.println (RunTime);
50. }
52. public static void Teststringbuilder () {
54. StringBuilder s=New StringBuilder ("Hello");
56. String s1="World";
58. long Start=system.currenttimemillis ();
60. For (int i=0;i<10000;i++) {
62. S.append (S1);
64. }
66. long End=system.currenttimemillis ();
68. long Runtime= (End-start);
70. System.out.println (RunTime);
72. }
74. public static void Main (string[] args) {
76. TestString ();
78. Teststringbuffer ();
80. Teststringbuilder ();
82. }
84. }

The result of the program operation is:

265
16
0

From the running results, when a string is often modified, using StringBuffer is much better than using string.

StringBuilder can also be decorated with strings, which are similar to StringBuffer, are string buffers, but StringBuilder is not thread-safe, and if only a single thread uses a string buffer, Then the efficiency of the StringBuilder will be higher. StringBuilder can therefore be used when there is only single-threaded access, and it is best to use thread-safe stringbuffer when there are multiple off-the-shelf access. Because StringBuffer can synchronize these methods when necessary, all operations on any particular instance appear to occur in a serial order that is consistent with the order in which the method calls are made by each thread involved.

In terms of execution efficiency, StringBuilder is the highest, stringbuffer second, and string is the lowest.

StringTokenizer is a tool class for splitting strings, as shown in the following example:

1). constructor.

1. StringTokenizer (String str): Constructs a StringTokenizer object to parse str. The default Java delimiter is "space", "tab (' \ t ')", "line feed (' \ n ')", "carriage return (' \ R ')". 2. StringTokenizer (String str, string Delim): Constructs a StringTokenizer object to parse STR and provides a specified delimiter. 3. StringTokenizer (String str, String Delim, Boolean returndelims): Constructs a StringTokenizer object to parse str, and provides a specified delimiter, at the same time, Specifies whether to return delimiters.

2). Introduction to Methods

int Counttokens (): Returns the number of times the Nexttoken method was called. If constructors 1 and 2 are used, the number of separators is returned
Boolean hasmoreelements (): Returns whether there is a delimiter.
Boolean Hasmoretokens (): Ibid.
String NextToken (): Returns the string from the current position to the next delimiter.
Object Nextelement (): Same as the result, unless life returns an object instead of a string
String NextToken (String delim): Same as NextToken (), returns the result with the specified delimiter

Cases:

string s = new String ("This is a test string"); StringTokenizer st = new StringTokenizer (s); System.out.println ("Token total:" + st.counttokens ()), while (St.hasmoreelements ()) {    System.out.println ( St.nexttoken ());}

Example 2:

String str = "100|66,55:200|567,90:102|43,54"; StringTokenizer Strtoke = new StringTokenizer (str, ":, |"); /default does not print delimiter//StringTokenizer strtoke=new StringTokenizer (str, ":, |", true);//print delimiter//StringTokenizer strtoke=new StringTokenizer (str, ":, |", false);//do not print delimiter while (Strtoke.hasmoretokens ()) {    System.out.println ( Strtoke.nexttoken ());}

Note that the StringTokenizer delimiter does not need to use escape characters

3). The difference from split

String.Split () uses regular expressions, while StringTokenizer only uses characters that are split verbatim.
If you do not use a regular expression (StringTokenizer also does not work with regular expressions), StringTokenizer is the most efficient in intercepting strings.

Differences in string, StringBuffer, StringBuilder, StringTokenizer in Java