Java String Class Methods with Examples
As an integral component of the Java Standard Library, the String class plays an important role in handling textual data and facilitating string manipulations within Java applications.
This article will delve into the characteristics of the String class, its immutability, and its representation of character sequences. We’ll also explore the String pool, a unique feature of Java’s memory management, and the wide array of methods provided by the String class for efficient string manipulation.
What is the String class in Java?
In Java, the String class is a fundamental and widely used part of the Java Standard Library. It is a crucial component for handling textual data and manipulating strings in Java applications. The String class is part of the java.lang package, which means it is automatically imported into every Java program, making it readily accessible without any additional import statements.
Characteristics of the Java String Class
The String class in Java has many features to offer, here are some of them:
1. Immutable Nature:
One of the key characteristics of the String class in Java is its immutability. Once a String object is created, its content cannot be changed. Any operation that appears to modify a String creates a new String object with the modified content. This design choice has implications for memory management and thread safety.
2. Sequence of Characters:
The primary purpose of the String class is to represent a sequence of characters. Each character in a String is indexed, starting from 0 for the first character. This allows for easy access and manipulation of individual characters within a string.
3. String Pool:
Java maintains a special memory area called the “String pool” for storing string literals. When you create a string using double quotes, such as String str = “Hello”;, Java checks the string pool first. If the string already exists in the pool, the existing reference is returned. This helps conserve memory by preventing the creation of duplicate string objects.
4. Wide Range of Methods:
The String class provides a rich set of methods for performing various operations on strings. These methods include substring extraction, concatenation, comparison, searching, and modification. Understanding these methods is essential for effective string manipulation in Java.
Creating a String in Java
In Java, the creation of strings can be accomplished through two different methods:
1. String Literal:
The most common and concise way to create a string in Java is by using string literals. A string literal is a sequence of characters enclosed within double quotation marks. When a string literal is assigned to a variable, Java automatically checks the string pool to see if an identical string already exists. If found, the variable is assigned a reference to the existing string; otherwise, a new string is created in the pool.
Example:
String s = "FirstCode";
In this example, the string “FirstCode” is a literal, and the variable s holds a reference to it.
2. Using the new Keyword:
Another way to create a string in Java is by explicitly using the new keyword along with the String class constructor. This method creates a new instance of the String class, regardless of whether an identical string already exists in the string pool. This approach is less common than using string literals but can be useful in scenarios where dynamic string creation or manipulation is required.
Example:
String s = new String("FirstCode");
Here, the new keyword is used to create a new String object with the content “FirstCode”.
String Constructors in Java: A Comprehensive Overview
In Java, the String class provides a variety of constructors to create strings from different data types, facilitating flexibility in handling diverse scenarios. Each constructor serves a specific purpose, allowing developers to choose the most appropriate method for their needs.
Here is an in-depth look at some key String constructors:
1. String(byte[] byte_arr)
This constructor constructs a new String by decoding the byte array. It uses the platform’s default character set for decoding. This constructor is convenient when working with byte data, such as reading from files or network streams. It uses the default character set of the platform for decoding, which may lead to variations in behavior across different platforms. The below code snippet will store “FirstCode” in the variable str.
byte[] arr = {70, 105, 114, 115, 116, 67, 111, 100, 101};
String str = new String(arr); //result = FirstCode
2. String(byte[] byte_arr, Charset char_set)
This constructor constructs a new String by decoding the byte array. It uses the specified character set (Charset) for decoding. This constructor allows explicit specification of the character set, providing more control over the decoding process. It’s especially useful when dealing with data that might have been encoded using a specific character set.
Below is an example of the same:
byte[] arr = {70, 105, 114, 115, 116, 67, 111, 100, 101};
Charset c = Charset.defaultCharset();
String s_byte_char = new String(arr, c); //result = FirstCode
3. String(byte[] byte_arr, String char_set_name)
This constructor constructs a new String by decoding the byte array. It uses the specified character set name for decoding. Similar to the previous constructor, this one takes a character set name as a string parameter. It provides an alternative way to specify the character set for decoding byte data.
Below is a code snippet that makes use of this constructor:
byte[] arr = {70, 105, 114, 115, 116, 67, 111, 100, 101};
String str = new String(arr, "US-ASCII"); //result = FirstCode
4. String(byte[] byte_arr, int start_index, int length)
This constructor constructs a new string from the byte array based on the start index and length parameters. This constructor enables the creation of a string from a subset of a byte array, starting at a specific index and including a specified number of characters.
Below is a code snippet illustrating the same:
byte[] arr = {70, 105, 114, 115, 116, 67, 111, 100, 101};
String s = new String(arr, 5, 8); // Result: Code
5. String(byte[] byte_arr, int start_index, int length, Charset char_set)
This constructor constructs a new string from the byte array based on the start index and length parameters. Uses the specified character set for decoding. This variant allows for the explicit specification of the character set when creating a string from a subset of a byte array.
byte[] arr = {70, 105, 114, 115, 116, 67, 111, 100, 101};
Charset c = Charset.defaultCharset();
String s = new String(arr, 5, 8, c); // Result: Code
6. String(byte[] byte_arr, int start_index, int length, String char_set_name)
This constructor constructs a new string from the byte array based on the start index and length parameters. Uses the specified character set name for decoding. Similar to the previous constructor, this one uses a character set name for decoding when creating a string from a subset of a byte array.
byte[] arr = {70, 105, 114, 115, 116, 67, 111, 100, 101};
String s = new String(arr, 0, 4, "US-ASCII"); // Result: First
7. String(char[] char_arr)
This constructor allocates a new String from the given character array. This constructor is a straightforward way to create a string from an array of characters, useful when dealing with character data. Below is an example showing the use of this constructor:
char arr[] = {'F', 'i', 'r', ‘s’, 't', 'C', ‘o’, ‘d’, ‘e’};
String str = new String(arr); // Result: FirstCode
8. String(char[] char_array, int start_index, int count)
This constructor allocates a String from a given character array, selecting count characters from the start index. This variant is useful when you want to create a string from a specific subset of a character array, defined by the start index and the number of characters.
char arr[] = {'F', 'i', 'r', ‘s’, 't', 'C', ‘o’, ‘d’, ‘e’};
String str = new String(arr , 0, 4); // Result: First
9. String(int[] uni_code_points, int offset, int count)
This constructor allocates a String from a Unicode code point array, choosing count characters from the start index. This constructor allows the creation of a string from an array of Unicode code points, specifying the start index and the number of characters.
int[] uni_code = {70, 105, 114, 115, 116, 67, 111, 100, 101};
String str = new String(uni_code, 0, 4); // Result: First
10. String(StringBuffer s_buffer)
This constructor allocates a new String from the string in a StringBuffer. This is useful when converting the content of a StringBuffer into a regular string.
StringBuffer str1= new StringBuffer("FirstCode");
String str2 = new String(str1); // Result: FirstCode
11. String(StringBuilder s_builder)
This constructor allocates a new String from the string in a StringBuilder. Similar to the previous constructor, this one is used when converting the content of a StringBuilder into a regular string.
StringBuilder str1 = new StringBuilder("FirstCode");
String str2 = new String(str1 ); // Result: FirstCode
Java String class methods
The Java String class is an important tool in handling textual data, offering a truckload of methods for string manipulation. From basic operations like concatenation and substring extraction to advanced tasks like pattern matching, the String class provides a robust toolkit.
These methods, designed to work with immutable strings, ensure data integrity and reliability in Java applications. For a quick reference, the table below outlines each Java String class method, serving as a handy guide for developers.
| No. | Method | Description |
| 1 | charAt() | Retrieve character at specified index |
| 2 | codePointAt() | Get Unicode of character at given index |
| 3 | codePointBefore() | Obtain Unicode of character before given index |
| 4 | codePointCount() | Count Unicode values in a string |
| 5 | compareTo() | Compare strings lexicographically |
| 6 | compareToIgnoreCase() | Compare strings, ignore case |
| 7 | concat() | Append one string to another |
| 8 | contains() | Check if string contains characters |
| 9 | contentEquals() | Check if string matches given CharSequence |
| 10 | copyValueOf() | Create string from character array |
| 11 | endsWith() | Check if string ends with specified characters |
| 12 | equals() | Compare strings for equality |
| 13 | equalsIgnoreCase() | Compare strings, ignore case |
| 14 | format() | Get formatted string with locale |
| 15 | getBytes() | Encode string into byte array |
| 16 | getChars() | Copy characters to char array |
| 17 | hashCode() | Get hash code of string |
| 18 | indexOf() | Find position of characters in string |
| 19 | intern() | Get canonical representation of string |
| 20 | isEmpty() | Check if string is empty |
| 21 | lastIndexOf() | Find position of last occurrence of characters |
| 22 | length() | Get length of string |
| 23 | matches() | Check if string matches regex |
| 24 | offsetByCodePoints() | Offset index by code points |
| 25 | regionMatches() | Test equality of string regions |
| 26 | replace() | Replace specified values in string |
| 27 | replaceFirst() | Replace first occurrence of regex |
| 28 | replaceAll() | Replace substrings with regex |
| 29 | split() | Split string into array of substrings |
| 30 | startsWith() | Check if string starts with characters |
| 31 | subSequence() | Get subsequence of characters |
| 32 | substring() | Get substring of string |
| 33 | toCharArray() | Convert string to char array |
| 34 | toLowerCase() | Convert string to lowercase |
| 35 | toString() | Get value of String object |
| 36 | toUpperCase() | Convert string to uppercase |
| 37 | trim() | Remove whitespace from both ends |
| 38 | valueOf() | Get string representation of value |
Conclusion
the String class in Java serves as a fundamental building block for developers working with textual data. Its immutability ensures data integrity, while the String pool optimizes memory usage by preventing the creation of duplicate string objects. The extensive set of methods offered by the String class empowers developers to perform diverse string operations efficiently.
Whether it’s comparing strings, extracting substrings, or transforming cases, the String class provides a robust toolkit for seamless string manipulation in Java. As you continue your journey in Java programming, a solid understanding of the String class will undoubtedly enhance your ability to work with strings effectively.