String Processing in Java

Submitted by pavel7_7_7 on Sunday, September 7, 2014 - 09:25.

String class is an important and useful class to process text information in Java programs. These class provides a large number of methods that can make processing of string more efficient and understandable. The simplest way to create a string is:

String myString = "This is string tutorial";

Extract character and sub-strings from string. The numeration of the characters in the strings begins from 0 zero.For example, if you want to extract the seventh character from the string, you will do it in the following way:

char charAtPosition7 = myString.charAt(6);

In the case you need to extract a substring, you can use substring method. There are two variants of the substring method: The first one extracts string from the beginIndex to endIndex

String substring(int beginIndex, int endIndex)

Example:

String string = myString.substring(8, 14);

Another way is to extract a sub-string from the beginIndex to the end of the string:

String substring(int beginIndex)

Example:

String endOfString = myString.substring(15);

Now lets test these operations:

System.out.println("Initial string " + myString);
System.out.println("char at position 7 " + charAtPosition7);
System.out.println("Substring from 9th char to  14th char " + string);
System.out.println("End of string " + endOfString);

The output of the program:

Initial string This is string tutorial
char at position 7 s
Substring from 9th char to  14th char string
End of string tutorial

You can split a string using a regular expression. For this task split method exists. There are two variants of split method: The first returns an array of string that matches the regex:
```
String[] split(String regex)
```
The second has a limit for the capacity of the array:
```
String[] split(String regex, int limit)
```
For example we can extract all the words from the string that are divided by space:
```
String[] sp = myString.split(" ");
	for(int i = 0; i != sp.length;++i)
		System.out.println(sp[i]);
	}
```
The output:
```
This
is
string
tutorial
```

Another useful method is trim. This method removes extra space characters from the begin and end of the string:

String testTrim = "    a lot of spaces here            ";
String edited = testTrim.trim();
System.out.println("Initial string " + testTrim);
System.out.println("Trimmed " + edited);

A string can be easily converted to upper or lower case. For this task you can use the following methods:
```
String toLowerCase()
String toUpperCase()
```
Another possibility provided by String class is searching for characters and sub-string in a string. To search for the first index of a character use:
```
int indexOf(int ch)
```
To get the last index of character:
```
int lastIndexOf(int ch)
```
Also, you can specify the starting position of the search by adding a parameter to these methods:
```
int indexOf(int ch, int fromIndex)
int lastIndexOf(int ch, int fromIndex)
```
The same possibility exist for searching a sub-string in a string:
```
int indexOf(String str)
int lastIndexOf(String str)
int indexOf(String str, int fromIndex)
int lastIndexOf(String str, int fromIndex)
```
All of these methods returns the index of the found character or sub-string or -1 if the character or sub-string doesn't occur. Also, you can check, if a string contains a specified char sequence:
```
boolean contains(CharSequence s)
```
You can use any string as the parameter to this function because CharSequence is the interface of the String class.
Once a string is created, it can't be modified. So, if you need to edit a string,you will have to create a new string and use the following methods to modify the original string. Replace old char with new char:
```
String replace(char oldChar, char newChar)
```
Replace target sub-string with new sub-string:
```
String replace(CharSequence target, CharSequence replacement)
```
Replace all sub-string corresponding to the regular expression:
```
String replaceAll(String regex, String replacement)
```
There is the modification of this method that replaces only the first occurrence of the sub-string:
```
String replaceFirst(String regex, String replacement)
```

Here are the basic operation that can be performed on the String objects. In the next tutorial you will find more complex examples to work with strings and use StringBuilder class.

Add new comment

248 views

String Processing in Java

Tags

Add new comment