Java Journal: December 2010

Difference between concat() and + (String concatenation operator)

Both concat() and + are used to concatenate the strings but they have some differences which are described below:

1. Java.lang.NullPointerException :

concat() method if called on null String reference variable, will throw NullPointerException while this is not the case with + operator.

For example,

String s=null;
s.concat(“abc”);

will throw NullPointerException.

While

String s=null;

System.out.println(s+”abc”);

Will print nullabc. While concatenating strings with + operator, a null reference variable changes to “null” (i..e a String containing null as its contents.). That’s why s becomes “null” and output is nullabc.

2. Number of arguments:

concat() takes only one argument while + can take any number of arguments.

Example,

“I”+“ am”+” a”+” good”+” boy”

3. Type of Argument:

Signature of concat() method is: public String concat(String str)

concat() only takes String type as argument. If any other type argument is passed to concat() it will give compile time error. Example,

s.concat(5); // error as 5 is a non string value

s.concat(“5”); // no error as here 5 is string (enclosed in “”)

While + can take any type of arguments. While doing concatenation non-string type argument is converted to String by using its toString() method

For example,

String s=”abc”;
int i=5;

System.out.println(s+i); // no error, will print abc5.

Here int value 5 is a primitive value. It will be first converted to a string value as:

int------>Integer.toString(5)-------> a String representation of int value 5.

Note that as explained in article String concatenation operator +, at least one argument of + must be of string type otherwise + will behave like mathematical addition operator instead of string concatenation operator.

4. Creation of new String Object:

You may have read that in Java Strings are immutable. Whenever you try to change its contents, a new String object with changed contents is created instead of modifying the original String object.

But concat() returns new String object only when the length of argument string is > 0.

String s=”Blue”;
String s1=”Sky!”
String s2=s.concat(s1);

Here concat() returns a new String object whose reference is stored in s2.

But if the length of argument string is 0, then concat() returns same original string instead of returning a new String object. Example,

String s=”abc”;
String s1=s.concat(“”);

Here “” (an empty String with length 0) is a passed as an argument to concat(). So no new String object created but reference to original string s is returned and strored in s1.

Therefore, s==s1 will give true here i.e both s and s1 are pointing to same objects.

While,

+ creates a new String object every time it concatenates something, except when the concatenation is done at compile time.

For example,

String s=”Hello”;

String s1=s+”World!”;

Here a new String object s1 is created with concatenated result (Hello World!).

Similarly,

String s=”Hello”;

String s1=”World!”;

String s2=s+s1;

Will create a new String object s2.

In both above example concatenation happen at run time.

But,

String s=”Hello”+”World!”;

Will not create a not create a new String object because here concatenation will happen at compile time.

There will be only one String object with contents “Hello World!”. Both String literals “Hello” and “World!” will be discarded.

5. Performance

Performance wise concat() is consider better than + operator. One of the reasons for this is that concat() returns a new String object only when length of its arguments is > 0 as stated in point 4.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

3. Using append() method of StringBuilder or StringBuffer class

« Using concat() method

The append()method of StringBuilder and StringBuffer classes can also be used to concatenate strings.

Example:

StringBuilder sb= new StringBuilder(“Hello”);
sb.append(“World!”);
System.out.println(sb);

Output: HelloWorld!

You can also chain append() together like this:

StringBuilder sb= new StringBuilder("The police ");
sb.append(" called off ").append(“ the search”).append(" for the missing boy.");
System.out.println(sb);

Output: The police called off the search for the missing boy.

The StringBuffer and StringBuilder classes have many overloaded append() methods - for all the built-in types, for objects etc. You can refer JavaDocs for their details.

Note: StringBuilder class was introduced in java 5.

If the argument of append() is non string then it is converted to String first by String.valueOf() method.

For Example,

StringBuilder sb= new StringBuilder("There were ");
int i=5;
sb.append(i).append(" thieves.");
System.out.println(sb);

Output: There were 5 thieves.

