eccezzioni ed arreylist

[stregone_giallo_rosso]

Salve ho alcuni problemi con java mi potete dire quando e come usare try e catch per le eccezzioni e come ordinare un arraylist...please

[andbin]

quando e come usare try e catch per le eccezzioniL'argomento delle eccezioni è abbastanza ampio. Cosa non ti è chiaro? Ti è chiara la suddivisione tra eccezioni "checked" e "unchecked"? E come dichiarare correttamente try/catch/finally ed usare il throws?

come ordinare un arraylistLa classe java.util.Collections ha 2 metodi sort() che operano su un List<T>.
La prima versione si basa sul "natural ordering", in pratica gli oggetti devono implementare Comparable. La seconda versione si basa su un Comparator.
In entrambi i casi, gli oggetti devono essere "mutualmente comparabili".

[stregone_giallo_rosso]

per esempio quando leggo un file devo inserirla l'eccezzione come????
mi puoi fare un esempio per l'ordinamento

[nuovoUtente86]

per esempio quando leggo un file devo inserirla l'eccezzione come????
mi puoi fare un esempio per l'ordinamento

quando leggi un file devi gestire IOException

dichiari le variabili che ti servono
try{esegui le operazioni di lettura ecc....}catch(IOException e){fai qualcosa se si verifica l' eccezione}

[stregone_giallo_rosso]

quindi se scrivo public void leggi(filename) throws IOexception devo mettere anche try e catch

[andbin]

per esempio quando leggo un file devo inserirla l'eccezzione come????Qui dovresti leggere la documentazione delle classi che intendi usare. Comunque la eccezione principale nelle classi per l'I/O è IOException, che è una eccezione "checked". Pertanto quando usi, per fare un esempio, i metodi read() di un InputStream, allora la eccezione IOException la devi comunque prendere in considerazione.

mi puoi fare un esempio per l'ordinamentoArrayList<String> list = new ArrayList<String> ();

list.add ("topolino");
list.add ("paperino");
list.add ("clarabella");

Collections.sort (list);

[nuovoUtente86]

quindi se scrivo public void leggi(filename) throws IOexception devo mettere anche try e catch

no perche segnali al compilatori o meglio a chi chiama il metodo che potresti propagare l' eccezione eventualmente senza mai catturarla.

[stregone_giallo_rosso]

quale mi consiglireresti usare per un codice scritto correttamente?? poi un ultima cosa che non trovo:
catch (Exception e) {
e.printStackTrace();
il metodo printStackTrace cosa stampa???

[nuovoUtente86]

quale mi consiglireresti usare per un codice scritto correttamente?? poi un ultima cosa che non trovo:
catch (Exception e) {
e.printStackTrace();
il metodo printStackTrace cosa stampa???

io preferisco gestire sempre localmente al metodo l' eccezione.
PrintStack() stampa un log circa la condizioni di esecuzione al momento dell' errore e puo essere utile per individuarne le cause.ricorda di gestire sempre la chiusura degli stream aperti,e lo uoi elegantemente fare con una clausola finally

[stregone_giallo_rosso]

in che modo, mi fai un esempio??

[andbin]

Esempio:
import java.io.*;
import java.util.*;

public class Prova
{
public static void main (String[] args)
{
try
{
String[] lines = readFileInArray ("pippo.txt");

// ....
}
catch (Exception e)
{
System.out.println (e);
}
}

public static String[] readFileInArray (String fileName)
throws IOException
{
BufferedReader br = null;

try
{
ArrayList<String> arrLines = new ArrayList<String> ();

FileInputStream fis = new FileInputStream (fileName);
InputStreamReader isr = new InputStreamReader (fis);

br = new BufferedReader (isr);

String line;

while ((line = br.readLine ()) != null)
arrLines.add (line);

return arrLines.toArray (new String[0]);
}
finally
{
if (br != null)
br.close ();
}
}
}

[nuovoUtente86]

Esempio:
import java.io.*;
import java.util.*;

public class Prova
{
public static void main (String[] args)
{
try
{
String[] lines = readFileInArray ("pippo.txt");

// ....
}
catch (Exception e)
{
System.out.println (e);
}
}

public static String[] readFileInArray (String fileName)
throws IOException
{
BufferedReader br = null;

try
{
ArrayList<String> arrLines = new ArrayList<String> ();

FileInputStream fis = new FileInputStream (fileName);
InputStreamReader isr = new InputStreamReader (fis);

br = new BufferedReader (isr);

String line;

while ((line = br.readLine ()) != null)
arrLines.add (line);

return arrLines.toArray (new String[0]);
}
finally
{
if (br != null)
br.close ();
}
}
}

mi sorge una domanda:
se io volessi gestire l' eccezione nel metodo readFileInArray nel catch oltre a stampare eventualmente qualcosa sarei obbligato a mettere return istanza di String[] oppure no?

[andbin]

mi sorge una domanda:
se io volessi gestire l' eccezione nel metodo readFileInArray nel catch oltre a stampare eventualmente qualcosa sarei obbligato a mettere return istanza di String[] oppure no?Se mettessi un catch, allora sì, devi far ritornare qualcosa. A meno che rilanci la eccezione da dentro il catch.

Tieni comunque presente che non devi sempre e in ogni occasione catturare le eccezioni! Immagina che readFileInArray possa essere chiamato in vari punti e momenti della tua applicazione o che possa essere addirittura chiamato da applicazioni diverse (ammettiamo che il metodo sia in un jar utilizzabile in generale da altre classi).
Sarebbe una pessima idea mettere un catch lì nel metodo, magari solo per stampare a video l'errore!

[nuovoUtente86]

Se mettessi un catch, allora sì, devi far ritornare qualcosa. A meno che rilanci la eccezione da dentro il catch.

Tieni comunque presente che non devi sempre e in ogni occasione catturare le eccezioni! Immagina che readFileInArray possa essere chiamato in vari punti e momenti della tua applicazione o che possa essere addirittura chiamato da applicazioni diverse (ammettiamo che il metodo sia in un jar utilizzabile in generale da altre classi).
Sarebbe una pessima idea mettere un catch lì nel metodo, magari solo per stampare a video l'errore!

public String[] metodo(){
BufferedReader br = null;

try
{
ArrayList<String> arrLines = new ArrayList<String> ();

FileInputStream fis = new FileInputStream ("fileName");
InputStreamReader isr = new InputStreamReader (fis);

br = new BufferedReader (isr);

String line;

while ((line = br.readLine ()) != null)
arrLines.add (line);

return arrLines.toArray (new String[0]);}catch (Exception e)
{
System.out.println (e);
}return new String[1];
}

prima che rispondessi avevo fatto questa prova e nonostante manche il return nel catch non segnala l' errore.

[andbin]

prima che rispondessi avevo fatto questa prova e nonostante manche il return nel catch non segnala l' errore.In realtà il return new String[1]; l'hai messo al fondo del metodo, non nel catch. In caso di eccezione, esegue il corpo del catch e poi esegue quel return.

[nuovoUtente86]

In realtà il return new String[1]; l'hai messo al fondo del metodo, non nel catch. In caso di eccezione, esegue il corpo del catch e poi esegue quel return.

scusa se si solleva l' eccezione il metodo dovrebbe bloccarsi..altrimenti non avrebbe senso la clausola finally.Le istruzioni vengono cmq eseguite il maniera sequenziale per cui verrebbero eseguite ugualmente.

[andbin]

scusa se si solleva l' eccezione il metodo dovrebbe bloccarsi..altrimenti non avrebbe senso la clausola finally.Il codice in un blocco finally viene sempre eseguito, in ogni caso.

[nuovoUtente86]

Il codice in un blocco finally viene sempre eseguito, in ogni caso.

quindi diventa indispensabile se si applicano return nella parte precedente del codice.
Ipotizzando che non vi siano return nel catch oppure nel try non è indispensabile utilizzare la finally,almeno dai test che ho fatto è cosi,in quanto con la sequenzialità del codice vengono cmq eseguite le operazioni successive.
Io ho sempre creduto che dopo il catch si usciva cmq dal metodo.

[andbin]

Io ho sempre creduto che dopo il catch si usciva cmq dal metodo.No, non è così.

Prova a dire cosa stampa questo codice:
public class Prova
{
public static void main (String[] args)
{
System.out.println (testLen (null));
}

public static int testLen (String str)
{
try
{
System.out.println ("Sono nel try");
return str.length ();
}
catch (Exception e)
{
System.out.println ("Sono nel catch");
return -1;
}
finally
{
System.out.println ("Sono nel finally");
return -2;
}
}
}Nota che viene lanciata una eccezione NullPointerException perché str viene passato null.

Se senza provare il codice mi dici cosa stampa, non hai vinto nulla :D .... ma hai capito il try/catch/finally.

[nuovoUtente86]

No, non è così.

Prova a dire cosa stampa questo codice:
public class Prova
{
public static void main (String[] args)
{
System.out.println (testLen (null));
}

public static int testLen (String str)
{
try
{
System.out.println ("Sono nel try");
return str.length ();
}
catch (Exception e)
{
System.out.println ("Sono nel catch");
return -1;
}
finally
{
System.out.println ("Sono nel finally");
return -2;
}
}
}Nota che viene lanciata una eccezione NullPointerException perché str viene passato null.

Se senza provare il codice mi dici cosa stampa, non hai vinto nulla :D .... ma hai capito il try/catch/finally.

sono nel try
sono nel catch
-1
sono nel finally
-2

[andbin]

sono nel try
sono nel catch
-1
sono nel finally
-2Non è proprio così.
Dal momento che viene lanciata la eccezione NullPointerException, quello che è sicuro è che il codice nel try non può continuare e quindi return str.length () non viene eseguito.
Il catch che è in grado di gestire la eccezione è quello sotto il try, pertanto viene stampato "Sono nel catch". Il catch fa un return di -1. In quel punto quindi la "ragione" di uscita del metodo sarebbe il ritorno di -1.
Ma visto che c'è il finally, prima di fare il return viene eseguito in ogni caso il codice nel finally. Nota che la ragione di uscita del return di -1 viene temporaneamente "memorizzata".
Il finally viene eseguito e stampa "Sono nel finally" poi fa il return di -2. Visto che il finally causa una nuova ragione di uscita, quella precedente viene dimenticata e quindi il metodo restituisce -2.

Morale della storia: se nel finally si causa una nuova ragione di uscita, lanciando una eccezione o facendo un return, qualunque ragione di uscita precedente viene cancellata.

[stregone_giallo_rosso]

Potete aiutarmi a risolvere questo esercizio?

Un operatore telefonico ha organizzato l’archivio anagrafico dei propri clienti in un file denominato “Anagrafe.dat” ordinato in senso crescente rispetto al cognome, come segue:

Nome Cliente Cognome Cliente Numero Telefono

Esempio:

Gerardo Bianchi 0333457362
Rosa Clementino 0543778825
…
…
Pasquale Zigone 2234887289

Per ogni telefonata effettuata viene prodotto ed accodato ad un file denominato “telefonate.dat” un record con le seguenti informazioni:

Numero-chiamante Numero-chiamato Durata (in secondi)

Esempio:

0543778825 0834586372 15
2234887289 0834765736 358
…
…
0543778825 8463726534 446

Scrivere un programma che riceva in ingresso (possibilmente dalla linea di comando) il cognome e nome di due persone e calcoli il tempo totale di conversazione fra le due persone.

Ho caricato gli elementi dei due file su due ArrayList, ma adesso non so come continuare! Le classi Tel e Ele già le ho fatte.
import java.util.Scanner;
import java.util.ArrayList;
import java.io.FileReader;
class Array {
public Array (String file, String file1) throws Exception {
Scanner n = new Scanner (new FileReader (file));
Scanner m = new Scanner (new FileReader (file1));
ArrayList<Ele> a = new ArrayList<Ele>();
ArrayList<Tel> z = new ArrayList<Tel>();
Ele b = Ele.read(n);


while(b != null) {
a.add(b);
b = Ele.read(n);

}
Tel x = Tel.read1(m);
while(x != null) {
z.add(x);
x = Tel.read1(m);

}

n.close();
m.close();

}

[nuovoUtente86]

Non è proprio così.
Dal momento che viene lanciata la eccezione NullPointerException, quello che è sicuro è che il codice nel try non può continuare e quindi return str.length () non viene eseguito.
Il catch che è in grado di gestire la eccezione è quello sotto il try, pertanto viene stampato "Sono nel catch". Il catch fa un return di -1. In quel punto quindi la "ragione" di uscita del metodo sarebbe il ritorno di -1.
Ma visto che c'è il finally, prima di fare il return viene eseguito in ogni caso il codice nel finally. Nota che la ragione di uscita del return di -1 viene temporaneamente "memorizzata".
Il finally viene eseguito e stampa "Sono nel finally" poi fa il return di -2. Visto che il finally causa una nuova ragione di uscita, quella precedente viene dimenticata e quindi il metodo restituisce -2.

Morale della storia: se nel finally si causa una nuova ragione di uscita, lanciando una eccezione o facendo un return, qualunque ragione di uscita precedente viene cancellata.
capito