22.

String Object

Notebook: 1_JAVA_BASICS
Created: 10/17/2018 1:07 PM Updated: 11/8/2018 11:23 PM
Author: suja.sadhusundarsingh@photoninfotech.net
URL: https://www.ntu.edu.sg/home/ehchua/programming/java/J3d_String.html

String Object:

What is String in java?

Generally, String is a sequence of characters. But in Java, string is an object that

represents a sequence of characters. The java.lang.String class is used to create a string
object.

How to create a string object?

There are two ways to create String object:

1. By string literal
2. By new keyword

1) String Literal

Java String literal is created by using double quotes. For Example:

. String s="welcome";

Each time you create a string literal, the JVM checks the "string constant pool" first. If the
string already exists in the pool, a reference to the pooled instance is returned. If the
string doesn't exist in the pool, a new string instance is created and placed in the pool.
For example:
. String s1="Welcome";
. String s2="Welcome";//It doesn't create a new instance
In the above example, only one object will be created. Firstly, JVM will not find any string
object with the value "Welcome" in string constant pool, that is why it will create a new
object. After that it will find the string with the value "Welcome" in the pool, it will not
create a new object but will return the reference to the same instance.
 Note: String objects are stored in a special memory area known as the
"string constant pool

2) By new keyword

String s=new String("Welcome");//creates two objects and one reference vari

able

In such case, JVM will create a new string object in normal (non-pool) heap memory.

Difference between String literal and New String object in Java

String strObject = new String("Java");

and

String strLiteral = "Java";

Both expression gives you String object, but there is subtle difference between them.
When you create String object using new() operator, it always create a new object in heap
memory. On the other hand, if you create object using String literal syntax e.g. "Java", it
may return an existing object from String pool

This will be much more clear when you compare two String objects created using String
literal and new operator, as shown in below example :

String a = "Java";
String b = "Java";
System.out.println(a == b); // True

Here two different objects are created and they have different references:

String c = new String("Java");

String d = new String("Java");
System.out.println(c == d); // False

Similarly when you compare a String literal with an String object created using new()
operator using == operator, it will return false, as shown below :
String e = "JDK";
String f = new String("JDK");
System.out.println(e == f); // False

In general you should use the string literal notation when possible. It is easier to read and
it gives the compiler a chance to optimize your code

Difference between "==" and Equals method:

equals( ) method compares the characters inside a String object. The == operator
compares two object references to see whether they refer to the same instance.

Example:

String s1 = "Hello";
String s2 = new String(s1);
System.out.println(s1 + " equals " + s2 + " -> " +
s1.equals(s2));
System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2));

The variable s1 refers to the String instance created by "Hello". The object referred to
by s2 is created with s1 as an initializer. Thus, the contents of the two String objects
are identical, but they are distinct objects. This means that s1 and s2 do not refer to the
same objects and are, therefore, not ==.

String vs StringBuilder vs StringBuffer in Java

Consider below code with three concatenation functions with three different types of
parameters, String, StringBuffer and StringBuilder.

Example:

public static void concat1(String s1)

{
s1 = s1 + "java";
}

public static void concat2(StringBuilder s2)

{
s2.append("java");
}

public static void concat3(StringBuffer s3)

{
s3.append("java");
}
1. Concat1 : In this method, The string passed from main() is not changed, this is due to
the fact that String is immutable.

2. Concat2 : In this method, it changes the actual value of the string (in main) .

2. Concat3 : StringBuffer is similar to StringBuilder except one difference that

StringBuffer is thread safe, i.e., multiple threads can use it without any issue. The thread
safety brings a penalty of performance.
When to use which one :

If a string is going to remain constant throughout the program, then use String class
object because a String object is immutable.
If a string can change (example: lots of logic and operations in the construction of the
string) and will only be accessed from a single thread, using a StringBuilder is good
enough.
If a string can change, and will be accessed from multiple threads, use a StringBuffer
because StringBuffer is synchronous so you have thread-safety.

Other String Methods:

Java String length(): The Java String length() method tells the length of the
string. It returns count of total number of characters present in the String.
For example:

