Generic arraylist bubblesort problems

Question

I know there are builtin routines, but as a learner, I want to sort using my own devices, and since sorting is old hat, I decided to try to make my own generic sort routine that I could use for numbers or strings and maybe even dates, if I ever figure out how they work in Java.

So here's what I have, having traded one error for another for another until now I only have errors in two places (enclosed within "**" markers), with need to figure out how to compare.

package sort;
import java.util.ArrayList;

public  abstract class Sort<E> implements Comparable<E> {

   public void swap(ArrayList<E> a, int i, int j) {
    E c = a.get(i);
    a.set(i,a.get(j));// = a[j];
    a.set(j, c);
  }

  public void bubbleSort(ArrayList<E> a) {
    boolean inOrder = false;
    while (!inOrder) {
      inOrder = true;
      for (int i = 1; i < a.size(); i++) {
        **if( a.get(i - 1).compareTo(a.get(i)) > 0 )** {
//cannot find symbol: method compareTo(E); location: class Object
//where E is a type-variable: E extends Object declared in class Sort                 
      inOrder = false;
          swap(a, i, i - 1);
        } 
      }
    }
  }

  public static void main(String args[]) //hadda lose 'static' for 'setLayout' to work
  {
    ArrayList<Integer> ary = new ArrayList<>();
    ary.add(2); ary.add(4); ary.add(7); ary.add(3);
    **bubbleSort(ary)**;
//method bubbleSort in class Sort<E> cannot be applied to given types; 
//required: ArrayList<E>
//found: ArrayList<Integer>
//reason: actual argument ArrayList<Integer> cannot be converted to ArrayList<E> 
//by method invocation conversion where E is a type-variable:
//E extends Object declared in class Sort
    for (int i = 0; i < ary.size(); i++) {
      System.out.println(ary.get(i));
    }
  }

  @Override
  public int compareTo(E o) {
    **return 0;** // fixing errors above may help this fall into place
  }
}

I'm trying to learn things that I feel ready for only to find that I'm not quite ready; close, cigarless.

Answer 1

This:

public  abstract class Sort<E> implements Comparable<E> {

means that E is an arbitrary object type, and that instances of Sort<E> can be compared to instances of E. (So your error message is complaining that E.compareTo doesn't exist, since Object doesn't have such a method.) What you want is this:

public abstract class Sort<E extends Comparable<E>> {

which means that E must be a type whose instances can be compared to each other.

---

Edited to add: Actually, as SLaks together point out, there's no real reason for Sort to be generic; you just need the bubbleSort method to be generic. Further, as MadProgrammer implies, either Sort should be non-abstract (so you can instantiate it directly) or bubbleSort should be static (so it can be called without instantiating a Sort instance) or both. For example:

public class Sort {
    private static <E> void swap(ArrayList<E> a, int i, int j) {
        ...
    }

    private static <E extends Comparable<E>> void bubbleSort(ArrayList<E> a) {
        ...
    }

    ...
}

Better yet, Sort can be an interface with a sort method, and BubbleSort.sort(...) is just an implementation of it (rather than giving Sort a specific bubbleSort method).

Answer 2

I'd like to just make a comment, if I may.

Learning BubbleSort is a fine way to learn how to use data structures in Java. I agree with the others that, in the real world, you will never use BubbleSort because it offers the worst performance of any sorting algorithm with the exception of "StoogeSort".

Still, there is value in going through the exercize as a new learner if it teaches you how to do important things like use and apply a generic type parameter, work with control-flow statements (e.g. for loops), and even do exception handling. Don't listen to the naysayers. The principle advantage of Bubblesort is that the algorithm is simple.

In my view, an even simpler sorting algorithm is the "Delayed Replacement Sort" also known as the "Selection Sort". The Delayed Replacement Sort has the same bad time complexity as BubbleSort (O(n^2)) but unlike BubbleSort, Selection Sorting is still used in certain applications. It is incorporated as a subalgorithm in some optimized sorting algorithms, and because it minimizes the number of swaps needed to order the collection, Selection Sort is still used when the cost of performing a swap is high.

The pseudocode for the Delayed Replacement Sort follows and is, in my opinion, even simpler than BubbleSort:

Begin DELAYEDSORT
 For ITEM=1 to maximum number of items in list-1
    LOWEST=ITEM
    For N=ITEM+1 to maximum number of items in list
       Is entry at position N lower than entry at position LOWEST?
          If so, LOWEST=N
    Next N
    Is ITEM different from LOWEST
       If so, swap entry at LOWEST with entry in ITEM
 Next ITEM
End DELAYEDSORT

The Delayed Replacement Sort can be as much as 50% faster than BubbleSort but still should not be used to sort very large collections.

Answer 3

After taking SLaks' advice and becoming much more familiar with generics (made generic stack and queue classes yesterday), today I used ruakh's outline (but had to change private to public in "bubblesort" line) which enabled majorly changing main to something sane (which now boils down to one do-something-useful line Sort.bubbleSort(ary);) and it worked, but I have two burning questions:

(1) What exactly does the first <E> mean/do/imply in this line:

private static <E> void swap(ArrayList<E> a, int i, int j) {

(2) Similarly... what's up with <E extends Comparable<E>> here:

private static <E extends Comparable<E>> void bubbleSort(ArrayList<E> a) {

To answer my own question, "Now, why didn't I think of those?"... "Why WOULD I think of them??"

EDIT: "parameterized" or "generic" methods are as legal as parameterized/generic types, and why not?

But I still don't know why, "obviously legal" or not, I'd have thought of either "trick".

EDIT: One word: experience