Is ArrayList an object in Java?

In this tutorial we will see how to sort an ArrayList of Objects by property using comparable and comparator interface. If you are looking for sorting a simple ArrayList of String or Integer then you can refer the following tutorials –

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 arraylist = new ArrayList[]; 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 with Comparable

Let’s say we need to sort the ArrayList 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 arraylist = new ArrayList[]; 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]

Comparable did our job why do we need Comparator anymore?
Since Comparable is implemented by the same class whose objects are sorted so it binds you with that sorting logic which is ok in most of the cases but in case you want to have more than way of sorting your class objects you should use comparators. Read more about them here:

1. Comparable in Java
2. Comparator in Java

Sorting ArrayList 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 StuNameComparator = new Comparator[] { 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 StuRollno = new Comparator[] { 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 arraylist = new ArrayList[]; 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]

• All Implemented Interfaces: Serializable, Cloneable, Iterable, Collection, List, RandomAccess Direct Known Subclasses: AttributeList, RoleList, RoleUnresolvedList
  public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable

  Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null. In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list. [This class is roughly equivalent to Vector, except that it is unsynchronized.]

  The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O[n] time. All of the other operations run in linear time [roughly speaking]. The constant factor is low compared to that for the LinkedList implementation.

  Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.

  An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.

  Note that this implementation is not synchronized. If multiple threads access an ArrayList instance concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally. [A structural modification is any operation that adds or deletes one or more elements, or explicitly resizes the backing array; merely setting the value of an element is not a structural modification.] This is typically accomplished by synchronizing on some object that naturally encapsulates the list. If no such object exists, the list should be "wrapped" using the Collections.synchronizedList method. This is best done at creation time, to prevent accidental unsynchronized access to the list:

  List list = Collections.synchronizedList[new ArrayList[...]];

  The iterators returned by this class's iterator and listIterator methods are fail-fast: if the list is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove or add methods, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

  Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

  This class is a member of the Java Collections Framework.

  Since: 1.2 See Also: Collection, List, LinkedList, Vector, Serialized Form

• • • finalize, getClass, notify, notifyAll, wait, wait, wait
    • containsAll, equals, hashCode

• • • public ArrayList[int initialCapacity]

      Constructs an empty list with the specified initial capacity.

      Parameters: initialCapacity - the initial capacity of the list Throws: IllegalArgumentException - if the specified initial capacity is negative
    • public ArrayList[]

      Constructs an empty list with an initial capacity of ten.

    • public ArrayList[Collection c]

      Retains only the elements in this list that are contained in the specified collection. In other words, removes from this list all of its elements that are not contained in the specified collection.

      Specified by: retainAll in interface Collection Specified by: retainAll in interface List Overrides: retainAll in class AbstractCollection Parameters: c - collection containing elements to be retained in this list Returns: true if this list changed as a result of the call Throws: ClassCastException - if the class of an element of this list is incompatible with the specified collection [optional] NullPointerException - if this list contains a null element and the specified collection does not permit null elements [optional], or if the specified collection is null See Also: Collection.contains[Object]
    • public ListIterator listIterator[int index]

      Returns a list iterator over the elements in this list [in proper sequence], starting at the specified position in the list. The specified index indicates the first element that would be returned by an initial call to next. An initial call to previous would return the element with the specified index minus one.

      The returned list iterator is fail-fast.

      Specified by: listIterator in interface List Overrides: listIterator in class AbstractList Parameters: index - index of the first element to be returned from the list iterator [by a call to next] Returns: a list iterator over the elements in this list [in proper sequence], starting at the specified position in the list Throws: IndexOutOfBoundsException - if the index is out of range [index < 0 || index > size[]]
    • public List subList[int fromIndex, int toIndex]

      Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. [If fromIndex and toIndex are equal, the returned list is empty.] The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations.

      This method eliminates the need for explicit range operations [of the sort that commonly exist for arrays]. Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of elements from a list:

      list.subList[from, to].clear[]; Similar idioms may be constructed for indexOf[Object] and lastIndexOf[Object], and all of the algorithms in the Collections class can be applied to a subList.

      The semantics of the list returned by this method become undefined if the backing list [i.e., this list] is structurally modified in any way other than via the returned list. [Structural modifications are those that change the size of this list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.]

      Specified by: subList in interface List Overrides: subList in class AbstractList Parameters: fromIndex - low endpoint [inclusive] of the subList toIndex - high endpoint [exclusive] of the subList Returns: a view of the specified range within this list Throws: IndexOutOfBoundsException - if an endpoint index value is out of range [fromIndex < 0 || toIndex > size] IllegalArgumentException - if the endpoint indices are out of order [fromIndex > toIndex]
    • public void forEach[Consumer