In above example you have appended an int value 5. Before appending, 5 will be converted to its string representation by String.valueOf(5).

« Using concat() method

I would like to know your comments and if you liked the article then please share it on social networking buttons.

2. Using concat() method of String class

« 1. String Concatenation operator +                                       3. Using append() method »

concat() method of String class appends the argument string to the string object on which it is called. For example,

System.out.println(”Tom”.concat(“Cat”)); Will print TomCat.

"Go".concat(" to").concat(" hell !")          will print "Go to hell !"

Now consider,

   String str= "strike";
str.concat("out");
System.out.println(str);   // the output will be strike, NOT strike out. WHY?

This is because in Java strings are immutable. Due to which whenever you change the contents of a String object, a new String object is created instead of modifying the original string.

Therefore when you changed the String object str by appending “out “ using str.concat(), it returned a new String object with changed contents instead of modifying original str contents.

str is still pointing to original string with value strike.

That’s why System.out.println(str); printed strike Not strike out.

The newly created String object with changed contents (strike out) will be garbage collected after some time as you have not stored its reference anywhere.

If your code will be:

String str= "strike";
str=str.concat("out");
System.out.println(str);   // the output will be strike out, NOT strike.

Here you have stored the reference of newly created String object with changed contents in reference variable str, which was earlier pointing to original string.

Therefore System.out.println(str); printed strike out Not strike.

Now the reference to original string got lost and it will be garbage collected after some time.

Similarly,

String first= "strike";
String sec=first.concat("out");
System.out.println(first==sec);   // will be false.

first==sec will print false showing that they are different String objects.

Two cases are there:

1) If the length of argument String is 0 then concat() returns the same string instead of creating a new String object. For example,

String s="James ";
String s1=s.concat("");
System.out.println((s==s1); // will print true.

Here argument of concat() is an empty string (length 0), Therefore instead of creating a new String object it returned reference to same original String object s.This can be confirmed by s==s1 giving true i.e both are pointing to same String object.

2) calling concat() on null reference variable:

Suppose your code is:

String s=null;
String s1=s.concat("Appending on null String variable");

It will give following error:
Exception in thread "main" java.lang.NullPointerException

« 1. String Concatenation operator +                                       3. Using append() method »

I would like to know your comments and if you liked the article then please share it on social networking buttons.

1. String Concatenation operator +

« String Concatenation 2. Using concat() method of String class »

In Java + operator has been overloaded so that it can also concatenate strings in addition to the normal plus operation (on integers etc.). Strings can be concatenated by using + operator as:

Example1:

String s= “Charlie” +”Chaplin”;

System.out.println(s); // will print Charlie Chaplin.

Example 2:

String s=”Ranga”;

String s1=”nathan”;

String s3=s+s1;

System.out.println(s3); // will print Ranganathan.

Example3:

System.out.println(“abc”+”def”); // will print abcdef.

System.out.println(s+s1); // will print Ranganathan.

Example 4:

String s=null;

String s1=”hello”

System.out.println(s+s1); // will print nullhello

Note the above example. Here s is a null reference variable pointing to null. Whenever you print a null reference variable, it converts to “null” (i.e a string having value null).

Therefore above statement prints nullhello.

Example 5:

Concatenating more than two strings at the same time:

String s=”Stop”+ “beating”+”around”+ “the”+ “bush.”;

System.out.println(s); // will print Stop beating around the bush

String s= “Big”

Styring s1=”fish”

String s2=”in”

String s3=”a little sea”;

String s4= s+s1+s2+s3;

System.out.println(s4); // will print Big fish in a little sea

Example 6:

You can also use compound additive operator (+=) to add Strings:

String s=”Old”;

s += ” man”;

System.out.println(s); // will print Old man.

s += ” man” is equivalent to s = s+” man”.

Example 7:

String s=”12”;

String s1=”12”;

String s2=s+s1;

System.out.println(s2); // will print 1212, NOT 24

Note that in above example 12 +12 has not get added to give 24 (normal plus operation) but instead it prints 1212. That’s why + is said to be overloaded for strings.

