reference:http://examples.javacodegeeks.com/core-java/lang/string/java-string-class-example/
1. Introduction
In this example we are going to discuss about the basic characteristics of Java String Class. String is probably one of the most used types in Java programs. That’s why Java provides a number of API methods that make String manipulation easy and efficient, straight out of the box. Strings are so important that even in the latest Java releases (including 7 and 8), several changes have been made to its class methods and its internal representation, improving it even further in terms of performance and security.
2. String Class basic methods
A String is simply a sequence of characters. As a matter of fact, a String Object is backed by a char array. Consequently, it is not null terminated, like in C/C++.
Here is how you can create a String
1
String str="Hello World";
"Hello World" is called a String literal. In a Java program, everything between two double quotes is a String literal. Literals are implemented as instances of String class. As you can see, you can conveniently initialize a String Object like a primitive type, e.g int i = 0;.
There is no need to do:
1
String str =new String("Hello World");
There is a difference between these two initialization methods, although the result is the same : A String with value “Hello World”. But more on that in just a bit.
For now, here is a simple main with the most important String API methods:
StringClassExample.java
001
package com.javacodegeeks.core.lang.string;
002
003
public class StringClassExample {
004
005
public static void main(String[]args){
006
//Initialization with literal
007
String str1 ="Hello World";
008
System.out.println("str1:"+str1);
009
010
//Initialization with char array
011
char arr[] = {'H','e','l','l','o'};
012
String str2 =new String(arr);
013
System.out.println("str2:"+str2);
014
015
//Concatenation using + operator
016
String str3 ="World";
017
str3 = str2 +" " + str3;
018
System.out.println("str3:"+str3);
019
020
//find out the length of a string
021
System.out.println(str3.length());
022
023
//You can even apply that to literals, as with all String API methods
024
//As we said. literals are implemented as String instances
025
System.out.println("Length: "+"abcdefg".length());
026
027
//Substring from position 2 to position 10
028
String c = str1.substring(2,10);
029
System.out.println("Substring :"+c);
030
031
//Substring from position 1 to position 4
032
System.out.println("Literal Substring :"+"abcdefghigklm".substring(1,4));
033
034
// Get the charcter array of the string.
035
char[] chars = c.toCharArray();
036
System.out.println("Char array : ["+chars[0]+","+chars[1]+","+chars[2]+"]");
037
038
//find the first index of a char inside a string
039
int i = str1.indexOf('W');
040
System.out.println("Index of 'W':"+i);
041
042
//find the first index of a string inside another string after a certain position
043
i = str1.indexOf("orld",5);
044
System.out.println("Index of 'orld':"+i);
045
046
//find the last index of a string inside another string
047
i = str1.lastIndexOf("l");
048
System.out.println("LAST Index of 'l':"+i);
049
050
//find the last index of a string inside another string after a certain position
051
// - like scanning the string backwards
052
i = str1.lastIndexOf("l",7);
053
System.out.println("LAST Index of 'l':"+i);
054
055
//find a character in a certain position
056
char cr = str1.charAt(5);
057
System.out.println("Character at position 5:"+cr);
058
059
//Lower case
060
System.out.println("ABCEFAFA".toLowerCase());
061
062
//Upper case
063
System.out.println("abcasipasc".toUpperCase());
064
065
//replace occurrences of a character
066
str1 = str1.replace('o','0');
067
System.out.println(str1);
068
069
//Trim white spaces from the end and the beginning
070
String str4 =" Java";
071
System.out.println(str4);
072
System.out.println(str4.trim());
073
074
//Split !!!
075
String str5="Java is great";
076
String[] strArray = str5.split(" ");
077
078
System.out.println(strArray[0]+","+strArray[1]+","+strArray[2]);
079
080
str5="Java-is-great";
081
strArray = str5.split("-");
082
System.out.println(strArray[0]+","+strArray[1]+","+strArray[2]);
083
084
str5="Java is great";
085
strArray = str5.split("/*");
086
System.out.println(strArray[0]+","+strArray[1]+","+strArray[2]+","+strArray[3]+","+strArray[4]+
087
","+strArray[5]+","+strArray[6]+","+strArray[7]+","+strArray[8]);
088
089
//contains and equals
090
System.out.println("Contains :" +"qwerty".contains("ert"));
091
System.out.println ("Equals :"+str5.equals("java is great"));
092
System.out.println ("Equals ignore case:"+str5.equalsIgnoreCase("java is great"));
093
094
// Compare lexicographically two strings
095
System.out.println ("Compare:"+str5.compareTo("abc"));
096
097
//comparison attempts
098
String s1 ="abc";
099
String s3 =new String("abc");
100
101
System.out.println(s1==s3);
102
System.out.println(s1.equalsIgnoreCase(s3));
103
104
}
105
106
}
This is the output of the above program:
str1:Hello World
str2:Hello
str3:Hello World
11
Length: 7
Substring :llo Worl
Literal Substring :bcd
Char array : [l,l,o]
Index of 'W':6
Index of 'orld':7
LAST Index of 'l':9
LAST Index of 'l':3
Character at position 5:
abcefafa
ABCASIPASC
Hell0 W0rld
Java
Java
Java,is,great
Java,is,great
,J,a,v,a, ,i,s,
Contains :true
Equals :false
Equals ignore case:true
Compare:-23
false
true
From the above program is clear that Java designers decided to treat Strings somewhat differently from other Objects. For example you can initialize them like a primitive, e.g String a="abc" and you can concatenate two strings using + operator, like you would add twoints (looks like overloading + operator in C++).
The comparison attempts section of the code might seem a little fuzzy, but it will get clear in the next section. What you should take away from it now, is that you SHOULD NEVER try to compare the contents of Strings using == operator. You are only comparing reference equality, not content equality. You MUST use equals or equalsIgnoreCase.
3. Other characteristics of String objects
String objects are immutable. This means that once a String is created, its contents cannot be changed. In the above example, every time we attempt to change its contents, e.g when concatenating, a new String object is created representing the result. Additionally, String class is final, so you cannot override its behavior.
Immutability was mostly chosen for security reasons and for performance. It also means that two different thread can share the same String and manipulate it as they want, not having to synchronize anything, because every time they make a change in the original string, a new one is created, while the old one remains untouched.
Now let’s see this :
1
String s1 ="abc";
2
String s2="abc";
3
4
String s3 =new String("abc");
5
6
System.out.println(s1==s2);
7
System.out.println(s1==s3);
This outputs:
true
false
Literals are stored in a special place in memory, called a String pool, of course in the form of String Objects. In that pool, a Stringobject with value “abc” is only created and stored once. Any other String that gets the value “abc” (statically – hard coded) will reference the same String object. So, every time you create a String using a literal, the system will search that pool and checks if the value of the literal exists in an object of the pool. If it does, it sends back the reference to that matching object, if not it creates a new Object and stores it in the pool. So, String references, initialized with the same literals, will point to the same String object. This technique was used to save precious memory, as it shares as much common data as possible.
Now, you can also see another reason why Strings are immutable. Imagine thread A creating a local string “abc” and then a second thread B creating his own local string “abc”. These two threads will share the same String object… If String was mutable, then if A changed the string, the change would affect thread B, but in a meaningless (put catastrophic) way.
When creating a String using new, you explicitly create a brand new object in the heap. This is also the case for non hard codedString initialization, for example, if you are reading input Strings from a source. These String Objects will not be stored in the pool. Imagine that you create an application that has to hold addresses for users living in Greece. There are four million people living in Athens, so consider the massive waste of space should you store four million String objects with value “Athens”. In order to pool those non hard coded Strings, there is an API method called intern, and can be used like so:
01
String s1 ="abc";
02
String s2="abc";
03
04
String s3 =new String("abc");
05
06
System.out.println(s1==s2);
07
System.out.println(s1==s3);
08
09
s3 = s3.intern();
10
System.out.println(s1==s3);
This will now output:
true
false
true
When calling intern, the system follows the same procedure as if we did s3 = "abc", but without using literals.
But be careful. Before Java 7, this pool was located in a special place in the Java Heap, called PermGen. PermGen is of fixed size, and can only hold a limited amount of string literals. So, interning should be used with ease. From Java 7 onward, the pool will be stored in the normal heap, like any other object (making them eligible for garbage collection), in a form of a hashmap and you can adjust its size using -XX:StringTableSize option. You could create your own String pool for that matter, but don’t bother.
This is only one of the aspects that Java creators changed in the String class. Even more radical changes ware made, including the internal String representation (it now has two less static fields).
Download the Eclipse Project
This was an example of Java String Class. You can download the Eclipse Project of this example here : StringClassExample.zip