[simman92]

Hi. this is my first post so please forgive me for errors.

I have made a Bubble Sort for ints.
my next step is to make my Bubble Sort
more sophisticated by making it work
for a generic array. I have to write a
test program for my method using arrays
with these three data types: Double, Character, and String.

so far i have

 
public class Sort {


	public static void main(String[] args) {
		int array[] = { 23, 12, 466, 22,1,2,3,4,56,2,6,4 };
		int temp;
		for (int i = 0; i < array.length -1; i++) {
			for (int j = 0; j < (array.length-1) - i; j++) {
				if (array[j + 1] < array[j]) {
					temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
		System.out.println("Sorted Array");
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
		
	}

}

thanks in advance for all help!

[CasiOo]

Why not just make a method which accepts an array of type Object? You do not need to know the exact type when doing a bubblesort

public void bubblesort(Object[] array) {

edit: yeah has to be Compareable instead of Object as they pointed out

This post has been edited by CasiOo: 06 December 2012 - 01:26 PM

[macosxnerd101]

That's a bad idea, because you won't know that the elements are mutually Comparable. Use generics here instead:

public <T extends Comparable<? super T>> void bubblesort(T[] elements){}

[pbl]

You can't have generic array of basic datatype in Java
If it is an array of Object like (Integer, Character, Doubkle, Float, ...) you can simply declare the tyupe of the array as Comparable in the method parameter

void sort(Comparable[] array) {

[macosxnerd101]

Quote

void sort(Comparable[] array) {

That still won't ensure that all the elements can be compared to each other. It is quite possible to run into something like a ClassCastException should that be the case.

[pbl]

Mac,
How can you call, at compilation time, a method sort(Comparable[] array)
with an array of Object that do not implement Comparable ?

May be an element might be null, ok we are better to test it within the sort

[macosxnerd101]

As proof of concept. Notice how comparing Apples and Oranges crashes at runtime, but it is fine to store the two in the array. Sorting relies on comparisons, so the problem should be clear. Whereas if you use methods to enforce that the elements are mutually Comparable, you won't run into the problem of worrying about comparisons causing a crash (because of type) during runtime.

package test;


class Apple implements Comparable<Apple>{
    
    public Apple(){}
    
    public int compareTo(Apple other) {
        return 0;
    }

}

class Orange implements Comparable<Orange>{
    
    public Orange(){}
    
    public int compareTo(Orange other){
        return 0;
    }
}

class Test{

    private Comparable[] array;
    
    public Test(){
        array = new Comparable[2];
        array[0] = new Apple();
        array[1] = new Orange();
        
        array[0].compareTo(array[1]); //fails with ClassCastException
        compare(array[0], array[1]); //fails with ClassCastException
        compare(array[0], new Apple());
    }
    
    public <T extends Comparable<? super T>> int compare(T one, T two){
        return one.compareTo(two);
    }
    
    public static void main(String[] args){
        new Test();
    }
    
}

[pbl]

Ha... I see what you mean...
You shouldn't send an array opf Comparable to the sort() method but an array of Orange or an Array of Apple

How can you compare Orange with Apple ? Good thing Java crashes if you try to do so

Good show anyhow