Similarly,

System.out.println(“24”+”3”); //will print 243 Not 27.

Working of String concatenation operator:

Consider,

String s=”3”;

int i=10;

System.out.println( s+i );

What will be the output 13 or 310? Output is 310.

Why so? This is because if any one of the arguments of + is String then + behaves like string concatenation operator instead of doing mathematical addition. Therefore instead of adding 3 and 10 (i.e 3+10=13) it concatenates them (310).

Similarly,

String s=”3”;

int i=10;

int i=11;

System.out.println(s+i+i1);  

Above statement will NEITHER print 24 (i.e 3+10+11=24), NOR 321 (i.e “3” +10+11=321), it will print 31011.

String concatenation operator works from left to right. Here s+i (i.e “3”+10) is evaluated first giving “310”( a string). Then “310”+11 evaluated to give 31011(also a string.)

Now consider,

String s=”3”;

int i=10;

int i1=11;

System.out.println(s+(i+i1));

Above statement will 321. This is because you have enclosed i+i1 in (). So (i+i1) will be evaluated first. Since both operands are of int type, + will do mathematical addition instead of string concatenation.

After adding i and i1 it will then concatenate 3 (a string) and 21 (an int) as “3”+21. Now since one of the operands is string therefore + will do string concatenation and result will be 321.

Similarly,

String s=”3”;

int i=10;

int i1=11;

System.out.println(i+i1+s);

Will print 213.

In above example i+i1 evaluated first to give 21 because + operates from left to right. Here + has done numerical addition instead of string concatenation. This is because both arguments are of int type, neither of the arguments is of String type.

Therefore,
10+11=21 (integer addition)
21+”3”=213 (String concatenation)

More Examples:

Example 1:

String s=”3”;

int i=10;

int i1=11;

System.out.println(i+s+i1);

Will print 10311

Example 2:

System.out.println(2+someObj.getValue());

Here what will be the output depends on the return type of getValue(). If getValue() returns String, only then above statement will be a String concatenation.

Suppose getValue() returns a String “10”, then output will be 210.

If getValue() returns an int 10, then output will be 12 (i.e 2+10=12).

Example 3:

System.out.print("" +14 + 2 ); 

will print 142 NOT 16 because first argument “” is a string (an empty string). Therefore it will be String concatenation instead of mathematical addition.

Example 4:

System.out.println("The square root of 3 is " + Math.sqrt(3));

Will print : The square root of 3 is 1.7320508075688772.

Here value returned by Math.sqrt(3) is concatenated with The square root of 3 is.

« String Concatenation 2. Using concat() method of String class »

I would like to know your comments and if you liked the article then please share it on social networking buttons.

String Concatenation

In Java strings can be concatenated in three ways:

1)   Overloaded + operator (also known as String Concatenation operator).
2)   Using concat() method of String class.
3)   Using append() method of StringBuilder or StringBuffer class.

1. String concatenation operator + »

I would like to know your comments and if you liked the article then please share it on social networking buttons.

What do you undesrtand by String interning?

String interning is a process in which a String object is moved into String pool.

You may have read that objects in the string pool are shared. Reference to a String object in the pool is shared in place of all those string literals that have same value as this String object has. This prevents the creation of new String objects.

Thus the main purpose of string interning is to save memory and increase performance of application by reducing the creation of new String objects.

Note: As described in this [article] when we say that String Pool contains String objects it actually means that String Pool contains 'references' to those String objects. Actual String objects are stored in permanent generation memory area. For the sake of convenience we use to say that String Pool contains String objects.

As you know that strings in Java can be created in two ways:

1) Using string literals and
2) Using "new" operator.

Strings created using String literals

Strings created using string literals are automatically interned and stored in string pool.

For example,

String s="John";

In above statement we have created a String object s using literal John. This string object would be automatically interned i.e automatically stored in string pool.

If we create two more strings with same value as:

String s1="John";
String s2="John";

