Generische ArrayList, CastProblem

[Lybrial]

Hallo Leute,

sitze nun seid einigen Stunden an einem Problem.
Habe mir eine eigene generische Array-List geschrieben in die ich nun einige Werte stecke,
die ich sortieren möchte. Beim ausführen bekomme ich allerdings immer folgende Exeption und
ich weiß nicht warum:


Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
at Uebung_05.ArrayList.getArray(ArrayList.java:178)
at Uebung_05.ArrayList.add(ArrayList.java:30)
at Uebung_05.Test.main(Test.java:8)

Die ArrayList:

public class ArrayList<T extends Comparable<T>> extends AlgDatContainer<T>{
	private int mLastIndex;
	private Object[] mArray;
	//*****Konstruktor***********************
	public ArrayList(){
		this(new Object[42]);
	}
	//*****Konstruktor***********************
	public ArrayList(int aSize){
		setArray(new Object[aSize]);
		setLastIndex(0);
	}
	//*****Konstruktor***********************
	public ArrayList(Object[] aArray){
		setArray(aArray);
		setLastIndex(aArray.length);
	}
	//*********************************************************************
	public int quantity(){
		return getLastIndex();
	}
	//*********************************************************************
	public void add(T aObject){
		if(getLastIndex() == getArray().length){
			arrayGrow();
		}
		getArray()[getLastIndex()] = aObject;
		mLastIndex++;
	}
	//*********************************************************************
	public T objectAtIndex(int aIndex){
		return getArray()[aIndex];
	}
	//*********************************************************************
	public boolean addObjectAtIndex(int aIndex, T aObject){
		if(aIndex >= 0 && aIndex <= quantity()){
			if(getLastIndex() == getArray().length){
				arrayGrow();
			}
			for(int i = getLastIndex(); i > aIndex; i--){
				getArray()[i] = getArray()[i-1];
			}
			getArray()[aIndex] = aObject;
			return true;
		}
		else
			return false;
	}
	//*********************************************************************
	public boolean deleteObjectAtIndex(int aIndex){
		if(aIndex >= 0 && aIndex <= quantity()){
			for(int i = aIndex; i < getLastIndex()-1; i++){
				getArray()[i] = getArray()[i+1];
			}
			mLastIndex--;
			getArray()[getLastIndex()] = null;
			return true;
		}
		else
			return false;
	}
	//*********************************************************************
	public int deleteObject(T aObject){
		int count = 0;
		for(int i = 0; i < getArray().length; i++){
			if(getArray()[i] == aObject){
				deleteObjectAtIndex(i);
				count++;
			}
		}
		return count;
	}
	//*********************************************************************
	public boolean isInArray(T aObject){
		for(int i = 0; i < getLastIndex(); i++){
			if(getArray()[i] == aObject){
				return true;
			}
		}
		return false;
	}
	//*********************************************************************
	private void arrayGrow(){
		Object vArray[] = new Object[getArray().length*2];
		for(int i = 0; i < getArray().length; i++){
			vArray[i] = getArray()[i];
		}
		setArray(vArray);
	}
	//*********************************************************************
	public void insertionSort(){
		for(int i = 1; i < getLastIndex(); i++){
			int pos = binarySearch(0, i, getArray()[i]);
			T temp = getArray()[i];
			
			for(int j = i; j > pos; j--){
				getArray()[j] = getArray()[j-1];
			}
			getArray()[pos] = temp;
		}
	}
	//*********************************************************************
	public void shellSort(){
		int[] spalten = {2147483647, 1131376761, 410151271, 157840433,
			    58548857, 21521774, 8810089, 3501671, 1355339, 543749, 213331,
			    84801, 27901, 11969, 4711, 1968, 815, 271, 111, 41, 13, 4, 1}; 			
		
		for(int step : spalten){              											
			for(int j = step; j < getLastIndex(); j++){     							
				T toMove = getArray()[j];           										
				int k = j;                         										
			    while(k >= step && toMove.compareTo(getArray()[k-step]) < 0){   		
			    	getArray()[k] = getArray()[k-step];
			        k = k - step;
			    }
			    	getArray()[k] = toMove;                						
			}
		}
	}
	//*********************************************************************
	public void bubbleSort(){
		for(int i = getLastIndex()-1; i > 0; i--){
	        for(int j = 0 ; j < i; j++){
	            if(getArray()[j].compareTo(getArray()[j+1]) > 0) {
	            	T temp = getArray()[j];
	                getArray()[j] = getArray()[j+1];
	                getArray()[j+1] = temp;
	            }
	        }
	    }
	}
	//*********************************************************************
	public void straightSelectionSort(){
        int lowest = 0;
        T temp;
        for(int i = 0; i < getLastIndex(); i++){
            for(int j = i; j < getLastIndex(); j++) {
                if(getArray()[lowest].compareTo(getArray()[j]) > 0){
                    lowest = j;
                }
            }
            if(lowest != i){
            	temp = getArray()[i];
            	getArray()[i] = getArray()[lowest];
            	getArray()[lowest] = temp;
            }
            lowest = i+1;
        }
    }
	//*********************************************************************
	private int binarySearch(int left, int right, T aObject){
		int mid = (left+right)/2;
		if(left > right){
			return left;
		}
		else if(getArray()[mid].equals(aObject)){
			return mid;
		}
		else if(getArray()[mid].compareTo(aObject) > 0){
			return binarySearch(left, mid-1, aObject);
		}
		else{
			return binarySearch(mid+1, right, aObject);
		}
	}
	//*********************************************************************
	public int getLastIndex(){
		return mLastIndex;
	}
	private void setLastIndex(int mLastIndex){
		this.mLastIndex = mLastIndex;
	}
	public T[] getArray(){
		return (T[])mArray;
	}
	private void setArray(Object[] mArray){
		this.mArray = mArray;
	}
}

