[java] altro problema stupido

[michelev83]

class es78 {
public static void main(String []args) {

int i;
double[] a=new double[10];

for (i=0; i<=a.length-1; i++)
a[i]= Leggi.unDouble();
System.out.println(a[i]);
}
}


con questo prpgrama con javac nn mi da errore ma eseguendolo. dopo aver iserito i valori mi da questo errore:


Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10 at es78.main(es78.java:9)

[Mazza2]

ma le parentesi del for?? metticele e funzia tutto :P

class es78 { 
public static void main(String []args) { 

int i; 
double[] a=new double[10]; 

for (i=0; i<=a.length-1; i++) {
a[i]= Leggi.unDouble(); 
System.out.println(a[i]); 
}
} 
}

[michelev83]

gia provato!

[michelev83]

forsenn mi sono spiefato bene....devo prima inserirli tutti e poi stamparli tutti...

[michelev83]

[Mazza2]

il codice qui sotto funzia alla perfezione. Anche quello che ti ho postato prima funzionava benissimo. L'unico errore puo' essere in Leggi.unDouble(); che non fa il suo dovere tutto qui.
al limite posta la classe Leggi... ciao

class es78 { 
public static void main(String []args) { 

int i; 
double[] a=new double[10]; 

for (i=0; i<a.length; i++) {
a[i] = Leggi.unDouble();
}

for(int k=0;k<a.length;k++){
System.out.println(a[k]); 
}
} 
}

[PGI]

Nel codice postato inizialmente da michelev83 il problema è nella linea

System.out.println(a[i]);

Il ciclo for infatti aumenta il valore di "i" partendo a 0 e arriva fino a 10.

Quando arriva a 10 la condizione del ciclo (i <= a.length -1) risulta "false" e il ciclo viene interrotto con i che vale 10.

La linea successiva al blocco for richiede l'accesso all'elemento di indice i ( = 10) di un array che ha 10 elementi (indice max = 9) e frappete, va tutto a schifio.

Ciao.

[michelev83]

si e qual e la solozione

grazie!

[michelev83]

questo e il testo dell esercizio

Scrivete un programma che legge in input 10 valori di tipo double, li memorizza in un array e li visualizza. Usate il ciclo for e il ".length".
Modificate il programma usando il while invece del for.

[PGI]

Il secondo post di mazza2 mi sembra corrispondere alla soluzione dell'esercizio (in versione for). Il primo ciclo legge, il secondo stampa.

Tenendo conto che il while è un for senza inizializzazione ed incremento, che l'inizializzazione deve essere fatta una sola volta, prima del primo uso e l'incremento dopo la verifica, una volta per ogni passaggio nel ciclo, dovresti risolvere con poche modifiche anche la richiesta di usare while al posto di for.

Ciao.

[michelev83]

grazie ora prvo ! nn avevo notato quel post!

coem farei senza di voi !

[michelev83]

