stringexample.java_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