2012-05-29 24 views
11

Codice 1:valori aggiunta al arraylist

ArrayList arr = new ArrayList(); 
arr.add(3); 
arr.add("ss"); 

Codice 2:

ArrayList<Object> arr = new ArrayList<Object>(); 
arr.add(3); 
arr.add("ss"); 

Codice 3:

ArrayList<Object> arr = new ArrayList<Object>(); 
arr.add(new Integer(3)); 
arr.add(new String("ss")); 

tutti i suddetti tre codici stanno lavorando bene .. qualcuno può dimmi cosa è preferibile e perché ... e perché il compilatore di eclipse avvisa sempre quando il tipo di argomenti non viene menzionato all'arrayylist .. grazie in annuncio vance ..

risposta

10

Prima regola semplice: non utilizzare mai il costruttore String(String), è assolutamente inutile (*).

Quindi arr.add("ss") va bene.

Con 3 è leggermente diverso: 3 è un valore letterale int, che non è un oggetto. Solo gli oggetti possono essere inseriti in un List. Pertanto, lo int dovrà essere convertito in un oggetto Integer.Nella maggior parte dei casi ciò sarà fatto automaticamente per te (tale processo è chiamato autoboxing). in modo efficace fa la stessa cosa di Integer.valueOf(3) che può (e will) evitare di creare una nuova istanza Integer in alcuni casi.

Quindi in realtà la scrittura è arr.add(3)solito un'idea migliore rispetto all'utilizzo di arr.add(new Integer(3)), perché può evitare di creare una nuova Integer oggetto e invece riutilizzare e esistente.

Disclaimer: Mi sto concentrando sulla differenza tra il secondo e il terzo blocco di codice qui e praticamente ignorando la parte generica. Per ulteriori informazioni sui generici, si prega di consultare le altre risposte.

(*) ci sono alcuni casi angolo oscuro in cui è utile, ma una volta che ci si avvicina a quelli non saprai mai di raccogliere dichiarazioni assoluti assoluti ;-)

2

Bene, facendo quanto sopra, ti apri per eseguire gli errori del tempo, a meno che tu non sia felice di accettare che i tuoi arraylists possano contenere sia stringhe che interi ed elefanti.

Eclipse restituisce un errore perché non vuole che tu non sia consapevole del fatto che non specificando alcun tipo per il parametro generico ti stai aprendo per errori di run time. Almeno con gli altri due esempi, sai che puoi avere oggetti nel tuo Arraylist e dal momento che Inetegers e Stringhe sono entrambi gli oggetti Eclipse non ti avvisa.

I codici 2 o 3 sono ok. Ma se sai che avrà o solo interi o solo le stringhe nella vostra arraylist poi vorrei fare rispettivamente

ArrayList<Integer> arr = new ArrayList<Integer>(); 

o

ArrayList<String> arr = new ArrayList<String>(); 

.

6

La seconda si sarebbe preferito:

  • evita costruttore inutili/inefficiente chiama
  • fa si specifica il tipo di elemento per la lista (se questo manca, si ottiene un messaggio di avviso)

Tuttavia, avere due diversi tipi di oggetto nella stessa lista ha un po 'di cattivo odore di progettazione. Abbiamo bisogno di più contesto per parlare di questo.

+2

Per elaborare l'ultimo punto di @ Thilo, molti sviluppatori Java direbbero che il mixaggio di più tipi in un 'Elenco ' è il problema e che è necessario progettare il codice più attentamente per preservare la sicurezza del tipo. –

+1

Lasciatemi aggiungere il mio nome anti-pattern preferito non ancora riconosciuto qui: mescolando tipi non correlati in una singola lista odori di [negazione oggetto] (http://stackoverflow.com/a/3725728/40342). –

3

La seconda forma è preferito:

ArrayList<Object> arr = new ArrayList<Object>(); 
arr.add(3); 
arr.add("ss"); 

Specificare sempre argomenti generici quando si usano tipi generici (come ArrayList<T>). Questo esclude il primo modulo.

Per quanto riguarda l'ultimo modulo, è più dettagliato e fa un lavoro extra senza alcun beneficio.

0

nel primo don 't definire il tipo che si terrà e collegato all'interno del vostro arraylist costruire

questo è il metodo preferito per farlo, si definisce il tipo di lista e l'IDE gestire il resto

nella terza si sarà meglio definire solo Lis t per il codice breve

+0

Non hai indicato o indicato generici che è un'essenza di questa domanda. Non è l'IDE che "gestisce il resto" ma il compilatore. Inoltre, "solo la definizione dell'elenco" non è per codice più breve: è il "Programma verso un'interfaccia", non una regola di "implementazione" che è un argomento molto più ampio. –

2

In realtà, un terzo è preferito:

ArrayList<Object> array = new ArrayList<Object>(); 
array.add(Integer.valueOf(3)); 
array.add("ss"); 

Ciò evita autoboxing (Integer.valueOf(3) contro 3) e non crea un oggetto String inutile.

Eclipse si lamenta quando non si utilizzano argomenti di tipo con un tipo generico come ArrayList, perché si utilizza qualcosa chiamato un tipo non elaborato, che è scoraggiato. Se una classe è generica (cioè ha parametri di tipo), allora dovresti sempre usare gli argomenti di tipo con quella classe.

Autoboxing, d'altra parte, è una preferenza personale. Alcune persone sono d'accordo, e altre no. Non mi piace, e accendo l'avviso per autoboxing/autounboxing.

2

Si riceve l'avviso perché ArrayList fa parte di java generics. Essenzialmente, è un modo per catturare gli errori di tipo in fase di compilazione. Ad esempio, se dichiari la tua lista di array con tipi Integer (ArrrayList<Integer>) e poi provi ad aggiungere stringhe, otterrai un errore in fase di compilazione - evitando brutti crash in fase di runtime.

La prima sintassi è lì per compatibilità con le versioni precedenti e dovrebbe essere evitata quando possibile (si noti che i generici non erano presenti nelle versioni precedenti di java).

Secondo e terzo esempio sono praticamente equivalenti. Poiché è necessario passare un oggetto e non un tipo primitivo al metodo add, lo 3 viene convertito internamente in Integer(3). Scrivendo una stringa tra virgolette, si crea effettivamente un oggetto String. Quando si chiama String("ss") si sta creando un nuovo oggetto String con valore uguale al parametro ("ss").

A meno che non sia necessario memorizzare tipi diversi nel proprio Elenco, suggerirei effettivamente di utilizzare una dichiarazione di tipo corretta, ad es. ArrayList<Integer> = new ArrayList<Integer>() - ti farà risparmiare un sacco di mal di testa a lungo termine.

Se sono necessari più tipi di dati nell'elenco, il secondo esempio è migliore.

2

Due ultime varianti sono uguali, int viene inserito automaticamente in Integer dove è necessario un Object. Se non scrivi alcuna classe in <> sarà Object per impostazione predefinita. Quindi non c'è differenza, ma sarà meglio capire se scrivi Object.