Using generic interfaces

[Ganesh Patekar]

This is how I tried to use generic interface and generic methods.

package test;

interface SortInfo<T> {

	T sortPersonByAgeAscending(T t);

	T sortPersonByNameAscending(T t);
}

class Person {
	private String personName;
	private int personAge;

	public String getPersonName() {
		return personName;
	}

	public void setPersonName(String personName) {
		this.personName = personName;
	}

	public int getPersonAge() {
		return personAge;
	}

	public void setPersonAge(int personAge) {
		this.personAge = personAge;
	}

	public String toString() {
		return "Name: " + this.getPersonName() + " Age: " + this.getPersonAge();
	}
}

class SortPersonInfo implements SortInfo<Person[]> {

	@Override
	public Person[] sortPersonByAgeAscending(Person[] prsnObjArray) {

		for (int i = 0; i < prsnObjArray.length; i++) {
			for (int j = i + 1; j < prsnObjArray.length; j++) {

				if (prsnObjArray[i].getPersonAge() > prsnObjArray[j].getPersonAge()) {

					Person tempPerson = prsnObjArray[i];
					prsnObjArray[i] = prsnObjArray[j];
					prsnObjArray[j] = tempPerson;
				}
			}
		}

		return prsnObjArray;
	}

	@Override
	public Person[] sortPersonByNameAscending(Person[] prsnObjArray) {

		for (int i = 0; i < prsnObjArray.length; i++) {
			for (int j = i + 1; j < prsnObjArray.length; j++) {

				if (prsnObjArray[i].getPersonName()
						.compareToIgnoreCase(prsnObjArray[j].getPersonName()) > 0) {
					Person tempPerson = prsnObjArray[i];
					prsnObjArray[i] = prsnObjArray[j];
					prsnObjArray[j] = tempPerson;
				}
			}
		}

		return prsnObjArray;
	}

}

public class GenericMethodDemo {

	private Person[] personList;

	public GenericMethodDemo() {
		/*
		 * 3 objects of Person created and assigned to array of type Person.
		 */
		personList = new Person[3];

		personList[0] = new Person();
		personList[0].setPersonName("Hrithik");
		personList[0].setPersonAge(40);

		personList[1] = new Person();
		personList[1].setPersonName("John");
		personList[1].setPersonAge(20);

		personList[2] = new Person();
		personList[2].setPersonName("Anil");
		personList[2].setPersonAge(50);

	}

	private void sortPersonByAge() {

		SortPersonInfo srtPersnObj1 = new SortPersonInfo();
		srtPersnObj1.sortPersonByAgeAscending(personList);
	}

	private void sortPersonByName() {

		SortPersonInfo srtPersnObj1 = new SortPersonInfo();
		srtPersnObj1.sortPersonByNameAscending(personList);
	}

	private void displayPersonInfo() {
		for (Person p : personList) {
			System.out.println(p.toString());
		}
	}

	public static void main(String[] args) {
		GenericMethodDemo gnrcMthdDmObj1 = new GenericMethodDemo();
		System.out.println("Person Information Before Sorting By Name:");
		gnrcMthdDmObj1.displayPersonInfo();
		gnrcMthdDmObj1.sortPersonByName();
		System.out.println("Person Information After Sorting By Name Ascending:");
		gnrcMthdDmObj1.displayPersonInfo();
		System.out.println();
		System.out.println("******Sort By Age Ascending******");
		System.out.println("Person Information Before Sorting By Age:");
		gnrcMthdDmObj1.displayPersonInfo();
		gnrcMthdDmObj1.sortPersonByAge();
		System.out.println("Person Information After Sorting By Age Ascending:");
		gnrcMthdDmObj1.displayPersonInfo();

	}

}

Output:
Person Information Before Sorting By Name:
Name: Hrithik Age: 40
Name: John Age: 20
Name: Anil Age: 50
Person Information After Sorting By Name Ascending:
Name: Anil Age: 50
Name: Hrithik Age: 40
Name: John Age: 20

******Sort By Age Ascending******
Person Information Before Sorting By Age:
Name: Anil Age: 50
Name: Hrithik Age: 40
Name: John Age: 20
Person Information After Sorting By Age Ascending:
Name: John Age: 20
Name: Hrithik Age: 40
Name: Anil Age: 50

Is this a way to use generic method and interface?

[Stephan van Hulst]

I wouldn't say this is correct. Your SortInfo interface defines a contract without the means to implement that contract reliably:

final class PetSortInfo implements SortInfo<Pet[]> {
  // How do we sort an array of pets?
}

final class SinglePersonSortInfo implements SortInfo<Person> {
 // How do we sort a single person?
}

This is how your interface should be declared instead:

interface NameAndAgeSorter<T extends HasNameAndAge> {

  T[] sortByAgeAscending (T[] array);

  T[] sortByNameAscending(T[] array);

}

[Ganesh Patekar]

Stephan van Hulst wrote:

interface NameAndAgeSorter<T extends HasNameAndAge>

Does HasNameAndAge means Person class in my example?

[Stephan van Hulst]

Person would be implementing HasNameAndAge, but so can Pet or anything else that has a name and an age.

However, it's even nicer to split up this interface into two separate traits:

interface HasName {
  String name();
}

interface HasAge {
  LocalDate dateOfBirth();
}

This is what Person would then look like:

final class Person implements HasName, HasAge {

  private final String name;
  private final LocalDate dateOfBirth;

  Person(String name, LocalDate dateOfBirth) {
    if (name == null || dateOfBirth == null)
      throw new IllegalArgumentException();

    this.name = name;
    this.dateOfBirth = dateOfBirth;
  }

  @Override
  public String name() {
    return name;
  }

  @Override
  public LocalDate dateOfBirth() {
    return dateOfBirth;
  }
}

And a possible sorter interface could then look like this:

interface NameAndAgeSorter<T extends HasName & HasAge> {
 
  T[] sortByNameThenByAge(T[] array);
 
}

[Ganesh Patekar]

This is new code.

package test;

import java.time.LocalDate;
import java.time.Month;
import java.time.format.DateTimeFormatter;

interface HasName {
	String getName();
}

interface HasAge {
	LocalDate getAge();
}

interface NameAndAgeSorter<T extends HasName & HasAge> {
	T[] sortByName(T[] array);

