Problema con Iteratore

[javacomelava]

Salve ragazzi.

Ho implementato una classe: CollezioneDiOrdinabili (che vuole rappresentare e gestire delle collezioni che siano formate di soli oggetti Ordinabili):

import java.util.*;

public class CollezioneOrdinabili{
	
	private Ordinabile[] elem;
	
	public CollezioneOrdinabili(int n){
		if(n<=0)System.out.println("ERRORE: parametro errato!!!\n");
		elem=new Ordinabile[n];	
	}

       

        public boolean inserisci(Ordinabile X){
		Class C=null;
		boolean ins=false;
		if(elem[0]==null)
			elem[0]=X;
		else{
			C=X.getClass();
			for(int i=1;i<elem.length && ins==false;i++){
				if(elem[i]==null && C.isInstance(elem[0])){
					elem[i]=X;
					ins=true;
				}
			}
		}
		return ins;
	}


         public String toString(){
		String header="\nCOLLEZIONE DI ORDINABILI:\n";
		String temp="";
		String fine="";
		for(int i=0;i<elem.length;i++){
			if(elem[i]!=null){
				temp=elem[i].toString();
				fine=fine+temp;
			}
		}
		header=header+fine;
		return header;
	}

Per fare ciò ho creato una interfaccia Ordinabile:

public interface Ordinabile{

	boolean maggioreDi(Ordinabile X);
	
}

Ho creato quindi una mia classe "stupida" che implementi l'interfaccia Ordinabile:

public class MiaStringa implements Ordinabile{
	
	private String str;
	
	public MiaStringa(String s){
		str=s;
	}
	
	public String getStringa(){
		return str;
	}
	
	public String toString(){
		String ris="\nSTRINGA: "+this.getStringa()+"\n";
		return ris;
	}
	
        /** this è maggiore di X se length() di this > length di X */
	public boolean maggioreDi(Ordinabile X){
		boolean md=false;
		if(X instanceof MiaStringa){
			int lung_this=this.getStringa().length();
			int lung_X=((MiaStringa)X).getStringa().length();
			if(lung_this>lung_X)
				md=true;
			}
		return md;
	}
}

Fin qui tutto bene.
Ho deciso poi di voler implementare all'interno di CollezioneDiOrdinabili un ITERATORE che mi restituisse gli elementi della collezione ORDINATAMENTE.
Ed è qui che sono andato nel pallone....non ci riesco...

private class MioIteratore implements Iterator{
		
		private int min;
		
		public MioIteratore(){
			if(elem[0]==null)throw new FailureException("ERRORE:                   collezione vuota!!!\n");
			Ordinabile pic=elem[0];
			min=0;
			for(int i=0;i<elem.length;i++){
				if(elem[i]!=null && (!(elem[i].maggioreDi(pic)))){
					pic=elem[i];
					min=i;
				}
			}
		}
		
		public Object next(){
			return elem[min];
		}
		
		public boolean hasNext(){
			boolean b=false;
			for(int i=0;i<elem.length && b==false ;i++){
				if(elem[i].maggioreDi(elem[min]))
					b=true;
				}
			return b;
		}	
			