All three reference variables - s,s1 and s2 would be pointing to same String object in the string pool.

Example,

public class StringInterning{
   public static void main(String[] args){
      String s="John";
      String s1="John";
      String s2="John";
      System.out.println(s==s1); //will print true
      System.out.println(s1==s2); //will print true
      System.out.println(s==s2); //will print true
}
}

If these strings would not get automatically interned then there s, s1 and s2 would be pointing to three different string objects with same value.

String created using new operator

Note: Creating strings using new operator is not a good practice.

Strings created using new operator need to be interned explicitly.They do not get automatically interned. For example,

String s= new String("John");

Here s will not get interned automatically and would NOT be stored in string pool.

If you create two more strings with same value like:

String s1= new String("John");
String s2= new String("John");

Then s ,s1 and s2 would be pointing to three different string objects instead of single shared string object.

Example,

public class StringInterning{
   public static void main(String[] args){
String s= new String("John");
      String s1= new String("John");
      String s2= new String("John");
      System.out.println(s==s1); //will print false
      System.out.println(s1==s2); //will print false
      System.out.println(s==s2); //will print false
}
}

To make s,s1 and s2 point to same String object they need to be interned explicitly.

How to intern strings created by new? This is shown in following section.

The intern() method- Explicilty interning the Strings

We can intern strings which are created using new operator with intern() method of String class as:

String s=new String("John");
s1=s.intern();

s.intern() will first check whether the string pool already contains any String object having same value as s. If pool already contains a String object with value "John", intern() will return reference of that object from pool into s1. Otherwise it will create a new String object with same contents, add it into the pool and return its reference.

Now s and s1 would be two different String objects. s does not belongs to string pool while s1 belongs to string pool (and would be shared ).

s==s1 will give false.

If your write like this,

String s=new String("John");
s=s.intern();

Here you have stored the returned reference into same variable s. The reference to old original string object created by new is now lost and it will be garbage collected. Variable s is now pointing to interned string.

Example

public class StringInterning{
public static void main(String[] args){
    String s= "John";
    String s1= new String("John");
    String s2= s1.intern();
    System.out.println(s==s1); //will print false
    System.out.println(s1==s2); //will print false
    System.out.println(s==s2); //will print true
}
}

But why do we need interning Strings explicitly?

Suppose you have a database program which is retreiving names of employees from an Employee table who live in New York.

List namesList= new ArrayList();
ResultSet rs = stmt.executeQuery("select names from employee where city='New York'");
while(rs.next()){
namesList.add(rs.getString("name"));
}

Assume it retrieves 500 rows from table in which 150 employees have same name, say Sandy.

Now, rs.getString(); method of java.sql.ResultSet interface returns a new String object for every name it retrieves from table row. Therefore it means there would be now 500 different String objects in memory and out of which 150 String objects have same value Sandy. Is not this a memory wastage?

Now suppose we use intern() as:

List namesList= new ArrayList();
ResultSet rs = stmt.executeQuery("select names from employee where city='New York'");
while(rs.next()){
namesList.add(rs.getString("name").intern());
}

Now for our 150 same names of Sandy, there would be only one string object and that String object will lie in String pool.

This will save memory for 150 objects.

Thus you need explicit String interning :

1)To prevent duplicate strings in our program.
2)To prevent creation of new string objects having same values as of existing ones.
3) To save memory.
4) As creation of new objects is reduced and already present strings are shared, this increase the performance of application. (Though calling intern() many times also affects performance adversely. So you have to do a trade off between saving memory and performance hit caused by calling intern() in your program.)

Some facts about interned strings

1) Interned String can be compared using == .

You may have read in article String equality Check: equals() or == ? that when we check two strings for equality of contents we should always use equals() method of String class. You should not use == for comparing the contents of two strings.

But interned strings can be compared using == for contents also . This is because for interned strings same contents means same string objects.

This is described in detail in article Interned String and use of ==.

2) == is faster than equals().