	T[] sortByAge(T[] array);

}

final class Person implements HasName, HasAge {
	private String personName;
	private LocalDate personAge;

	public String getPersonName() {
		return personName;
	}

	public void setPersonName(String personName) {
		this.personName = personName;
	}

	public LocalDate getPersonAge() {
		return personAge;
	}

	public void setPersonAge(LocalDate personAge) {
		this.personAge = personAge;
	}

	public String toString() {
		return "Name: " + this.getPersonName() + " Age: " + this.getPersonAge();
	}

	@Override
	public String getName() {
		return personName;
	}

	@Override
	public LocalDate getAge() {
		return personAge;
	}
}

class SortPersonInfo implements NameAndAgeSorter<Person> {

	@Override
	public Person[] sortByName(Person[] prsnObjArray) {
		for (int i = 0; i < prsnObjArray.length; i++) {
			for (int j = i + 1; j < prsnObjArray.length; j++) {

				if (prsnObjArray[i].getName()
						.compareToIgnoreCase(prsnObjArray[j].getName()) > 0) {
					Person tempPerson = prsnObjArray[i];
					prsnObjArray[i] = prsnObjArray[j];
					prsnObjArray[j] = tempPerson;
				}
			}
		}

		return prsnObjArray;
	}

	@Override
	public Person[] sortByAge(Person[] prsnObjArray) {
		for (int i = 0; i < prsnObjArray.length; i++) {
			for (int j = i + 1; j < prsnObjArray.length; j++) {

				if (prsnObjArray[i].getAge()
						.compareTo(prsnObjArray[j].getAge()) > 0) {
					Person tempPerson = prsnObjArray[i];
					prsnObjArray[i] = prsnObjArray[j];
					prsnObjArray[j] = tempPerson;
				}
			}
		}

		return prsnObjArray;

	}

}

public class GenericMethodDemo {

	private Person[] personList;

	public GenericMethodDemo() {
		/*
		 * 3 objects of Person created and assigned to array of type Person.
		 */

		// LocalDate personAge =

		personList = new Person[3];

		personList[0] = new Person();
		personList[0].setPersonName("Hrithik");
		personList[0].setPersonAge(LocalDate.of(1987, Month.JULY, 31));

		personList[1] = new Person();
		personList[1].setPersonName("John");
		personList[1].setPersonAge(LocalDate.of(1980, Month.JANUARY, 15));

		personList[2] = new Person();
		personList[2].setPersonName("Anil");
		personList[2].setPersonAge(LocalDate.of(1997, Month.SEPTEMBER, 11));

	}

	private void sortPersonByName() {

		SortPersonInfo srtPersnObj1 = new SortPersonInfo();
		srtPersnObj1.sortByName(personList);
	}

	private void sortPersonByAge() {

		SortPersonInfo srtPersnObj1 = new SortPersonInfo();
		srtPersnObj1.sortByAge(personList);
	}

	private void displayPersonInfo() {
		for (Person p : personList) {
			System.out.println(p.toString());
		}
	}

	public static void main(String[] args) {
		GenericMethodDemo gnrcMthdDmObj1 = new GenericMethodDemo();
		System.out.println("Person Information Before Sorting By Name:");
		gnrcMthdDmObj1.displayPersonInfo();
		gnrcMthdDmObj1.sortPersonByName();
		System.out.println("Person Information After Sorting By Name Ascending:");
		gnrcMthdDmObj1.displayPersonInfo();
		System.out.println();

		System.out.println("******Sort By Age Ascending******");
		System.out.println("Person Information Before Sorting By Age:");
		gnrcMthdDmObj1.displayPersonInfo();
		gnrcMthdDmObj1.sortPersonByAge();
		System.out.println("Person Information After Sorting By Age Ascending:");
		gnrcMthdDmObj1.displayPersonInfo();

	}

}

It works properly. Is this correct?

[Liutauras Vilda]

Ganesh Patekar wrote:It works properly. Is this correct?

There is a one side effect. Your original array personList gets altered after the sortByXXX gets invoked. That is not always correct, in your case I'd say incorrect as there are no records that you were aware of that. In case otherwise, since original array gets altered, you don't even need to return anything from the sort method. Check if that was your intention.

[Stephan van Hulst]

Besides what Liutauras mentioned, it looks correct. Here are some other pointers though:

Person is package-visible, but contains public members.

You should annotate toString() with @Override.

Person's fields can be null. You shouldn't allow this.

SortPersonInfo is a bad name. Either it's a verb, and class names shouldn't be verbs, or it's a noun, but it doesn't represent any kind of info. Call it something like PersonSorter.

SortPersonInfo can be final.

You're using a form of selection sort. Selection sort is an inefficient sorting method.

You duplicated your sorting code. Code duplication is bad.

GenericMethodDemo is public. Is this necessary?

GenericMethodDemo can be final.

personList can be final.

If Person has a constructor that initializes its fields from parameters, you can populate personList with an array initializer.

You don't have to call toString() inside println() argument list. The println() method automatically calls toString() if you pass it any old object.

[Ganesh Patekar]

Liutauras Vilda wrote:

Ganesh Patekar wrote:It works properly. Is this correct?

There is a one side effect. Your original array personList gets altered after the sortByXXX gets invoked. That is not always correct, in your case I'd say incorrect as there are no records that you were aware of that. In case otherwise, since original array gets altered, you don't even need to return anything from the sort method. Check if that was your intention.

