La pratica standard è quella di seguire le primitive, a meno che tu non abbia a che fare con i generici (assicurati di essere a conoscenza di autoboxing e unboxing !).
Ci sono una serie di buoni motivi per seguire la convenzione:
1. Eviti semplici errori:
Ci sono alcuni casi sottili e non intuitivi che spesso catturano i principianti. Anche i programmatori esperti scivolano e fanno questi errori a volte (speriamo che questo sia seguito da imprecazioni quando eseguono il debug del codice e trovano l'errore!).
L'errore più comune sta usando a == binvece di a.equals(b). Le persone sono abituate a fare a == bcon le primitive, quindi è facile farlo quando si usano i wrapper di oggetti.
Integer a = new Integer(2);
Integer b = new Integer(2);
if (a == b) { // Should be a.equals(b)
// This never gets executed.
}
Integer c = Integer.valueOf(2);
Integer d = Integer.valueOf(2);
if (c == d) { // Should be a.equals(b), but happens to work with these particular values!
// This will get executed
}
Integer e = 1000;
Integer f = 1000;
if (e == f) { // Should be a.equals(b)
// Whether this gets executed depends on which compiler you use!
}
2. Leggibilità:
Considera i seguenti due esempi. Molte persone direbbero che il secondo è più leggibile.
Integer a = 2;
Integer b = 2;
if (!a.equals(b)) {
// ...
}
int c = 2;
int d = 2;
if (c != d) {
// ...
}
3. Prestazioni:
Il fatto è che è più lento usare i wrapper Object per le primitive piuttosto che usare le primitive. Stai aggiungendo il costo dell'istanza dell'oggetto, delle chiamate di metodo, ecc. Alle cose che usi ovunque .
La citazione di "... diciamo circa il 97% delle volte: l'ottimizzazione prematura è la radice di tutti i mali" la citazione non si applica qui. Stava parlando di ottimizzazioni che rendono il codice (o sistema) più complicato - se sei d'accordo con il punto 2, questa è un'ottimizzazione che rende il codice meno complicato!
4. È la convenzione:
Se fai diverse scelte stilistiche rispetto al 99% degli altri programmatori Java là fuori, ci sono 2 aspetti negativi:
- Troverai il codice di altre persone più difficile da leggere. Il 99% degli esempi / tutorial / ecc. Là fuori utilizzerà primitive. Ogni volta che ne leggi uno avrai il sovraccarico cognitivo in più di pensare a come apparirebbe nello stile a cui sei abituato.
- Altre persone troveranno il tuo codice più difficile da leggere. Ogni volta che fai domande su Stack Overflow dovrai scorrere le risposte / i commenti chiedendo "perché non usi le primitive?". Se non mi credi, guarda le battaglie che le persone hanno su cose come il posizionamento delle parentesi, che non influisce nemmeno sul codice generato!
Normalmente elencherei alcuni contrappunti, ma onestamente non riesco a pensare a nessuna buona ragione per non andare qui alla convention!