Advanced Tutorial on Java Strings

The following editor will bring you an article about advanced Java strings (a must-read article). The editor thinks it’s pretty good, so I’ll share it with you now and give it as a reference. Let’s follow the editor and take a look.

Preface

There are three most commonly used classes for string operations, namely String and StringBuilder. , StringBuffer, these three classes will be discussed in detail below...

String

The String class represents a string , this is the most basic class for strings, and this is also the most commonly used class. I will not introduce it in detail here

Construction

new String(String str)

new String(StringBuilder str)

new String(StringBuffer str)

new String(byte[] bys,String charsetName) Constructs a new String by decoding the specified byte subarray using the specified character set.

Common methods

str charAt(int index) Returns the character at the specified index

String concat(String str) Connect the specified string str to the end of this string and return the characters after the connection is successful, so it needs to be accepted to be effective.

boolean contains(CharSequence s) determines whether this string contains the specified char value sequence. CharSequence here is an interface, you can directly use its subclasses as parameters (String, StringBuffer, StringBuild)

static String copyValueOf(char[] c) turns the character array into a string and returns

static String copyValueOf(char[] c,int off,int count) Convert the intercepted character array into a string and return it. Off is the subscript to start interception, and count is the number of interceptions

boolean endWith(String s) determines whether the string ends with s

boolean equals(Object o) is used for comparison

int indexOf(char c) returns the first character c in the string Index of the first occurrence

int indexOf(char c,int fromIndex) Start searching from the specified index and find the index of the first occurrence

int indexOf(String str) Return the specified substring The index of the first occurrence in this string.

int indexOf(String str,int fromIndex) Returns the index of the first occurrence of the specified substring in this string, starting from the specified index.

boolean isEmpty()

int length()

boolean matches(String regex) Whether to match the regular expression

trim() returns the string Copy, ignoring leading and trailing whitespace.

String substring(int beginIndex) returns a new string, which is a substring of this string.

String substring(int beginIndex, int endIndex) Returns a new string that is a substring of this string.

String toUpperCase() Converts all characters in this String to uppercase using the rules of the default locale.

String[] split(String regex) Splits this string based on matches of the given regular expression.

String[] split(String regex, int limit) Splits this string based on matching the given regular expression.

char[] toCharArray() Converts this string to a new character array.

byte[] getBytes(Charset charset) Use the given charset to encode this String into a byte sequence and store the result into a new byte array

Note

The above new String(byte[] bys,String charsetName) construction method is very important, it can change the encoding set of the string (cooperates with byte[] getBytes(Charset charset)) Let’s take a look at an example. The code is as follows:

/*
 * InputStreamReader实现了将字节流FileInputStream转换为字符流，然后使用转换来的字节流创建高效流，从而实现高效的读写
 */

/*
 * 编码集(我的eclipse编辑器默认的是utf-8
 * 下面将中文字符串的编码集变为GBK写入a.txt文件,因为a.txt默认的是utf-8的因此这里在文件中显示的是乱码
 * 然后我们读出来的还是GBK的，因为我们写入的是GBK编码集的，但是我的eclipse是utf-8的编码集，因此在控制台上输出的还是乱码
 * new String(byte[] bys,String
 * charsetName)使用这个构造方法将byte数组改变编码集并且转换为utf-8格式的，那么这次在控制台上输出的就不乱码了
 */

// 将GBK格式的中文写入a.txt文件
File file = new File("src/a.txt");
FileOutputStream fileOutputStream = new FileOutputStream(file);
String str = "中";
byte[] by = str.getBytes("GBK"); // 将字符串改为GBK编码集
fileOutputStream.write(by);
fileOutputStream.close();

//从a.txt文件中读取中文
FileInputStream fileInputStream = new FileInputStream(file);
int len;
byte[] bys = new byte[4];
while ((len = fileInputStream.read(bys)) != -1) {
 System.out.println(new String(bys, "GBK"));
}
fileInputStream.close();

StringBuffer

Thread-safe mutable character sequence. A string buffer similar to String, but cannot be modified. Of course, the most important point is thread safety. We can see from its source code that thread control blocks are used for some operations (append, insert..) to achieve synchronization, which is suitable for use in multi-threads. Source The code is as follows:

 public synchronized StringBuffer append(Object obj) {
super.append(String.valueOf(obj));
return this;
}

public synchronized StringBuffer append(String str) {
super.append(str);
return this;
}

public synchronized StringBuffer delete(int start, int end) {
super.delete(start, end);
return this;
}

/**
 * @throws StringIndexOutOfBoundsException {@inheritDoc}
 * @since 1.2
 */
public synchronized StringBuffer deleteCharAt(int index) {
super.deleteCharAt(index);
return this;
}

Construction

new StringBuffer(StringBuilder str)
new StringBuffer( String str)

Commonly used methods

StringBuffer append(str) appends the str of the specified type to the end of this string (String, char,char[],int,double,float,long,StringBuffer,StringBuilder)

StringBuffer insert(int offest, str) Inserts the str of the specified type into this sequence, offset represents the starting position of insertion Index, types are String, char, char[], int, double, float, long, StringBuffer, StringBuilder

String delete(int fromIndex,int endIndex) removes the string in this sequence and returns a new one Buffer string

StringBuffer reverse() Reverse string

String substring(int start) Returns a new String that contains the character subsequence currently contained by this character sequence.

String substring(int start, int end) Returns a new String containing the character subsequence currently contained by this sequence.

StringBuffer deleteCharAt(int index) Removes the char at the specified position in this sequence.

int length() length

String toString() Returns the string representation of the data in this sequence.

StringBuilder

It is recommended to use this class in preference because it is faster than StringBuffer in most implementations. However, this class is not thread-safe and is only suitable for single threads. If you use multi-threading, it is recommended to use StringBuffer. Of course, you can also use this, but you need to implement synchronization yourself

Construction method

new StringBuilder(String str)

Common methods

The common methods of this class are the same as those of StringBuffer. I won’t list them one by one here. You can use them by referring to the above

The above is the detailed content of Advanced Tutorial on Java Strings. For more information, please follow other related articles on the PHP Chinese website!