Ohh, Yes arrays are reference types so no need to return. Yes your are correct, actually I should not alter original array.(I don't have any condition but in general It is good to keep record of original)

JLS 10.7.1 wrote: Arrays Are Cloneable (Only one dimensional (In multidimensional subarrays are shared))

Here we have one dimensional array so I cloned original array into duplicatePersonList and used that cloned array for sorting. I also checked after sorting which alters duplicatePersonList but originalPersonList was not altered.

Stephan van Hulst wrote:You're using a form of selection sort. Selection sort is an inefficient sorting method.

Ohh I see, yes I'm going to revise all algorithms once again and will create new topic only for sorting algorithms soon( Later I will also sort them using comparators). It's been long time haven't gone through them but at this moment I think I'll keep this as It is because I'm brushing up my basic concepts of Java.

Stephan van Hulst wrote:You duplicated your sorting code. Code duplication is bad.

Are you saying duplicate code because of those two separate methods one for date of birth and other for name? Actually I wanted to have separate sorting one is based only on name and other on date of birth. I mean not  comparaing person on name and date of birth at a time. If I understood something else than what you meant then please let me know.

[Ganesh Patekar]

Here is latest code where I changed few names of fields, class and methods.

package test;

import java.time.LocalDate;
import java.time.Month;

interface HasName {
	String getName();
}

interface HasAge {
	LocalDate getDOB();
}

interface NameAndAgeSorter<T extends HasName & HasAge> {
	void sortByName(T[] array);

	void sortByAge(T[] array);
}

final class Person implements HasName, HasAge {
	private String personName;
	private LocalDate personDOB;

	Person(String personName, LocalDate personDOB) {

		if (personName == null || personDOB == null) {
			throw new NullPointerException("Person's attribute can't be null");
		}

		this.personName = personName;
		this.personDOB = personDOB;
	}

	String getPersonName() {
		return personName;
	}

	void setPersonName(String personName) {
		this.personName = personName;
	}

	LocalDate getPersonAge() {
		return personDOB;
	}

	void setPersonAge(LocalDate personAge) {
		this.personDOB = personAge;
	}

	@Override
	public String toString() {
		return "Name: " + this.getPersonName() 
		+ " Age: " + this.getPersonAge();
	}

	@Override
	public String getName() {
		return personName;
	}

	@Override
	public LocalDate getDOB() {
		return personDOB;
	}

}

final class PersonSorter implements NameAndAgeSorter<Person> {

	@Override
	public void sortByName(Person[] prsnObjArray) {
		for (int i = 0; i < prsnObjArray.length; i++) {
			for (int j = i + 1; j < prsnObjArray.length; j++) {

				if (prsnObjArray[i].getName()
						.compareToIgnoreCase(prsnObjArray[j].getName()) > 0) {
					Person tempPerson = prsnObjArray[i];
					prsnObjArray[i] = prsnObjArray[j];
					prsnObjArray[j] = tempPerson;
				}
			}
		}

	}

	@Override
	public void sortByAge(Person[] prsnObjArray) {
		for (int i = 0; i < prsnObjArray.length; i++) {
			for (int j = i + 1; j < prsnObjArray.length; j++) {

				if (prsnObjArray[i].getDOB()
						.compareTo(prsnObjArray[j].getDOB()) > 0) {
					Person tempPerson = prsnObjArray[i];
					prsnObjArray[i] = prsnObjArray[j];
					prsnObjArray[j] = tempPerson;
				}
			}
		}

	}

}

final class GenericMethodDemo {

	private final Person[] personList;
	private final Person[] duplicatePersonList;

	public GenericMethodDemo() {

		personList = new Person[] { 
				new Person("Hrithik", LocalDate.of(1987, Month.JULY, 31)),
				new Person("John", LocalDate.of(1980, Month.JANUARY, 15)),
				new Person("Anil", LocalDate.of(1997, Month.SEPTEMBER, 11)) 
				};

		duplicatePersonList = personList.clone();
	}

	private void sortPersonByName() {

		PersonSorter srtPersnObj1 = new PersonSorter();
		srtPersnObj1.sortByName(duplicatePersonList);
	}

	private void sortPersonByAge() {

		PersonSorter srtPersnObj1 = new PersonSorter();
		srtPersnObj1.sortByAge(duplicatePersonList);
	}

	private void printSortedListOfPerson() {
		for (Person p : duplicatePersonList) {
			System.out.println(p);
		}
	}

	/*
	 * Below method only for priniting original array list
	 */
	private void printOriginalListOfPerson() {
		for (Person p : personList) {
			System.out.println(p);
		}
	}

	public static void main(String[] args) {
		GenericMethodDemo gnrcMthdDmObj1 = new GenericMethodDemo();
		System.out.println("Person Information Before Sorting By Name:");
		gnrcMthdDmObj1.printSortedListOfPerson();
		gnrcMthdDmObj1.sortPersonByName();
		System.out.println("Person Information After Sorting By Name Ascending:");
		gnrcMthdDmObj1.printSortedListOfPerson();
		System.out.println();

		System.out.println("******Sort By Age Ascending******");
		System.out.println("Person Information Before Sorting By Age:");
		gnrcMthdDmObj1.printSortedListOfPerson();
		gnrcMthdDmObj1.sortPersonByAge();
		System.out.println("Person Information After Sorting By Age Ascending:");
		gnrcMthdDmObj1.printSortedListOfPerson();

	}
}

I'm getting correct output. Any advice in above code?

[Liutauras Vilda]

Ganesh Patekar wrote:

interface NameAndAgeSorter<T extends HasName & HasAge> {
    void sortByName(T[] array);
    ...
}

final class PersonSorter
    public void sortByName(Person[] prsnObjArray) {
        ...
    }
}

In my opinion there isn't needed to write PersonSorter, especially if it sorts by name. As was mentioned earlier, if you'd sort Dog's array by their name, you'd end up implementing DogsSorter class, if got cows, you'd need to implement CowsSorter which basically would look similarly except sortByName method's parameter type.

So what you could do, is to write a class in more general way so it would implement methods sort by name and age, and such example method signature would look as (but this time it takes interface as a parameter):

public void sortByname(HasName[] A) {
    ...
}

As well similarly sorting by age. So, in that case you wouldn't care are the people or dogs or cats or cows, it would sort all entities who have names (implements interface HasName) and similarly with an age.

Your code duplication appear in elements swapping. So, three lines in each of sorting method could be wrapped to a swapElements() method.

[Liutauras Vilda]

That could look similarly to:

public interface SortsByNameAndAge<T extends HasName & HasAge> {
    ...
}

public class NameAndAgeSorter implements SortsByNameAndAge<..> {
    
    /* Alters original array's content */
    public void sortByName(HasName[] A) {
        ...
        swapElements(...);
    }

    public void sortByAge(HasAge[] B) {
        ...
        swapElements(...);
    }

    private void swapElements(...) {
        ...
    }
}

[Stephan van Hulst]

Your sorting methods are only different in how they compare the elements. You can prevent code duplication by separating the comparison logic from the sorting logic:

private static void sort(T[] array, Comparator<? super T> comparator) {
  ...
}