Der Container:

public abstract class AlgDatContainer <T>{
	public abstract int quantity();
	public abstract void add(T aObject);
	public abstract T objectAtIndex(int aIndex);
	public abstract boolean addObjectAtIndex(int aIndex, T aObject);
	public abstract boolean deleteObjectAtIndex(int aIndex);
	public abstract int deleteObject(T aObject);
	public abstract boolean isInArray(T aObject);
}

Die Testklasse:

public class Test {
	public static void main(String []args){
        String[] strAr = {"Carolin", "Marc", "Christian", "Ronja", "Micha", "Alex" };
		ArrayList<String> ar = new ArrayList<String>(strAr);

		ar.add("Michael");
		ar.add("Bob");
		ar.add("Tom");
		ar.add("Jerry");
		ar.add("Butch");
		ar.add("Spike");
		ar.add("Mutter");

		for(int i = 0; i < ar.getArray().length; i++){
			System.out.println(ar.getArray()[i]);
		}
		System.out.println("*********************************");
		System.out.println("*********************************");
		ar.bubbleSort();
		for(int i = 0; i < ar.getArray().length; i++){
			System.out.println(ar.getArray()[i]);
		}
	}
}

Wo liegt das Cast Problem und wie kann ich es verhindern?

Danke im vorraus

 

[SlaterB]

du hast ein Object[] und Java will das auf Comparable casten, weil soviel von T auch zur Laufzeit bekannt ist,
verwende doch ein Comparable[]

 

[Lybrial]

Habs mittlerweile:

Mit Comparable passt alles

Bei den Casts muss man aufpassen. Ein Cast des Arrays, also ein Cast (T[])mArray, casted natürlich nicht die Inhalte des Array sondern nur die Referenz auf das Array, ein kleiner aber feiner Unterschied.
Einfach ausgedrückt:
*) mArray muss ein Object[] Array sein (alles ist ein Object!)
*) Wenn man ein Element reinsteckt, wird daraus eine Instanz der Klasse Object
*) Wenn ein Element aus mArray rausholt, ist man dafür verantwortlich dass:
1) Der Cast auf (T) gemacht wird
2) Das was man rausholt auch wirklich eine Instanz der Klasse T ist.