		public void remove(){
                
                }

Praticamente l'ho pensata cosi:

l'iteratore ha una variabile d'istanza che rappresenta il minimo.
Quindi il costruttore dell'iteratore inizializza la var d'istanza assegnandogli l'indice del'array dov'e' contenuto il minimo.

next() restituisce semplicemtente il minimo attuale.
hasNext() controlla se all'interno dell'array c'e' un valore maggiore del minimo.ciò significherebbe che quel valore ancora non è stato considerato e quindi hasNext() restituisce true.

remove() mi sta facendo impazzire!!! Io l'ho pensata cosi:
dovrebbe cercare nell'array il VALORE PIU PICCOLO TRA GLI ELEMENTI CHE SIANO ALLO STESSO TEMPO ANCHE MAGGIORI DEL MINIMO ATTUALE.Ma come fare questa cosa??? ci ho scapocciato per tutto il giorno....ma sono sommerso da loop infiniti.....

Spero qualcuno riesca ad aiutarmi....alla fine sono sicuro che sto impazzendo per qualche stupidaggine.

SAluti e grazie per l'aiuto!

[andbin]

No alt ... partiamo dall'inizio. Innanzitutto la tua collezione è basata su un array a capacità prefissata e la collezione non è quindi espandibile. Va bene, non è questo il problema. Vedo che in inserisci() fai una cosa particolare: il primo elemento ti serve per capire se gli altri aggiunti dopo sono dello stesso identico tipo. Oltre che essere più lungo il codice è anche fin troppo restrittivo! Nelle collezioni del framework le cose non sono gestite così: se si vuole ordinare una collezione (solo List, chiaramente) allora tutti gli elementi devono essere "mutualmente" comparabili. Ma questo non è rafforzato/controllato da alcun test!! Se due elementi nel List non sono mutualmente comparabili, sbucherà fuori una eccezione ClassCastException al primo confronto non appropriato.

Ora .... perché devi complicarti la vita??

Passiamo all'iteratore: tu vuoi che faccia delle ricerche con una logica un po' particolari. Ma un iteratore dovrebbe solo iterare e basta, secondo l'ordine dettato dalla implementazione della collezione. Ora ... la tua collezione non mi sembra "sorted" ovvero mantenuta ordinata internamente in base al contenuto degli elementi.
E .... quindi???

[javacomelava]

ciao a grazie per la risposta.

Per il discorso sul primo punto sono d'accordo con te...ma questo è solo un "ESEMPIO GIOCATTOLO" per preparare un'esame.Sono sicuro che per implementare qualcosa di SOCIALMENTE UTILE ci voglia ben altro che queste due righe di codice.

Passiamo al seocndo punto:
Sempre a scopo PURAMENTE DIDATTICO,mi sono chiesto come poter implementare un iteratore in modo che iterasse sulla collezione in modo da restituirmi i suoi elementi in modo ordinato.

Una persona normale mi direbbe: Scusa,ma fatti un bel metodo che implementi un algoritmo qualsiasi di ordinamento,ordina gli elementi e poi iteri normalmente.

Però il mio scopo non era ordinare l'array....bensi cercare di DARE UN CERTO COMPORTAMENTO all'iteratore per imparare meglio a gestirli e farci pratica.E infatti ci sto scapocciando da un bel pò .... spero di essermi spiegato

[andbin]

Originariamente inviato da javacomelava
Sempre a scopo PURAMENTE DIDATTICO,mi sono chiesto come poter implementare un iteratore in modo che iterasse sulla collezione in modo da restituirmi i suoi elementi in modo ordinato.

Il punto è proprio qui. La tua collezione non è sorted (mantenuta internamente ordinata) mentre invece vorresti che sia l'iteratore a fornire l'ordine.

L'iteratore però non dovrebbe avere alcuna "logica" di ordinamento. Dovrebbe solo iterare e basta!

Se vuoi proprio fargli fare un ordinamento, nell'iteratore fai una copia dell'array, ordinalo e itera su quello.
Altro discorso se volessi rendere la tua collezione "sorted" ovvero mantenuta ordinata internamente. Questo vorrebbe dire che in inserisci() ci dovrebbe essere la logica che stabilisce dove l'elemento deve essere inserito affinchè la collezione resti ordinata.

Se tenti di realizzare l'iteratore come stavi facendo, cioè tra gli N elementi sparpagliati non in ordine cercare qua e là gli elementi secondo l'ordine .... rischi solo di: a) farti venire mal di testa b) scrivere molto codice c) farlo poco efficiente.
Se ti dico i numeri 5 3 7 2, capisci subito che devi prendere prima il quarto, poi il secondo, poi il primo e infine il terzo. Ma per fare questo dovresti tenere traccia di questo "percorso", magari eliminando l'elemento appena trovato in modo da non prenderlo più. E oltretutto dovresti scansionare molte volte la lista (=inefficiente).

[javacomelava]

Teoricamente hai perfettamente ragione,e anche io mi sono posto la tua stessa domanda...."Ma che senso ha????".Però come ti ho detto sono esercizi di preparazione di un esame...e lei vuole questo.Quindi tocca trovare una soluzione valida per farla felice.

P.S.: ed io non la riesco a trovare :|