You can then call this generic sorting method like this:

@Override
public void sortByName(T[] array) {
  // A collator with secondary strength will compare strings while ignoring case differences.
  Collator ignoringCase = Collator.getInstance();
  ignoringCase.setStrength(Collator.SECONDARY);

  sort(array, Comparator.comparing(T::getName, ignoringCase));
}

[Stephan van Hulst]

The fun part is that you don't actually even have to implement the sort yourself this way. Check out what the method signature of Arrays.sort() is.

[Ganesh Patekar]

I apologize for being late, my internet connection was interrupted since last night  
I created comparator for name and age and used with Arrays's sort method.
Latest Code 1:

package generic;

import java.time.LocalDate;
import java.time.Month;
import java.util.Arrays;
import java.util.Comparator;

interface HasName {
	String getName();
}

interface HasAge {
	LocalDate getDOB();
}

interface SortByNameAndAge<T extends HasName & HasAge> {
	void sortByName(HasName[] t);

	void sortByAge(HasAge[] t);
}

final class NameComparator implements Comparator<HasName> {

	@Override
	public int compare(HasName o1, HasName o2) {
		return o1.getName().compareToIgnoreCase(o2.getName());
	}

}

final class AgeComparator implements Comparator<HasAge> {

	@Override
	public int compare(HasAge o1, HasAge o2) {
		return o1.getDOB().compareTo(o2.getDOB());
	}

}

final class Person implements HasName, HasAge {
	private String personName;
	private LocalDate personDOB;

	Person(String personName, LocalDate personDOB) {

		if (personName == null || personDOB == null) {
			throw new NullPointerException("Person's attribute can't be null");
		}

		this.personName = personName;
		this.personDOB = personDOB;
	}

	String getPersonName() {
		return personName;
	}

	void setPersonName(String personName) {
		this.personName = personName;
	}

	LocalDate getdob() {

		return personDOB;
	}

	void setPersonAge(LocalDate personAge) {
		this.personDOB = personAge;
	}

	@Override
	public String toString() {
		return "Person Name: " + this.getPersonName() 
		+ " Person DOB: " + this.getdob();
	}

	@Override
	public String getName() {
		return personName;
	}

	@Override
	public LocalDate getDOB() {
		return personDOB;
	}

}

final class NameAndAgeSorter implements SortByNameAndAge {

	@Override
	public void sortByName(HasName[] objArray) {
		Arrays.sort(objArray, new NameComparator());
	}

	@Override
	public void sortByAge(HasAge[] objArray) {
		Arrays.sort(objArray, new AgeComparator());
	}
}

final class GenericMethodDemo {

	private final Person[] personList;
	private final Person[] duplicatePersonList;

	public GenericMethodDemo() {

		personList = new Person[] { 
				new Person("Hrithik", LocalDate.of(1987, Month.JULY, 31)),
				new Person("John", LocalDate.of(1980, Month.JANUARY, 15)),
				new Person("Anil", LocalDate.of(1997, Month.SEPTEMBER, 11)) 
				};

		duplicatePersonList = personList.clone();
	}

	private void sortByName() {

		NameAndAgeSorter nmAgeSrtrObj1 = new NameAndAgeSorter();
		nmAgeSrtrObj1.sortByName(duplicatePersonList);
	}

	private void sortByAge() {

		NameAndAgeSorter nmAgeSrtrObj1 = new NameAndAgeSorter();
		nmAgeSrtrObj1.sortByAge(duplicatePersonList);
	}

	private void printList() {
		for (Person p : duplicatePersonList) {
			System.out.println(p);
		}
	}

	/*
	 * Below method only for priniting original array list
	 */
	private void printOriginalList() {
		for (Person p : personList) {
			System.out.println(p);
		}
	}

	public static void main(String[] args) {
		GenericMethodDemo gnrcMthdDmObj1 = new GenericMethodDemo();
		System.out.println("Information Before Sorting By Name:");
		gnrcMthdDmObj1.printList();
		gnrcMthdDmObj1.sortByName();
		System.out.println("Information After Sorting By Name Ascending:");
		gnrcMthdDmObj1.printList();
		System.out.println();

		System.out.println("******Sort By DOB Ascending******");
		System.out.println("Person Information Before Sorting By DOB:");
		gnrcMthdDmObj1.printList();
		gnrcMthdDmObj1.sortByAge();
		System.out.println("Person Information After Sorting By DOB Ascending:");
		gnrcMthdDmObj1.printList();
	}
}

[Stephan van Hulst]

GenericMethodDemo has a public constructor. The class is package private.

It's confusing to use 'List' in personList, because it's an array. Write personArray or just persons. The same goes for duplicatePersonList

Why are you suffixing your variables with 'Obj1'? All reference variables refer to objects. It's unnecessary and clutters your code.

Your variable names are cryptic because you are abbreviating them too much. Don't write nmAgeSrtrObj1; write nameAndAgeSorter, or just sorter. Similarly, don't write gnrcMthdDmObj1; write demo.

NameAndAgeSorter implements a raw type. Never use raw types.

The point above about abbreviating goes for getDOB() as well. There's no good reason to abbreviate it. There's plenty of room on modern monitors, the amount of time saved by writing the abbreviation is negligible but it makes code a lot less easy to read.

SortByNameAndAge is a verb phrase. You should use noun phrases for type names. You should call it NameAndAgeSorter instead. The issue is that you already have a class named like that. How do the two relate? The concrete class gives default implementations for the methods declared in the interface. Such a class is called an adapter. Adapters are typically non-final, so that people can override the default behavior. This is what I propose:

interface NameAndAgeSorter<T extends HasName & HasAge> {

  void sortByName(HasName[] array);

  void sortByAge(HasAge[] array);
  
}

class NameAndAgeSorterAdapter<T extends HasName & HasAge> implements NameAndAgeSorter<T> {

  @Override
  public void sortByName(HasName[] array) {
    Arrays.sort(array, new NameComparator());
  }

  @Override
  public void sortByAge(HasAge[] array) {
    Arrays.sort(array, new AgeComparator());
  }
}

Your Person constructor now performs parameter checking, but you can still set a personName and personDOB to null through the setters. Since the Person class is final, you can do parameter checking in your setters, and then just call the setters from the constructor. However, I don't really see a good reason to be able to change a Person's name or age after you've constructed one. You can make Person immutable.