When you compare strings using ==, it only compares the reference variables and when you use equals() method it performs character by character comparision.Therefore using == is faster than using equals().

Now since you can use == for comparing the contents of interned strings, interning the strings makes your application faster if you use == in place of equals().

But you should always avoid it because using == for string's data comparision is a bad practice. If you forget to use intern() on any string and become habitual of using == for comparing string data, this can lead to unexpected results.

Moreover, if you look at the code of equals() method of String class, you will see that equals() first use == to check whether the reference variables of two strings under comparision are equal or not. If they are not equal then only it do character by character comparision otherwise returns false.

So equals() called on interned strings is faster than the equals() called on non interned strings.

3) Interned strings are stored on Permanent Generation Memoey Area.

Interned Strings are stored in Permanent Generation memory instead of heap memory( assuming permanent generation is separate from heap). Permanent generation memory has limited size. So when you call intern() on two many strings with different values, all those interned strings would be added to Permanent Generation area. This may end up in java.lang.OutOfMemoryError: PermGen space.

Note that above figures corresponds to pre -Java 7 versions. But in Java7 interned strings are no longer stored in Permanent Generation area but stored in heap memory. Thus it removes the memory restriction on interned strings.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Interned Strings and use of ==

Interned strings are those strings whose references are stored in the string pool. We make string interned so that strings with similar values share same string object instead of having different string objects.This saves memory and also increase performance. Interning of strings is described in article What do you undesrtand by String interning?

You may have read in article String equality Check: equals() or == ? that for comparing string contents one should always use equals() instead of ==. This is because == do not compare contents, it compares only references.

But for interned strings you can also use == to compare the contents of strings. This is because, for interned strings, same contents means same String object.

For non interned strings,

Same contents ==> same String objects OR different string objects

Here equals() will give true while == may give true OR false. So you cannot depend on == for equality of contents.

For Example,

String s="Eclipse";
String s1="Eclipse";
String s2= new String("Eclipse");

Here s and s1 are both pointing to same string objects while s2 is a different object.

So,

System.out.println(s.equals(s1)); // will print true i.e same contents

System.out.println(s==s1);     // will print TRUE i.e SAME objects

But,

System.out.println(s.equals(s2)); // will print true i.e same contents

System.out.println(s==s2);     // will print FALSE i.e DIFFERENT
                               // objects despite same contents

BUT for Interned Strings,

same contents always ==> same string objects.

Here if equals() gives true means == will also give true.So you depend on == for equality of contents also.

For example,

String s="Eclipse";
String s1= new String("Eclipse");
String s2= s1.intern();

Here s and s1 are two different objects. But due to interning s and s2 are pointing to same String object.

Therefore,

System.out.println(s.equals(s1));   // will print true i.e same
   // contents

System.out.println(s==s1);         // will print FALSE i.e DIFFERENT
                                  // objects

But,

System.out.println(s.equals(s2));    // will print true i.e same
                                      //contents

System.out.println(s==s2);     // will print TRUE i.e always SAME
                               //    objects for same content

Thus after making strings interned one can use == to compare strings for data because then strings with same values always refer to same String objects.

But you should always avoid it because using == for string's data comparision is a bad practice. If you forget to make any string interned and become habitual of using == for comparing string data, this can lead to unexpected results and you will waste your coding time in finding bugs caused by this.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Why Strings in Java are immutable?

String is immutable because several benefits that were designed around the String class depends on the immutability property of string in java. For example,

1) String Pool

In Java String class is implemented along with the concept of String Pool. String Pool contains the references of various String objects which corresponds to the String literals you are using in your code.

The main purpose of String Pool is to provide a way to share the String objects with the same value and thus preventing the creation of new String objects for those String lierals that have same values.

Each String object in string pool is shared at several places in code. If Strings in Java were to be mutable then a change made to a string object in the pool at one place would affect all other places where that string object is being shared.

For example, suppose you have a code:

String inputFile="orders.dat";
String outputFile="orders.dat";
...
sendDataToFile(String outputFile);
...

