Java String Class Example--reference

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