personAge is a bad name for the parameter of setPersonAge(). A LocalDate does not represent an age, it represents a date.

You can use String.format() to easily format strings with multiple variables:

@Override
public String toString() {
  return String.format("Person name: %s; date of birth: %s", name, dateOfBirth);
}

[Winston Gutkowski]

Ganesh Patekar wrote:I apologize for being late, my internet connection was interrupted since last night  
I created comparator for name and age and used with Arrays's sort method.

Yet another possibility is to use the fact that Java enums can implement interfaces. This allows you to create "named" Comparators for a class without having to worry about all that extra "generic" stuff (which I suspect is overkill in your case). Viz:

public class Person {
   public static enum Index
      implements Comparator<Person>
   {
      NAME {
         @Override
         public int compare(Person o1, Person o2) {
            return o1.getName().compareToIgnoreCase(o2.getName());
         }
      ),
      AGE {
         @Override
         public int compare(Person o1, Person o2) {
            return o2.getDOB().compareTo(o1.getDOB());
         }
      );
   }

   // the rest of your Person class
   ...
}

and NOW you can sort an array of people with
  Arrays.sort(people, Person.Index.NAME);

and if you're on version 8, you can use the new API to sort on any combination of "indices" you like, eg:
  Arrays.sort(people, Person.Index.NAME.thenComparing(
     Person.Index.AGE.reverse());

HIH

Winston

PS: I think your AgeComparator is wrong. As DOB gets larger, your age decreases.

[Ganesh Patekar]

@Stephan van Hulst I hope I made changes as you mentioned. I know I'm bit irking you all but please have look once again.

Winston Gutkowski wrote:and if you're on version 8, you can use the new API to sort on any combination of "indices" you like, eg:
 Arrays.sort(people, Person.Index.NAME.thenComparing(
    Person.Index.AGE.reverse());  

That is stream API of Java 8 correct? I need to read about It before applyig here so for time being used sort with enum.
Yes I've seen that sort of enum in JLS 8 Example 8.9.3-3. Enum Constants with Class Bodies.
I created another College class just to see how It works using enum constants with class bodies.

I came across an old thread about making class immutable here  --->link suggested to read Java theory and practice: To mutate or not to mutate? which was really informative so made changes according to that(I hope) in Person class.
Latest Code 2:

package generic;

import java.time.LocalDate;
import java.time.Month;
import java.util.Arrays;
import java.util.Comparator;

interface HasName {
	String getName();
}

interface HasAge {
	LocalDate getDateOfBirth();
}

interface NameAndAgeSorter<T extends HasName & HasAge> {
	void sortByName(HasName[] t);

	void sortByAge(HasAge[] t);
}

final class NameComparator implements Comparator<HasName> {

	@Override
	public int compare(HasName o1, HasName o2) {
		return o1.getName().compareToIgnoreCase(o2.getName());
	}

}

final class AgeComparator implements Comparator<HasAge> {

	@Override
	public int compare(HasAge o1, HasAge o2) {
		return o1.getDateOfBirth().compareTo(o2.getDateOfBirth());
	}

}

/*
 * Immutable class
 */

final class Person implements HasName, HasAge {
	private final String name;
	private final LocalDate dateOfBirth;

	Person(String name, LocalDate dateOfBirth) {

		if (name == null || dateOfBirth == null) {
			throw new NullPointerException("Person's attribute can't be null");
		}

		this.name = name;
		this.dateOfBirth = dateOfBirth;
	}

	@Override
	public String toString() {
		return String.format("Person name: %s; date of birth: %s"
				, name, dateOfBirth);
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public LocalDate getDateOfBirth() {
		return dateOfBirth;
	}

}

/*
 * Immutable class
 */

final class College {
	private final String name;
	private final LocalDate foundationDay;

	static enum Index implements Comparator<College> {
		NAME {

			@Override
			public int compare(College o1, College o2) {
				return o1.getName().compareToIgnoreCase(o2.getName());
			}

		},
		AGE {

			@Override
			public int compare(College o1, College o2) {
				return o1.getFoundationDay().compareTo(o2.getFoundationDay());
			}
		}

	};

	College(String name, LocalDate foundationDay) {

		if (name == null || foundationDay == null) {
			throw new NullPointerException("College's attributes can't be null");
		}
		this.name = name;
		this.foundationDay = foundationDay;
	}

	public String getName() {
		return name;
	}

	public LocalDate getFoundationDay() {
		return foundationDay;
	}

	@Override
	public String toString() {
		return String.format("College Name: %s; Foundation Day: %s"
				, name, foundationDay);
	}

}

/*
 * This is adapter class so non-final
 */
class NameAndAgeSorterAdapter<T extends HasName & HasAge> 
implements NameAndAgeSorter<T> {

	@Override
	public void sortByName(HasName[] array) {
		Arrays.sort(array, new NameComparator());
	}

	@Override
	public void sortByAge(HasAge[] array) {
		Arrays.sort(array, new AgeComparator());
	}
}

final class GenericMethodDemo {

	private final Person[] personArray;
	private final Person[] duplicatePersonArray;
	private final College[] collegeArray;

	GenericMethodDemo() {

		personArray = new Person[] { 
				new Person("Hrithik", LocalDate.of(1987, Month.JULY, 31)),
				new Person("John", LocalDate.of(1980, Month.JANUARY, 15)),
				new Person("Anil", LocalDate.of(1997, Month.SEPTEMBER, 11)) };

		duplicatePersonArray = personArray.clone();

		collegeArray = new College[] { 
				new College("SIOM", LocalDate.of(1992, Month.JANUARY, 1)),
				new College("MIT", LocalDate.of(2000, Month.NOVEMBER, 15)),
				new College("WIT", LocalDate.of(2016, Month.SEPTEMBER, 11)) };
	}

	private void sortByName() {

		NameAndAgeSorterAdapter<Person> sorter 
		= new NameAndAgeSorterAdapter<Person>();
		sorter.sortByName(duplicatePersonArray);
		Arrays.sort(collegeArray, College.Index.NAME);
	}

	private void sortByAge() {

		NameAndAgeSorterAdapter<Person> sorter 
		= new NameAndAgeSorterAdapter<Person>();
		sorter.sortByAge(duplicatePersonArray);
		Arrays.sort(collegeArray, College.Index.AGE);

	}

	private void printArray() {

		for (Person p : duplicatePersonArray) {
			System.out.println(p);
		}

		for (College c : collegeArray) {
			System.out.println(c);
		}

	}

	/*
	 * Below method only for printing original array list
	 */
	private void printOriginalArray() {
		for (Person p : personArray) {
			System.out.println(p);
		}
	}

	public static void main(String[] args) {
		GenericMethodDemo demo = new GenericMethodDemo();
		System.out.println("Before sorting by name:");
		demo.printArray();
		demo.sortByName();
		System.out.println("After sorting by name in ascending order:");
		demo.printArray();
		System.out.println();

		System.out.println("****Sort by bate of birth in ascending order****");
		System.out.println("Before sorting by date of birth:");
		demo.printArray();
		demo.sortByAge();
		System.out.println("After sorting by date of birth in ascending order:");
		demo.printArray();
	}
}

[Stephan van Hulst]

Great job!

Now, I suppose the next thing to realize is that you're never actually using both sorting methods of NameAndAgeSorter in the same place. It was a nice interface to practice with generic type parameters that have disjoint type constraints, but in practice it's not very useful. Let's take this opportunity to introduce some more Java 8 features. We can make the solution more generic:

interface SortingAlgorithm {

  <T> void sort(T[] array, Comparator<? super T> comparator);

  default <T extends Comparable<? super T>> void sort (T[] array) {
    sort(array, Comparator.naturalOrder());
  }
}

You could then implement some standard sorting algorithms:

enum StandardSortingAlgorithm implements SortingAlgorithm {

  JAVA_SORT {
    @Override
    public <T> void sort(T[] array, Comparator<? super T> comparator) {
      Arrays.sort(array, comparator);
    }
  },
  
  BUBBLE_SORT {
    @Override
    public <T> void sort(T[] array, Comparator<? super T> comparator) {
      throw new UnsupportedOperationException("Not implemented yet.");
    }
  },
  
  SELECTION_SORT {
    @Override
    public <T> void sort(T[] array, Comparator<? super T> comparator) {
      throw new UnsupportedOperationException("Not implemented yet.");
    }
  },
  
  INSERTION_SORT {
    @Override
    public <T> void sort(T[] array, Comparator<? super T> comparator) {
      throw new UnsupportedOperationException("Not implemented yet.");
    }
  },
  
  MERGE_SORT {
    @Override
    public <T> void sort(T[] array, Comparator<? super T> comparator) {
      throw new UnsupportedOperationException("Not implemented yet.");
    }
  },
  
  QUICK_SORT {
    @Override
    public <T> void sort(T[] array, Comparator<? super T> comparator) {
      throw new UnsupportedOperationException("Not implemented yet.");
    }
  }
}

If your HasAge trait looks like this:

interface HasAge {
  
  static final Comparator<HasAge> ORDER_BY_AGE = Comparator.comparing(HasAge::getDateOfBirth).reversed();
  
  LocalDate getDateOfBirth();
  
  default Optional<Period> getAgeAt(LocalDate date) {
    LocalDate dateOfBirth = getDateOfBirth();
    
    if (dateOfBirth.isAfter(date))
      return Optional.empty();
    
    return Optional.of(dateOfBirth.until(date));
  }
}

With some static imports, you could then sort an array of persons by age like so:

QUICK_SORT.sort(persons, ORDER_BY_AGE);

[Ganesh Patekar]

I created complete new code for Java 8 feature usage. I'm actually not acquainted with this new feature, yet to read and practice so just tried as per your code.
package algorithms incorporates:

package algorithms;

import java.util.Arrays;
import java.util.Comparator;

interface SortingAlgorithm {

	<T> void sort(T[] array, Comparator<? super T> comparator);

	default <T extends Comparable<? super T>> void sort(T[] array) {
		sort(array, Comparator.naturalOrder());
	}
}

public enum StandardSortingAlgorithms implements SortingAlgorithm {

	JAVA_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			Arrays.sort(array, comparator);
		}
	},

	BUBBLE_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	SELECTION_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	INSERTION_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	MERGE_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	QUICK_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	}
}