Scrivete un programma che legge in input 10 valori di tipo double, li memorizza in un array e li visualizza in ordine invertito (dall'ultimo al primo).

Scrivete un programma che ha lo stesso effetto del precedente, ma i valori vanno memorizzati nell'array a partire dall'ultima posizione (e visualizzati sempre in ordine invertito dall'ultimo letto al primo).


come si fannoo

nn hocapito niente dei for anndati

[PGI]

Stando al testo non devi usare dei cicli annidati (un ciclo dichiarato all'interno del corpo di un altro ciclo), semmai usi due cicli in successione (uno per leggere e memorizzare, uno per stampare). Si tratta in buona sostanza di un esercizio sugli indici degli array.

dichiari e inizializzi un array di 10 double;
for(int i = 0; i < 10;i++) -> leggi un double e lo infili nell'array in posizione i;
//un altro for, non annidato
for(int i = 9; i >= 0; i--) -> stampa a video array[i];

Il secondo è identico, solo che il primo ciclo deve comportarsi come l'ultimo (cioè andare da 9 a 0 incluso).

Ciao.

[michelev83]

si sto capendo! grasie!

[PGI]

Non ho capito se la risposta sia sarcastica o se tu stia capendo davvero.

[michelev83]

no no sto capendo davvero! davvero graziwe!

[michelev83]

altro probelmino devo fare un rpgrammino che dice se due array char sono uguali
class es711{

public static void main(String[]ags){
int i;
int k;
int j;
System.out.println("inserisci dimesione array");
i= Leggi.unInt();
char[] a= new char[i];
char[] b= new char [i];
System.out.println("inserisci array 1");
for (k=0; k<=a.length-1; k++)
a[k]= (char) Leggi.unChar();
System.out.println("inserisci array 2");
for (j=0; j<=a.length-1; j++)
b[j]= (char) Leggi.unChar();

if ((a[k])==(b[j]))
System.out.println("uguali");
else
System.out.println("diversi");


}
}


ecco al javac mi da che e esatto quando lo eseguo inserisco gli array e dopo mi da l erroee

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 at es711.main(es711.java:18)


grazie di nuovo a tutti quelli che mi aiutano

[PGI]

Nelle espressioni di accesso agli elementi di un array Java la validità dell'indice è valutata a tempo di esecuzione. Potresti scrivere array[-1000] e javac non farebbe una piega.

Il problema è qui.

if ((a[k])==(b[j]))

Quando termina il ciclo k vale a.length, ma l'indice massimo di un array è array.length - 1. Lo stesso per j.

Non so perchè ma hai il vizietto di riciclare gli indici dei cicli .

In condizioni normali (quindi, salvo speciali esigenze, che qui non ci sono) un for include dichiarazione ed inizializzazione dell'indice (nel tuo codice dichiari l'indice all'esterno, lo inizializzi nel for e poi lo ricicli nell'istruzione che ho riportato sopra). Dovresti seguire la forma standard che tra l'altro migliora la leggibilità.

for(int k = 0; k < a.length; k++) {
        ecc. ecc.
}

Dovendo poi verificare che gli array a e b contengano gli stessi elementi, dovresti controllarli elemento per elemento. Di vuole un altro ciclo. a e b hanno la stessa lunghezza, quindi:

for(da 0 ad a.length -1) -> se a[i] è diverso da b[i] -> gli array non contengono gli stessi elementi -> esci dal ciclo (basta un elemento diverso a rendere diversi gli array).

Per sapere, una volta terminato il ciclo, se la serie di confronti abbia dato esito positivo o negativo dovresti usare un valore di controllo che inizializzi prima di entrare nel ciclo. Ad esempio:

boolean sonoUguali = true;
for(...) se a[i] è diverso da b[i] -> sonoUguali = false -> break;

terminato il ciclo se "sonoUguali" è "true" allora il ciclo si è "estinto" naturalmente, quindi tutti gli elementi sono uguali.

se vale "false" è perchè, incontrando un elemento diverso, ha eseguito la tua istruzione condizionale che diceva "se incontri due elementi diversi imposta sonoUguali a false ed esci".

Ciao.

[michelev83]

questonn ho capito molto...

mo lo rileggo uan decian di volte...

[michelev83]

[quote]Originariamente inviato da PGI

Quando termina il ciclo k vale a.length, ma l'indice massimo di un array è array.length - 1. Lo stesso per j.

Non so perchè ma hai il vizietto di riciclare gli indici dei cicli .

In condizioni normali (quindi, salvo speciali esigenze, che qui non ci sono) un for include dichiarazione ed inizializzazione dell'indice (nel tuo codice dichiari l'indice all'esterno, lo inizializzi nel for e poi lo ricicli nell'istruzione che ho riportato sopra). Dovresti seguire la forma standard che tra l'altro migliora la leggibilità.

for(int k = 0; k < a.length; k++) {
        ecc. ecc.
}

ok fin qua ho cpaito...e cheil prof c diceva di usare cosi perhce epiu capible...vabbe le robe che n capisco io son altre ma lui le da per scontate...