Now both inputFile and outputFile would be pointing to same String object with value orders.dat and this object would be in pool.

Now if you change inputFile like this:

inputFile.replace("orders","ordersByMark");

and if Strings would be mutable then the above statement would change the contents of original String object lying in pool from orders.dat to ordersByMark.dat. Now since both inputFile and outputFile was pointing to same String object, change to input file would also change the output file to ordersByMark.dat which is undesirable. Due to this sendDataToFile(String outputFile) method would send data to wrong file.

Thus conclusion is that String pool is meant for sharing the String objects.But this could not become possible if Strings would be mutable.

2) Thread-Safety

One of the greatest advantage of immutable objects is that they can be easily used in mutithreaded environments. Since the state of immutable objects cannot be changed they can be safely used when multiple threads are working upon them. This removes the need of synchronization which is a costly operation.

Since Strings are immutable they can also be used safely in multithreaded environments without requiring sychronization and thus causing performance gains as synchronization affects performance.

Thus due to immutability of Strings they are thread-safe.

3) String used as keys in Maps

Strings are often used as keys in Maps. As you may know that maps calculate hashcode of the keys in order to find the bucket to store that key-value pair.

According to Java API docs of String class:

The hash code for a String object is computed as
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

using int arithmetic, where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation.

Clearly hashcode of string is based on the contents of string.

Suppose you are using a string as key in your Map. If Strings were to be mutable and later if you change the contents of that string then hashcode of that key would also get changed. Then Map will be unable to find the bucket for that key and your key-value pair will be lost.

String key contents changed------>hashcode change-------> bucket info lost in Maps for that key.

4) Cahcing the hashcode

Since hashcode of strings in Java depends on its contents and contents of string do not change (immutable), String class caches the hashcode of String objects instead of calculating it again and again.

This causes performance gain where hashcode is needed to be calcuated again and again such as keys in Maps.Thus use of string as keys in Maps also cause performance gains.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Hashcode Caching by String

Caching the hashcode of an object is very useful in operations where it needs to be calculated frequently. It avoids the recalculation of hashcode again and again and thus increase application performance.

One such operation where hashcode caching is very useful is using an object as a key in maps like HashMap.

Strings are frequently used as keys in maps so it is a best case for caching the hashcode. String class has a built-in hashcode caching mechanism.

According to Java API Docs the hash code for a String object is computed as

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

using int arithmetic, where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation. (The hash value of the empty string is zero.)

It shows that hashcode of a String object depends on its contents.

Now for caching the hashcode for an object whose hashcode depends on its contents, it is necessary for that object to be [immutable]. Otherwise when contents of that object would be changed then hashcode also get changed. Thus caching of hashcode of a such mutable object is of no use. Since strings in Java are immutable we can cache its hashcode.

If you look ito the source code of String class, you will find following definition of hashCode() method :

1494       public int hashCode() {
1495           int h = hash;
1496           if (h == 0 && count > 0) {
1497               int off = offset;
1498               char val[] = value;
1499               int len = count;
1500
1501               for (int i = 0; i < len; i++) {
1502                   h = 31*h + val[off++];
1503               }
1504               hash = h;
1505           }
1506           return h;
1507       }

At line 1495, you will see

int h = hash;

Here variable h is assigned to a variable hash. This variable hash is used to store the haschode for a String object. hash variable is defined at line 122 as:

    122       /** Cache the hash code for the string */
123       private int hash; // Default to 0

Hashcode for strings are cached on per object basis i.e each String object's hashcode is stored in this private variable hash.

Whenever hashCode() method of String class is called, the value of variable hash is checked whether it is 0 or not as indiated by line 1495 and 1496. Variable hash equals to 0 means that hashcode() method is being called first time and hashcode has not been calculated yet.

If hash is equals to 0, only then hashcode for correspoding String object is calculated and cached in variable hash as shown in line 1504.

So when the next time hashCode() for the same String object is called, value of hash does not come out to be 0 and hashcode is not recalcuated but is reused as stored in variable hash.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Difference between Comparable and Comparator Interfaces in java.