package sortusage incorporates:

package sortusage;

import java.time.LocalDate;
import java.time.Period;
import java.util.Comparator;
import java.util.Optional;

final class DateOfBirthComparator implements Comparator<HasAge> {

	@Override
	public int compare(HasAge o1, HasAge o2) {
		return o1.getDateOfBirth().compareTo(o2.getDateOfBirth());
	}

}

interface HasAge {

	static final Comparator<HasAge> ASCENDING_ORDER_BY_DATEOFBIRTH 
	= Comparator.comparing(HasAge::getDateOfBirth)
			.thenComparing(new DateOfBirthComparator());
	static final Comparator<HasAge> REVERSE_ORDER 
	= Comparator.comparing(HasAge::getDateOfBirth).reversed();

	LocalDate getDateOfBirth();

	default Optional<Period> getAgeAt(LocalDate date) {
		LocalDate dateOfBirth = getDateOfBirth();

		if (dateOfBirth.isAfter(date)) {
			return Optional.empty();
		}
		return Optional.of(dateOfBirth.until(date));
	}
}

final class Person implements HasAge {
	private final String name;
	private final LocalDate dateOfBirth;

	Person(String name, LocalDate dateOfBirth) {

		if (name == null || dateOfBirth == null) {
			throw new NullPointerException("Person's attribute can't be null");
		}

		this.name = name;
		this.dateOfBirth = dateOfBirth;
	}

	@Override
	public String toString() {
		return String.format("Person name: %s; date of birth: %s"
				, name, dateOfBirth);
	}

	@Override
	public LocalDate getDateOfBirth() {
		return dateOfBirth;
	}
}

package sortusage;

import java.time.LocalDate;
import java.time.Month;

import static algorithms.StandardSortingAlgorithms.JAVA_SORT;

class AlgorithmDemo {
	private final Person[] personArray;

	AlgorithmDemo() {

		personArray = new Person[] { 
				new Person("Hrithik", LocalDate.of(1987, Month.JULY, 31)),
				new Person("John", LocalDate.of(1980, Month.JANUARY, 15)),
				new Person("Anil", LocalDate.of(1997, Month.SEPTEMBER, 11)) 
				};
	}

