Un int può essere nullo in Java?

Può intessere nullin Java?

Per esempio:

int data = check(Node root);

if ( data == null ) {
 // do something
} else {
 // do something
}

Il mio obiettivo è quello di scrivere una funzione che restituisce un int. Detto intè memorizzato all'altezza di un nodo e se il nodo non è presente, sarà nullo e dovrò verificarlo.

Lo sto facendo per i compiti, ma questa parte specifica non fa parte dei compiti, mi aiuta solo a superare quello che sto facendo.

Grazie per i commenti, ma sembra che pochissime persone abbiano effettivamente letto cosa c'è sotto il codice, mi chiedevo in quale altro modo posso raggiungere questo obiettivo; è stato facile capire che non funziona.

int non può essere nullo, ma Integer può . È necessario fare attenzione quando si decomprimono numeri interi null poiché ciò può causare molta confusione e grattarsi la testa!

ad esempio questo:

int a = object.getA(); // getA returns a null Integer

ti darà un NullPointerException, nonostante l'oggetto non sia nullo!

Per dare seguito alla tua domanda, se vuoi indicare l' assenza di un valore, vorrei indagarejava.util.Optional<Integer>

No. Solo i riferimenti agli oggetti possono essere nulli, non primitivi.

Un ottimo modo per scoprire:

public static void main(String args[]) {
    int i = null;
}

Prova a compilare.

In Java, int è un tipo primitivo e non è considerato un oggetto. Solo gli oggetti possono avere un valore nullo. Quindi la risposta alla tua domanda è no, non può essere nulla. Ma non è così semplice, perché ci sono oggetti che rappresentano i tipi più primitivi.

La classe Integer rappresenta un valore int, ma può contenere un valore null. A seconda del checkmetodo, potresti restituire un int o un numero intero.

Questo comportamento è diverso da alcuni linguaggi più puramente orientati agli oggetti come Ruby, dove persino le cose "primitive" come gli ints sono considerate oggetti.

Insieme a tutte le risposte sopra vorrei aggiungere anche questo punto.

Per i tipi primitivi, abbiamo dimensioni di memoria fisse, cioè per int abbiamo 4 byte e char abbiamo 2 byte. E null viene utilizzato solo per gli oggetti perché la dimensione della memoria non è fissa.

Quindi per impostazione predefinita abbiamo,

   int a=0;

e non

   int a=null;

Lo stesso vale per altri tipi primitivi e quindi null viene utilizzato solo per oggetti e non per tipi primitivi.

Il codice non verrà nemmeno compilato. Solo un degno Objectpuò essere null, come Integer. Ecco un esempio di base da mostrare quando è possibile verificare null:

Integer data = check(Node root);

if ( data == null ) {
 // do something
} else {
 // do something
}

D'altra parte, se check()viene dichiarato di tornare int, non può mai essere nulle l'intero if-elseblocco è quindi superfluo.

int data = check(Node root);

// do something

I problemi di autoboxing non si applicano anche qui quando check()viene dichiarato di ritorno int. Se fosse tornato Integer, potresti rischiare NullPointerExceptionquando lo assegni a un intinvece di Integer. Assegnarlo come un Integere usare il if-elseblocco sarebbe stato davvero obbligatorio.

Per ulteriori informazioni su autoboxing, controlla questa guida Sun .

invece di dichiararlo come int idichiararlo come Integer iallora possiamo farei=null;

Integer i;
i=null;

L'oggetto intero sarebbe il migliore. Se è necessario utilizzare le primitive, è possibile utilizzare un valore che non esiste nel caso d'uso. L'altezza negativa non esiste per le persone, quindi

public int getHeight(String name){
    if(map.containsKey(name)){
        return map.get(name);
    }else{
        return -1;
    }
}

No, ma int [] può essere.

int[] hayhay = null; //: allowed (int[] is reference type)
int   hayno  = null; //: error   (int   is primitive type)
                     //: Message: incompatible types: 
                     //: <null> cannot be converted to int

Come @Glen ha menzionato in un commento, in pratica hai due modi per aggirare questo:

• usa un valore "fuori limite". Ad esempio, se i "dati" non possono mai essere negativi nell'uso normale, restituire un valore negativo per indicare che non è valido.
• Usa un numero intero. Assicurati solo che il metodo "check" restituisca un numero intero e lo assegni a un numero intero non a un int. Perché se un "int" viene coinvolto lungo la strada, il boxe automatico e il unboxing possono causare problemi.

Controlla null nel tuo metodo check () e restituisci un valore non valido come -1 o zero se null. Quindi il controllo sarebbe per quel valore piuttosto che passare il null lungo. Questa sarebbe una cosa normale da fare ai vecchi tempi "C".

Qualsiasi tipo di dati primitivo come int, booleano o float ecc. Non può archiviare il valore null (laterale), poiché java ha fornito la classe Wrapper per la memorizzazione dello stesso tipo int in Intero, booleano in booleano.

Ad esempio: intero i = null;

Un int non è nullo, può essere 0 se non inizializzato. Se vuoi che un numero intero sia nullo, devi usare Integer invece di int. le primitive non hanno valore nullo. il valore predefinito per un int è 0.

Tipo di dati / Valore predefinito (per i campi)

int ------------------ 0

lungo ---------------- 0L

float ---------------- 0.0f

doppio ------------- 0.0d

char --------------- '\ u0000'

String --------------- null

booleano ------------ falso

Dato che chiedi un altro modo per raggiungere il tuo obiettivo, ti suggerisco di utilizzare una classe wrapper:

new Integer(null);

Non sono un esperto, ma credo che l' nullequivalente di un int sia 0.

Ad esempio, se ne crei uno int[], ogni slot contiene 0invece di null, a meno che tu non lo imposti su qualcos'altro.

In alcune situazioni, questo può essere utile.