Sto un po 'estendendo le risposte fornite (dato che finora si concentrano sulla loro "propria" / terminologia artificiale concentrandosi sulla programmazione di un particolare linguaggio invece di occuparsi del quadro più ampio dietro la scena della creazione dei linguaggi di programmazione , in generale, cioè quando le cose come le considerazioni sulla sicurezza dei tipi e sulla memoria fanno la differenza):
int non è booleano
Tener conto di
boolean bar = true;
System.out.printf("Bar is %b\n", bar);
System.out.printf("Bar is %d\n", (bar)?1:0);
int baz = 1;
System.out.printf("Baz is %d\n", baz);
System.out.printf("Baz is %b\n", baz);
con uscita
Bar is true
Bar is 1
Baz is 1
Baz is true
Il codice Java sulla terza riga (bar)?1:0mostra che la barra ( booleana ) non può essere implicitamente convertita (castata) in un int . Sto sollevando questo argomento non per illustrare i dettagli dell'implementazione dietro JVM, ma per sottolineare che in termini di considerazioni di basso livello (come le dimensioni della memoria) si devono preferire i valori alla sicurezza del tipo. Soprattutto se quel tipo di sicurezza non è realmente / pienamente utilizzato come nei tipi booleani in cui i controlli vengono effettuati in forma di
se il valore \ in {0,1} viene quindi trasmesso al tipo booleano, altrimenti genera un'eccezione.
Tutto solo per affermare che {0,1} <{-2 ^ 31, .., 2 ^ 31 -1}. Sembra un eccesso, vero? La sicurezza dei tipi è veramente importante nei tipi definiti dall'utente, non nella fusione implicita di primitivi (sebbene gli ultimi siano inclusi nel primo).
I byte non sono tipi o bit
Ricorda che in memoria la tua variabile nell'intervallo di {0,1} occuperà comunque almeno un byte o una parola (xbit in base alla dimensione del registro) a meno che non sia stata curata in modo particolare (ad es. Imballata bene in memoria - 8 "booleana" bit in 1 byte - avanti e indietro).
Preferendo la sicurezza del tipo (come nel mettere / racchiudere il valore in una scatola di un tipo particolare) piuttosto che nell'imballaggio di valore extra (ad es. Usando i bit shift o l'aritmetica), si sceglie effettivamente di scrivere meno codice piuttosto che guadagnare più memoria. (D'altra parte si può sempre definire un tipo di utente personalizzato che faciliterà tutte le conversioni che non valgono il valore booleano).
parola chiave vs. tipo
Infine, la tua domanda riguarda il confronto tra parola chiave e tipo . Ritengo sia importante spiegare perché o in che modo otterrai prestazioni utilizzando / preferendo le parole chiave ("contrassegnate" come primitive ) rispetto ai tipi (normali classi composite definibili dall'utente utilizzando un'altra classe di parole chiave ) o in altre parole
boolean foo = true;
vs.
Boolean foo = true;
La prima "cosa" (tipo) non può essere estesa (sottoclasse) e non senza motivo. In effetti, la terminologia Java delle classi primitive e di wrapping può essere semplicemente tradotta in valore inline (un LITERAL o una costante che viene sostituita direttamente dal compilatore ogni volta che è possibile inferire la sostituzione o, in caso contrario, fallback nel wrapping del valore).
L'ottimizzazione è ottenuta grazie a banali:
"Meno operazioni di casting runtime => più velocità."
Questo è il motivo per cui, quando viene fatta l'inferenza del tipo effettivo, può (ancora) finire per creare un'istanza della classe di wrapping con tutte le informazioni sul tipo, se necessario (o convertire / eseguire il casting in tale).
Quindi, la differenza tra il valore booleano e booleana è esattamente nella compilazione e runtime (un po 'lontano in corso, ma quasi come instanceof vs getClass () ).
Infine, l'autoboxing è più lento dei primitivi
Si noti che Java può eseguire il box automatico è solo uno "zucchero sintattico". Non accelera nulla, ti permette solo di scrivere meno codice. Questo è tutto. Il cast e il wrapping nel contenitore di informazioni sul tipo vengono comunque eseguiti. Per motivi di prestazioni, scegliere l'aritmetica che salterà sempre le pulizie extra della creazione di istanze di classe con informazioni sul tipo per implementare la sicurezza del tipo. La mancanza di sicurezza del tipo è il prezzo da pagare per ottenere prestazioni. Per il codice con espressioni con valori booleani la sicurezza del tipo (quando si scrive meno e quindi codice implicito ) sarebbe fondamentale, ad esempio per i controlli di flusso if-then-else.