	private void AscendingOrderByDateOfBirth() {
		JAVA_SORT.sort(personArray, HasAge.ASCENDING_ORDER_BY_DATEOFBIRTH);

	}

	private void ReverseOrder() {
		JAVA_SORT.sort(personArray, HasAge.REVERSE_ORDER);
	}

	private void printArray() {
		for (Person p : personArray) {
			System.out.println(p);
		}
	}

	public static void main(String[] args) {
		AlgorithmDemo demo = new AlgorithmDemo();
		System.out.println("Before sorting:");
		demo.printArray();
		demo.AscendingOrderByDateOfBirth();
		System.out.println("After sorting by date of birth in ascending order:");
		demo.printArray();
		System.out.println("Reverse order:");
		demo.ReverseOrder();
		demo.printArray();
		System.out.println();
	}
}

[Stephan van Hulst]

Great! The only qualms I have are with the declaration and definition of your sorting orders.

The result of Comparator.comparing(HasAge::getDateOfBirth) is a comparator that will order items according to their date of birth. If you perform thenComparing(new DateOfBirthComparator()), you've created a comparator that will order items according to their date of birth TWICE. The second comparison is useless, so you can leave it out.

Comparator.comparing(HasAge::getDateOfBirth) returns a comparator that does EXACTLY the same thing as DateOfBirthComparator. That means DateOfBirthComparator is redundant, you can delete it.

The following points are a matter of personal taste:

The name HasAge.REVERSE_ORDER is misleading. It implies the reverse of the natural order of things that have an age. But things that have an age don't necessarily have a natural order: What is the natural order of a Person? Why didn't you call it DESCENDING_ORDER_BY_DATEOFBIRTH?

Before we do that though, I would move the ASCENDING/DESCENDING part to the end of the name. That way, these constants will appear close together in JavaDoc.

Finally, I think ORDER_BY_DATEOFBIRTH is less intuitive to use than ORDER_BY_AGE, because people generally are more interested in sorting things by their age then by their date of birth. As Winston remarked earlier, an object's age has the reverse order of their date of birth.

Putting it all together:

static final Comparator<HasAge> ORDER_BY_AGE_ASCENDING  = Comparator.comparing(HasAge::getDateOfBirth).reversed();
static final Comparator<HasAge> ORDER_BY_AGE_DESCENDING = Comparator.comparing(HasAge::getDateOfBirth);

[Stephan van Hulst]

Have a cow for your interest in the topic, and keeping up with it

[Liutauras Vilda]

Have one more cow. You definitely putted lots of effort.

I learned from this topic too, as Java 8 features to me are unexplored field yet.

[Stephan van Hulst]

I just realized I chastised you for using a type called SortByNameAndAge, while recommending types called HasName and HasAge.

I should clarify that the HasSomething naming scheme is often used for interfaces that expose a simple property.

A method like sortByName(HasName[] array) is not a simple property. It does not represent data that belongs to its type. A method like getName() is.

[Ganesh Patekar]

Internet problem episode kept continuing since last afternoon
Oh I see, thank you for informing when an interface should be named like HasSomething. I'm getting lots of information need to document all major points.
Wow this is the first time I'm being rewarded for doing something which I'm suppose to and benifits me,  thank both of you for cows.  

Changes: removed redundant comparator, replaced order by date of birth by order by age, calculated age of person using date of birth and printed so we don't have to see their date of birth to check whether they are sorted correctly or not.

Code 1 with Java 8 feature:

package algorithms incorporates:

package algorithms;

import java.util.Arrays;
import java.util.Comparator;

interface SortingAlgorithm {

	<T> void sort(T[] array, Comparator<? super T> comparator);

	default <T extends Comparable<? super T>> void sort(T[] array) {
		sort(array, Comparator.naturalOrder());
	}
}

public enum StandardSortingAlgorithms implements SortingAlgorithm {

	JAVA_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			Arrays.sort(array, comparator);
		}
	},

	BUBBLE_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	SELECTION_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	INSERTION_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	MERGE_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	},

	QUICK_SORT {
		@Override
		public <T> void sort(T[] array, Comparator<? super T> comparator) {
			throw new UnsupportedOperationException("Not implemented yet.");
		}
	}
}

package sortusage incorporates:

package sortusage;

import java.time.LocalDate;
import java.time.Period;
import java.util.Comparator;
import java.util.Optional;

interface HasAge {
	/*
	 * Returns comparator that imposes reverse ordering 
	 * of this(Natural ordering comparator) comparator
	 */
	static final Comparator<HasAge> ORDER_BY_AGE_ASCENDING 
	= Comparator.comparing(HasAge::getDateOfBirth).reversed();

	// Natural order
	static final Comparator<HasAge> ORDER_BY_AGE_DESCENDING 
	= Comparator.comparing(HasAge::getDateOfBirth);

	LocalDate getDateOfBirth();

	default Optional<Period> getAgeAt(LocalDate date) {
		LocalDate dateOfBirth = getDateOfBirth();

		if (dateOfBirth.isAfter(date)) {
			return Optional.empty();
		}
		return Optional.of(dateOfBirth.until(date));
	}
}

final class Person implements HasAge {
	private final String name;
	private final LocalDate dateOfBirth;

	Person(String name, LocalDate dateOfBirth) {

		if (name == null || dateOfBirth == null) {
			throw new NullPointerException("Person's attribute can't be null");
		}

		this.name = name;
		this.dateOfBirth = dateOfBirth;
	}

	@Override
	public String toString() {
		return String.format("Person name: %s; date of birth: %s; "
				+ "Age: %s", name, dateOfBirth,
				Period.between(dateOfBirth, LocalDate.now()).getYears());
	}

	@Override
	public LocalDate getDateOfBirth() {
		return dateOfBirth;
	}
}

package sortusage;

import java.time.LocalDate;
import java.time.Month;

import static algorithms.StandardSortingAlgorithms.JAVA_SORT;

class AlgorithmDemo {
	private final Person[] personArray;

	AlgorithmDemo() {

		personArray = new Person[] { 
				new Person("Hrithik", LocalDate.of(1987, Month.JULY, 31)),
				new Person("John", LocalDate.of(1980, Month.JANUARY, 15)),
				new Person("Anil", LocalDate.of(1997, Month.SEPTEMBER, 11)) 
				};
	}

