Java Collections Framework:ArrayList-3(ArrayList Sorting)

 

How to sort ArrayList in Java


Example 1: Sorting of ArrayList<String>

Here we are sorting the ArrayList of String type. We are doing it by simply calling the Collections.sort(arraylist) method. The output List will be sorted alphabetically.

import java.util.*;
public class Details  {

	public static void main(String args[]){
	   ArrayList<String> listofcountries = new ArrayList<String>();
	   listofcountries.add("India");
	   listofcountries.add("US");
	   listofcountries.add("China");
	   listofcountries.add("Denmark");

	   /*Unsorted List*/
	   System.out.println("Before Sorting:");
	   for(String counter: listofcountries){
			System.out.println(counter);
		}

	   /* Sort statement*/
	   Collections.sort(listofcountries);

	   /* Sorted List*/
	   System.out.println("After Sorting:");
	   for(String counter: listofcountries){
			System.out.println(counter);
		}
	}
}

Output:



Before Sorting:
India
US
China
Denmark
After Sorting:
China
Denmark
India
US

Example 2: Sorting of ArrayList<Integer>

The same Collections.sort() method can be used for sorting the Integer ArrayList as well.

import java.util.*;
public class ArrayListOfInteger  {

	public static void main(String args[]){
	   ArrayList<Integer> arraylist = new ArrayList<Integer>();
	   arraylist.add(11);
	   arraylist.add(2);
	   arraylist.add(7);
	   arraylist.add(3);
	   /* ArrayList before the sorting*/
	   System.out.println("Before Sorting:");
	   for(int counter: arraylist){
			System.out.println(counter);
		}

	   /* Sorting of arraylist using Collections.sort*/
	   Collections.sort(arraylist);

	   /* ArrayList after sorting*/
	   System.out.println("After Sorting:");
	   for(int counter: arraylist){
			System.out.println(counter);
		}
	}
}

Output:

Before Sorting:
11
2
7
3
After Sorting:
2
3
7
11

How to sort ArrayList in descending order in Java.

Example: Sorting in Descending order

We are using Collections.reverseOrder() method along with Collections.sort() in order to sort the list in decreasing order. In the below example we have used the following statement for sorting in reverse order.
Collections.sort(arraylist, Collections.reverseOrder());

However the reverse order sorting can also be done as following – This way the list will be sorted in ascending order first and then it will be reversed.
Collections.sort(list);
Collections.reverse(list);

Complete example:



import java.util.*;
public class Details  {

	public static void main(String args[]){
	   ArrayList<String> arraylist = new ArrayList<String>();
	   arraylist.add("AA");
	   arraylist.add("ZZ");
	   arraylist.add("CC");
	   arraylist.add("FF");

	   /*Unsorted List: ArrayList content before sorting*/
	   System.out.println("Before Sorting:");
	   for(String str: arraylist){
			System.out.println(str);
		}

	   /* Sorting in decreasing order*/
	   Collections.sort(arraylist, Collections.reverseOrder());

	   /* Sorted List in reverse order*/
	   System.out.println("ArrayList in descending order:");
	   for(String str: arraylist){
			System.out.println(str);
		}
	}
}

Output:

Before Sorting:
AA
ZZ
CC
FF
ArrayList in descending order:
ZZ
FF
CC
AA

In the above example we have used the ArrayList of String type (ArrayList<String>) for sorting. The same sorting method can be used for the list of integers as well.


Java ArrayList of Object Sort Example (Comparable And Comparator)


We generally use Collections.sort() method to sort a simple array list. However if the ArrayList is of custom object type then in such case you have two options for sorting- comparable and comparator interfaces. Before going through the example of them, let’s see what’s the output when we try to sort arraylist of Objects without implementing any of these interfaces.

What’s the need of comparable and comparator?

Consider the below example – I have a Student class which has properties like Student name, roll no and student age.

public class Student  {
    private String studentname;
    private int rollno;
    private int studentage;

    public Student(int rollno, String studentname, int studentage) {
         this.rollno = rollno;
         this.studentname = studentname;
         this.studentage = studentage;
    }

