Array,chiarimento dubbi e incertezze

[Trebottoni]

Salve a tutti sono nuovo di questo forum e del mondo di java;
sto affrontando un progetto per l'università,e sono qui per chiedervi alcuni chiarimenti.

Mi trovo ad un punto nel progetto in cui devo creare un array contenente 4536 combinazioni.I numeri partono da 1023 e terminano a 9877(1023<=x<9876),escluse quelle combinazioni in cui i numeri iniziano per 0 e quelle in cui i numeri si ripetono (es 0567,4388,0033..). Quindi escludendo queste tipologie di numeri,ottengo 4536 combinazioni accettate(es 1023,1024....9876).
La parte di codice che esclude queste combinazioni l'ho scritta,ora devo metterla all'interno dell'array,ma prima devo risolvere un piccolo problema che vi esporrò.

I numeri non vanno letti come decimali,ma come "singoli" ovvero 1023-->uno zero due tre e NON milleventitre. Perchè sono delle combinazioni di numeri singoli,ma questo credo che a java importi poco e niente se il programma è scritto correttamente.

Ora dovendomi creare questo array ho trovato subito una difficoltà. Ipotizzando,per semplificare le cose e lavorando con numeri piccoli,di avere solo 20 elementi nel mio array,voglio inserire al suo interno dei numeri che vanno da 10 a 29(quindi 20 elementi).

Ho scritto queste linee di codice:

public class Main
{
public static void main(String[] args)
{
int[] maxnumeri=new int[20];
for(int i=10;i<=maxnumeri.length;i++)
{
System.out.println("x["+i+"]");
}
}


in teoria(secondo me) dovrebbe cominciare ad inserire partendo dal 10, un totale di 20 elementi. Quindi dovrebbe scrivere 10,11,12...29. Invece scrive da 10,11,12..19.

Sarei grato se qualcuno mi spiegasse dove sbaglio..
Ovviamente il mio scopo è creare l'array più grande per il progetto ma dato che ho difficoltà con numeri piccoli e non capisco il funzionamneto,gradirei avere una spiegazione prima di cimentarmi con l'altro array.

Grazie per leventuale aiuto

[andbin]

Originariamente inviato da Trebottoni
I numeri non vanno letti come decimali,ma come "singoli" ovvero 1023-->uno zero due tre e NON milleventitre. Perchè sono delle combinazioni di numeri singoli,ma questo credo che a java importi poco e niente se il programma è scritto correttamente.

Se non devi trattarli come numeri "interi" ovvero appunto es. non milleventitre ma come 4 cifre 1, 0, 2, 3 allora non necessariamente devi usare 1 int.

Una combinazione la puoi "modellare" con: 1) un array di 4 byte (dico byte perché se il valore è 0...9 va bene e non spreca spazio) o 2) un oggetto di una tua classe (es. Combinazione) che contiene le 4 cifre (anche qui come byte, ad esempio).

A quel punto fai un array esattamente di 4536 riferimenti ad array o oggetti Combinazione. Tra array e oggetto, è meglio l'oggetto di una tua classe, perché puoi ridefinire il concetto di uguaglianza (metodo equals), il toString e mettere altro che ti serve per gestire la combinazione.

[Trebottoni]

ok,grazie per la risposta;
vedrò se ne sono capace,posterò eventuali(probabili) difficoltà.
Altre idee/aiuti sono ben accetti..sul codice che ho postato magari..

[VincenzoTheBest]

Ti propongo un esempio di impostazione che ho pensato per il tuo problema; si tratta soprattutto di una alternativa allo spezzone di codice che hai proposto.
Ti resta solo pensare come generare le combinazioni.

/**
 * @(#)MainComb.java
 *
 *
 * @author Vincenzo
 * @version 1.00 2010/11/15
 */

public class MainComb {
    
    private final Integer NUM_DEC = 10;
    private Integer bottom;
    private Integer up;
    private boolean escludiCombConZeroNonSign;
    private int totaleCombinazioni;
    private int combinazioni[];
    
    public MainComb(Integer bottom, Integer up, boolean escludi){
    	this.bottom = bottom;
    	this.up = up;
    	escludiCombConZeroNonSign = escludi;
    	totaleCombinazioni = getTotal();
    	combinazioni = new int[totaleCombinazioni - 1];
    }
    
    /*
     * D(n, k) = n(n-1) .. (n-k+1)
     */
    private int getNumCombSenzaRip(){
    	int ret, i, last;
    	last =  NUM_DEC - bottom.toString().length() + 1;
    	ret = i = NUM_DEC;
    	while(i > last){
    		ret *= --i;
    	}
    	if(escludiCombConZeroNonSign)
    		ret -= ret / NUM_DEC;
    	return ret;
    }
    
    /*
     * Le combinazioni di interi sono limitate
     * ad un intervallo.
     * Es: 1023 <= x < 9876, dove x è una combinazione di interi
     */
    private int getTotal(){
    	int numComb = getNumCombSenzaRip();
    	int maxDec = 9;
    	int maxComb = Integer.valueOf(up.toString().substring(0, 1));
    	while( maxDec > maxComb){
    		numComb -= NUM_DEC-1;
    		maxDec--;
    	}
    	return numComb;
    }
    
    public int getTotaleCombinazioni(){
    	return this.totaleCombinazioni;
    }
    
    @Override
    public String toString(){
    	return "[" + bottom + ", " + up + "[";
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
		Integer bottom = new Integer(1023);
		Integer up = new Integer(9876);
		
		MainComb mc = new MainComb(bottom, up, true);
		System.out.println(mc.toString());
		System.out.println("Totale disposizioni: " + mc.getTotaleCombinazioni());
		
		bottom = new Integer(10);
		up = new Integer(29);
		mc = new MainComb(bottom, up, true);
		System.out.println(mc.toString());
		System.out.println("Totale disposizioni: " + mc.getTotaleCombinazioni());		
    }
}