	private void orderByAgeAscending() {
		JAVA_SORT.sort(personArray, HasAge.ORDER_BY_AGE_ASCENDING);

	}

	private void orderByAgeDescending() {
		JAVA_SORT.sort(personArray, HasAge.ORDER_BY_AGE_DESCENDING);
	}

	private void printArray() {
		for (Person p : personArray) {
			System.out.println(p);
		}
	}

	public static void main(String[] args) {
		AlgorithmDemo demo = new AlgorithmDemo();
		System.out.println("Before sorting:");
		demo.printArray();
		demo.orderByAgeAscending();
		System.out.println("Order by age ascending:");
		demo.printArray();
		System.out.println("Order by age descending:");
		demo.orderByAgeDescending();
		demo.printArray();
		System.out.println();
	}
}

Output:
Before sorting:
Person name: Hrithik; date of birth: 1987-07-31; Age: 29
Person name: John; date of birth: 1980-01-15; Age: 36
Person name: Anil; date of birth: 1997-09-11; Age: 18

Order by age ascending:
Person name: Anil; date of birth: 1997-09-11; Age: 18
Person name: Hrithik; date of birth: 1987-07-31; Age: 29
Person name: John; date of birth: 1980-01-15; Age: 36

Order by age descending:
Person name: John; date of birth: 1980-01-15; Age: 36
Person name: Hrithik; date of birth: 1987-07-31; Age: 29
Person name: Anil; date of birth: 1997-09-11; Age: 18

[Ganesh Patekar]

I wrote a class having a method for Bubble sorting but not getting how to invoke It from enum here

BUBBLE_SORT {
        @Override
        public <T> void sort(T[] array, Comparator<? super T> comparator) {
            throw new UnsupportedOperationException("Not implemented yet.");
            // BubbleSorter.bubleSort(array);  like this ?
        }
    }

Should I invoke this method where throw new statement is(I mean replacing throw new)? in above BUBBLE_SORT element of enum? I'll put this BubbleSorter in package algorithms.
I read how bubble sort works on Bubble Sort Wiki and tried to implement in code. Is It good code for bubble sorting Or should I improve?

Bubble sort code 1:

class BubbleSorter {

	 static void swap(int array[], int i, int j) {
		int temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}

	static void bubleSort(int[] array) {

		int i = 0;
		int j = 0;
		int count = 0;
		boolean hasChanged = false;
		while (count < array.length) {
			i = 0;
			j = i + 1;
			hasChanged = false;
			while (j < array.length) {
				if (array[i] > array[j]) {
					System.out.println(array[i] + " <==>" + array[j]);
					swap(array, i, j);
					hasChanged = true;
				}
				i = j;
				j++;
			}
			count++;
			if (!hasChanged) {
				break;
			}
		}
	}
}

[Stephan van Hulst]

Ganesh Patekar wrote:

/*
 * Returns comparator that imposes reverse ordering 
 * of this(Natural ordering comparator) comparator
 */
static final Comparator<HasAge> ORDER_BY_AGE_ASCENDING 
= Comparator.comparing(HasAge::getDateOfBirth).reversed();

// Natural order
static final Comparator<HasAge> ORDER_BY_AGE_DESCENDING 
= Comparator.comparing(HasAge::getDateOfBirth);

These comments are incorrect. These comparators don't compare by natural order. They compare by natural order of dates of birth.

Ganesh Patekar wrote:

@Override
public String toString() {
	return String.format("Person name: %s; date of birth: %s; "
			+ "Age: %s", name, dateOfBirth,
			Period.between(dateOfBirth, LocalDate.now()).getYears());
}

You don't need to use Period.between(). HasAge already has a method you can use: getAgeAt().

@Override
public String toString() {
  return String.format("Person name: %1$s; date of birth: %2$td %2$tB, %2$tY; current age: %3$d years",
    name,
    dateOfBirth,
    getAgeAt(now()).map(Period::getYears).orElse(0)
  );
}

[Stephan van Hulst]

Ganesh Patekar wrote:Should I invoke this method where throw new statement is(I mean replacing throw new)? in above BUBBLE_SORT element of enum? I'll put this BubbleSorter in package algorithms.

Yes, you should replace the throw statement. However, you can't just call your sorting algorithm like that, because it sorts int arrays, and you want to sort T arrays.

[Ganesh Patekar]

Stephan van Hulst wrote:These comments are incorrect. These comparators don't compare by natural order. They compare by natural order of dates of birth.

Yes I meant the same but didn't write by natural order of date of birth just to express common meaning of that.

Stephan van Hulst wrote:You don't need to use Period.between(). HasAge already has a method you can use: getAgeAt().

Ohh! I was wondering why we had default method in that interface.

Stephan van Hulst wrote:Yes, you should replace the throw statement. However, you can't just call your sorting algorithm like that, because it sorts int arrays, and you want to sort T arrays.

Ehh, didn't notice, yes It's T[] not int[]. Anyway I will try all these stuff later since I need to pay attention on basic core, once I finish those will definitely come to this again for sure. Because all these generic concepts are really interesting.

[Winston Gutkowski]

Ganesh Patekar wrote:That is stream API of Java 8 correct?

No, but the new Comparator API uses functional interfaces, which are a parallel development. In fact, Comparator itself IS a functional interface now.

The only other thing I'd say is that different sort algorithms tend to have different strengths, so many modern routines use them in combination, based on things like size or "sortedness".

Insertion sort, for example, works extremely well when a dataset is small or "mostly sorted" - far better than many supposedly "better" algorithms - but, of course, has a horrible worst case (O(n²). This makes it great as a "secondary algorithm" to use in conjunction with things like quicksort and mergesort.

BTW, there's a relatively new "low-write" quadratic sort called Cycle sort that might interest you.

Winston

[Ganesh Patekar]

Winston Gutkowski wrote:No, but the new Comparator API uses functional interfaces, which are a parallel development. In fact, Comparator itself IS a functional interface now.

Oh I see, yes I'm yet to study algorithms (Had done before but long time ago so need to revise) and their performance in different situations so I can understand which algorithm is good to use in which situation. Also about different list frameworks performance in different operations like search, delete etc. Thank you for Cycle sort link