    public String getStudentname() {
         return studentname;
    }
    public void setStudentname(String studentname) {
	this.studentname = studentname;
    }
    public int getRollno() {
	return rollno;
    }
    public void setRollno(int rollno) {
	this.rollno = rollno;
    }
    public int getStudentage() {
	return studentage;
    }
    public void setStudentage(int studentage) {
 	this.studentage = studentage;
    }	
}

And I want to have an ArrayList of Student Object. We do it like this –

import java.util.*;
public class ArrayListSorting  {

     public static void main(String args[]){
	   ArrayList<Student> arraylist = new ArrayList<Student>();
	   arraylist.add(new Student(223, "Chaitanya", 26));
	   arraylist.add(new Student(245, "Rahul", 24));
	   arraylist.add(new Student(209, "Ajeet", 32));

	   Collections.sort(arraylist);

	   for(Student str: arraylist){
			System.out.println(str);
	   }
     }
}

I tried to call the Collections.sort() on the List of Objects and boom! I got the the error message like this –
Exception in thread “main” java.lang.Error: Unresolved compilation problem:
Bound mismatch: The generic method sort(List) of type Collections is not applicable for the arguments (ArrayList). The inferred type Student is not a valid substitute for the bounded parameter > at beginnersbook.com.Details.main(Details.java:11)

Reason: I Just called the sort method on an ArrayList of Objects which actually doesn’t work until unless we use interfaces like Comparable and Comparator.

Now you must have understood the importance of these interfaces. Let’s see how to use them to get the sorting done in our way.

Sorting of ArrayList<Object> with Comparable

Let’s say we need to sort the ArrayList<Student> based on the student Age property. This is how it can be done – First implement Comparable interface and then Override the compareTo method.

package beginnersbook.com;

public class Student implements Comparable {
    private String studentname;
    private int rollno;
    private int studentage;

    public Student(int rollno, String studentname, int studentage) {
        this.rollno = rollno;
        this.studentname = studentname;
        this.studentage = studentage;
    }
    ...
    //getter and setter methods same as the above example 
    ...
    @Override
    public int compareTo(Student comparestu) {
        int compareage=((Student)comparestu).getStudentage();
        /* For Ascending order*/
        return this.studentage-compareage;

        /* For Descending order do like this */
        //return compareage-this.studentage;
    }

    @Override
    public String toString() {
        return "[ rollno=" + rollno + ", name=" + studentname + ", age=" + studentage + "]";
    }

}

Now we can very well call Collections.sort on ArrayList

import java.util.*;
public class ArrayListSorting  {

	public static void main(String args[]){
	   ArrayList<Student> arraylist = new ArrayList<Student>();
	   arraylist.add(new Student(223, "Chaitanya", 26));
	   arraylist.add(new Student(245, "Rahul", 24));
	   arraylist.add(new Student(209, "Ajeet", 32));

	   Collections.sort(arraylist);

	   for(Student str: arraylist){
			System.out.println(str);
	   }
	}
}

Output:

[ rollno=245, name=Rahul, age=24]
[ rollno=223, name=Chaitanya, age=26]
[ rollno=209, name=Ajeet, age=32]

Sorting ArrayList<Object> multiple properties with Comparator

We are overriding compare method of Comparator for sorting.

package beginnersbook.com;
import java.util.Comparator;
public class Student  {
    private String studentname;
    private int rollno;
    private int studentage;

    public Student(int rollno, String studentname, int studentage) {
        this.rollno = rollno;
        this.studentname = studentname;
        this.studentage = studentage;
    }
    ...
    //Getter and setter methods same as the above examples
    ...
    /*Comparator for sorting the list by Student Name*/
    public static Comparator<Student> StuNameComparator = new Comparator<Student>() {

	public int compare(Student s1, Student s2) {
	   String StudentName1 = s1.getStudentname().toUpperCase();
	   String StudentName2 = s2.getStudentname().toUpperCase();

	   //ascending order
	   return StudentName1.compareTo(StudentName2);

	   //descending order
	   //return StudentName2.compareTo(StudentName1);
    }};