1 public class StringLength{

2 public static void main(String args[]{
3 String s1="hello";
4 String s2="whatsup";
5 System.out.println("string length is: "+s1.length());
6 System.out.println("string length is: "+s2.length());
7 }}

Here, String length() function will return the length 5 for s1 and 7 for s2
respectively.

Java String compareTo(): The Java String compareTo() method compares the
given string with current string. It is a method of ‘Comparable’ interface which is
implemented by String class. Don’t worry, we will be learning about String
interfaces later. It either returns positive number, negative number or 0. For
example:

1 public class CompareToExample{

2 public static void main(String args[]){
3 String s1="hello";
4 String s2="hello";
5 String s3="hemlo";
6 String s4="flag";
7 System.out.println(s1.compareTo(s2)); // 0 because both are equal
8 System.out.println(s1.compareTo(s3)); //-1 because "l" is only one time lower than "m"
 9 System.out.println(s1.compareTo(s4)); // 2 because "h" is 2 times greater than "f"
10 }}

This program shows the comparison between the various string. It is noticed that
if s1 > s2, it returns a positive number
if s1 < s2, it returns a negative number
if s1 == s2, it returns 0

Java String concat() : The Java String concat() method combines a specific
string at the end of another string and ultimately returns a combined string. It is
like appending another string. For example:

1 public class ConcatExample{

2 public static void main(String args[]){
3 String s1="hello";
4 s1=s1.concat("how are you");
5 System.out.println(s1);
6 }}

The above code returns “hellohow are you”.

Java String IsEmpty() : This method checks whether the String contains
anything or not. If the java String is Empty, it returns true else false. For
example:

1 public class IsEmptyExample{

2 public static void main(String args[]){
3 String s1="";
4 String s2="hello";
5 System.out.println(s1.isEmpty()); // true
6 System.out.println(s2.isEmpty()); // false
7 }}

Java String Trim() : The java string trim() method removes the leading and
trailing spaces. It checks the unicode value of space character (‘\u0020’) before
and after the string. If it exists, then removes the spaces and return the omitted
string. For example:

1 public class StringTrimExample{

2 public static void main(String args[]){
3 String s1=" hello ";
4 System.out.println(s1+"how are you"); // without trim()
5 System.out.println(s1.trim()+"how are you"); // with trim()
6 }}

In the above code, the first print statement will print “hello how are you” while
the second statement will print “hellohow are you” using the trim() function.

Java String toLowerCase() : The java string toLowerCase() method converts

all the characters of the String to lower case. For example:

1 public class StringLowerExample{

2 public static void main(String args[]){
3 String s1="HELLO HOW Are You?”;
4 String s1lower=s1.toLowerCase();
5 System.out.println(s1lower);}
6 }
 The above code will return “hello how are you”.

Java String toUpper() : The Java String toUpperCase() method converts all
the characters of the String to upper case. For example:

1 public class StringUpperExample{

2 public static void main(String args[]){
3 String s1="hello how are you";
4 String s1upper=s1.toUpperCase();
5 System.out.println(s1upper);
6 }}

The above code will return “HELLO HOW ARE YOU”.

Java String ValueOf(): This method converts different types of values into
string.Using this method, you can convert int to string, long to string, Boolean to
string, character to string, float to string, double to string, object to string and
char array to string. The signature or syntax of string valueOf() method is given
below:
public static String valueOf(boolean b)
public static String valueOf(char c)
public static String valueOf(char[] c)
public static String valueOf(int i)
public static String valueOf(long l)
public static String valueOf(float f)
public static String valueOf(double d)
public static String valueOf(Object o)

Let’s understand this with a programmatic example:

1 public class StringValueOfExample{

2 public static void main(String args[]){
3 int value=20;
4 String s1=String.valueOf(value);
5 System.out.println(s1+17); //concatenating string with 10
6 }}

In the above code, it concatenates the Java String and gives the output – 2017.

Java String replace(): The Java String replace() method returns a string,
replacing all the old characters or CharSequence to new characters. There are 2
ways to replace methods in a Java String.

1 public class ReplaceExample1{

2 public static void main(String args[]){
3 String s1="hello how are you";
4 String replaceString=s1.replace('h','t');
5 System.out.println(replaceString); }}

In the above code, it will replace all the occurrences of ‘h’ to ‘t’. Output to the
above code will be “tello tow are you”. Let’s see the another type of using
replace method in java string:
Java String replace(CharSequence target, CharSequence replacement) method :

1 public class ReplaceExample2{

2 public static void main(String args[]){
3 String s1="Hey, welcome to Edureka";
4 String replaceString=s1.replace("Edureka","Brainforce");
5 System.out.println(replaceString);
6 }}

In the above code, it will replace all occurrences of “Edureka” to “Brainforce”.

Therefore, the output would be “ Hey, welcome to Brainforce”.

Java String contains() :The java string contains() method searches the
sequence of characters in the string. If the sequences of characters are found,
then it returns true otherwise returns false. For example:

1 class ContainsExample{
2 public static void main(String args[]){
3 String name=" hello how are you doing?";
4 System.out.println(name.contains("how are you")); // returns true
5 System.out.println(name.contains("hello")); // returns true
6 System.out.println(name.contains("fine")); // returns false
7 }}

In the above code, the first two statements will return true as it matches the
String whereas the second print statement will return false because the
characters are not present in the string.

Java String equals() : The Java String equals() method compares the two
given strings on the basis of content of the string i.e Java String representation.
If all the characters are matched, it returns true else it will return false. For
example:

1 public class EqualsExample{

2 public static void main(String args[]){
3 String s1="hello";
4 String s2="hello";
5 String s3="hi";
6 System.out.println(s1.equalsIgnoreCase(s2)); // returns true
7 System.out.println(s1.equalsIgnoreCase(s3)); // returns false
8 }
9 }

Java String equalsIgnoreCase(): This method compares two string on the

basis of content but it does not check the case like equals() method. In this
method, if the characters match, it returns true else false. For example:

1 public class EqualsIgnoreCaseExample{

2 public static void main(String args[]){
3 String s1="hello";
4 String s2="HELLO";
5 String s3="hi";
6 System.out.println(s1.equalsIgnoreCase(s2)); // returns true
7 System.out.println(s1.equalsIgnoreCase(s3)); // returns false
8 }}
 In the above code, the first statement will return true because the content is
same irrespective of the case. Then, in the second print statement will return
false as the content doesn’t match in the respective strings.

Java String toCharArray(): This method converts the string into a character
array i.e first it will calculate the length of the given Java String including spaces
and then create an array of char type with the same content. For example:

1 StringToCharArrayExample{
2 public static void main(String args[]){
3 String s1="Welcome to Edureka";
4 char[] ch=s1.toCharArray();
5 for(int i=0;i&<ch.length;i++){
6 System.out.print(ch[i]);
7 }}}

The above code will return “Welcome to Edureka”.

Java StringGetBytes() : The Java string getBytes() method returns the

sequence of bytes or you can say the byte array of the string. For example:

1 public class StringGetBytesExample {

2 public static void main(String args[]){
3 String s1="ABC";
4 byte[] b=s1.getBytes();
5 for(int i=0;i&<b.length;i++){
6 System.out.println(b[i]);
7 }
8 }}

In the above code, it will return the value 65,66,67.

Java String IsEmpty() : This method checks whether the String is empty or
not. If the length of the String is 0, it returns true else false. For example:
1 public class IsEmptyExample{
2 public static void main(String args[]) {
3 String s1="";
4 String s2="hello";
5 System.out.prinltn(s1.isEmpty()); // returns true
6 System.out.prinltn(s2.isEmpty()); // returns false
7 }}

}}
.out.prinltn(s1.isEmpty()); // returns true
System.out.prinltn(s2.isEmpty()); // returns false
}}

In the above code, the first print statement will return true as it does not contain anything while the second print statement
will return false.
 Java String endsWith() : The Java String endsWith() method checks if this string ends with the given suffix. If it

returns with the given suffix, it will return true else returns false. For example:

1 public class EndsWithExample{

2 public static void main(String args[]) {
3 String s1="hello how are you”;
4 System.out.println(s1.endsWith("u")); // returns true
5 System.out.println(s1.endsWith("you")); // returns true
6 System.out.println(s1.endsWith("how")); // returns false
7 }}

This is not t