Both Comparable and Comparator interfaces in java are used in sorting of objects. Some of the main differences between them are outlined below:

1. Comparable interface lies in java.lang package while Comparator interface lies in java.util package.

2. Comparable interface use compareTo() method to compare objects while Comparator interface use compare() method.

Signature of compareTo() is:

public int compareTo(T obj)

compareTo() takes only one argument and compare it with the object on which compareTo()is called i.e object referenced by 'this' keyword.

Signature of compare() is :

public int compare(T obj1, T obj2)

Unlike compareTo(), compare() takes two arguments. These arguments are the two objects which are being compared.

3. Comparable in Java is used to implement natural ordering of objects while Comparator can be used to implement any user defined ordering.

4. If you have a List (or an array) with each of its elements implementing Comparable interface and you pass this List( or array) to Collection.sort() (or Arrays.sort()), then they will be automatically sorted out according to their natural order.

If their elements do not implement Comparable then you have to pass a Comparator object to
Collections.sort() (or Arrays.sort()) in order to sort the elements like:

Collections.sort (listObject, comparatorObject);

Arrays.sort (array, comparatorObject);

5. In order to use Comparable you have to change the class whose instances you are going to compare. For example, if you are going to compare instances of Accounts class then you have to change it in order to implement Comparable interface.

public class Account implements Comparable{

…

@Override

public int compareTo(Account a1){

…

}

But Comparator does not force you to change the class. You can create separate comparator class as:

public class AccountComparator implements Comparator{

…

@Override

public int compare(Account a1, Account a2){

…

}

and then pass it to the funtions like Arrays.sort() or Collections.sort() as shown in point 4.
Here you do not need to change your Account class.

6. Comparable contract specifies that if null is passed as argument to compareTo(), then it should throw NullPointerException.

Obj1.compareTo(null) // should throw NullPointerException

While contract of Comparator, upto Java 6, does not say anything about null arguments passed to compare(). It also does not specify that compare() should throw NullPointerException.

Its upto you how to handle null arguments. Here you can throw NullPointerException or, unlike Comparable, allow the comparison.

Note that contract of Comparator in Java7 explicitly says that :

Unlike Comparable, a comparator may optionally permit comparison of null arguments, while maintaining the requirements for an equivalence relation.

And

compare() should throw:

NullPointerException - if an argument is null and this comparator does not permit null arguments

7. Comparable should be used to compare elements according to their natural order and Comparator can be used for any other user defined order.

8. Objects which implement Comparable can be used as keys in a SortedMap ( like TreeMap) and as elements in a SortedSet (like TreeSet) without explicitly passing Comparator to their constructors.

9. Comparable can be used when you have only one sorting criteria. For example If you want to sort instances of a PhoneNumber class according to its owners last name only.

But If you have multiple sorting criteria you would need Comparator. For example If you want to sort phone numbers according to area or owners first name also in addition to last name.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Why String is declared final?

String class is made final to close one of the open doors which can make an immutable class mutable.

There are many chances by which an immutable class can be made mutable if it is allowed to be subclassed (i.e if it can be extended). Therefore often immutable classes are made final so that they cannot be extended, making them strongly immutbale as against to weakly immutable.

Thus String is made final to make it strongly immutable.

If String had not been made final, then one can create its subclass and :

1)Can add new fields in sublcass which are not declared final (mutable):

New fields can be added to subclass of String class without declaring them final. So object of this subclass would not be immutable.

Now object of subclass of String class would also be object of String class. This would cause an object of String class to exist which is not immutable.

2) Can override existing methods:

A subclass can override existing methods of String class which can then return different values each time they are called, thus breaking immutabillty. Example,

one can override public charAt(int index) method of String class to return some random character each time it is called as:

@Override
public char charAt(int index){
//retruning some randomly selected character.
}

thus breaking the immutablilty and whole design of String class as many features of String class depends on its immutabilty.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Rajinder Menu