    /*Comparator for sorting the list by roll no*/
    public static Comparator<Student> StuRollno = new Comparator<Student>() {

	public int compare(Student s1, Student s2) {

	   int rollno1 = s1.getRollno();
	   int rollno2 = s2.getRollno();

	   /*For ascending order*/
	   return rollno1-rollno2;

	   /*For descending order*/
	   //rollno2-rollno1;
   }};
    @Override
    public String toString() {
        return "[ rollno=" + rollno + ", name=" + studentname + ", age=" + studentage + "]";
    }

}

ArrayList class:

package beginnersbook.com;
import java.util.*;
public class Details  {

	public static void main(String args[]){
	   ArrayList<Student> arraylist = new ArrayList<Student>();
	   arraylist.add(new Student(101, "Zues", 26));
	   arraylist.add(new Student(505, "Abey", 24));
	   arraylist.add(new Student(809, "Vignesh", 32));

	   /*Sorting based on Student Name*/
	   System.out.println("Student Name Sorting:");
	   Collections.sort(arraylist, Student.StuNameComparator);

	   for(Student str: arraylist){
			System.out.println(str);
	   }

	   /* Sorting on Rollno property*/
	   System.out.println("RollNum Sorting:");
	   Collections.sort(arraylist, Student.StuRollno);
	   for(Student str: arraylist){
			System.out.println(str);
	   }
	}
}

Output:

Student Name Sorting:
[ rollno=505, name=Abey, age=24]
[ rollno=809, name=Vignesh, age=32]
[ rollno=101, name=Zues, age=26]
RollNum Sorting:
[ rollno=101, name=Zues, age=26]
[ rollno=505, name=Abey, age=24]
[ rollno=809, name=Vignesh, age=32]


Comments

Post a Comment

Popular posts from this blog

Java OOPS:OOPS Concepts Overview

Image
  OOPs concepts in Java Object-oriented programming System(OOPs) is a programming paradigm based on the concept of “objects” that contain data and methods. The primary purpose of object-oriented programming is to increase the flexibility and maintainability of programs. Object oriented programming brings together data and its behaviour(methods) in a single location(object) makes it easier to understand how a program works. We will cover each and every feature of OOPs in detail so that you won’t face any difficultly understanding  OOPs Concepts . OOPs Concepts – Table of Contents What is an Object What is a class Constructor in Java Object Oriented Programming Features Abstraction Encapsulation Inheritance Polymorphism Abstract Class and Methods Interfaces in Java What is an Object Object:  is a bundle of data and its behaviour(often known as methods). Objects have two characteristics: They have  states  and  behaviors . Examples of states and behaviors Exam...
Read more

Selenium-Java Contents

  Contents Datatypes In Java String Class In Java  if, if else and nested if else In Java   for loop In Java   while, do while loops In Java   One and two dimensional array In Java   Methods In Java   Access Modifiers In Java   Return Type Of Method In Java   Static, Non Static Methods, Variables In Java   Object In Java   Variable Types In Java   Constructor In Java   Inheritance In Java   Interface In Java   ArrayList In Java   Hashtable In Java   Read-Write Text File In Java   Exception handling, try-catch-finally, throw and throws In Java   Useful Eclipse Shortcuts To Use With Selenium WebDriver Automation Encapsulation In Java Polymorphism In Java What Is An Abstract Class In Java? What Is Method Overloading In Java? Similarities And Difference Between Abstract Class And Interface Usage of "final" Keyword In Java What Is Use Of "Super" Keyword In Java?
Read more

Java OOPS:Constructors in Java – A complete study!!

Image
  Constructors in Java – A complete study!! Constructor is a block of code that initializes the newly created object. A constructor resembles an instance method in java but it’s not a method as it doesn’t have a return type. In short constructor and method are different(More on this at the end of this guide). People often refer constructor as special type of method in Java. Constructor has same name as the class and looks like this in a java code. public class MyClass { //This is the constructor MyClass (){ } .. } Note that the constructor name matches with the class name and it doesn’t have a return type. How does a constructor work To understand the working of constructor, lets take an example. lets say we have a class  MyClass . When we create the object of  MyClass  like this: MyClass obj = new MyClass () The  new keyword  here creates the object of class  MyClass  and invokes the constructor to initialize this newly crea...
Read more