Come controllare il tipo di variabile in Java?

Come posso verificare per assicurarmi che la mia variabile sia int, array, double, ecc ...?

Modifica: ad esempio, come posso verificare che una variabile sia un array? C'è qualche funzione per farlo?

Java è un linguaggio tipizzato staticamente, quindi il compilatore esegue la maggior parte di questo controllo per te. Dopo aver dichiarato una variabile di un certo tipo, il compilatore si assicurerà che gli vengano assegnati solo valori di quel tipo (o valori che sono sottotipi di quel tipo).

Gli esempi che hai fornito ( int, array, double) sono tutti primitivi e non ci sono sottotipi di essi. Pertanto, se dichiari una variabile come int:

int x;

Puoi essere certo che manterrà solo intvalori.

Se hai dichiarato una variabile come a List, tuttavia, è possibile che la variabile contenga i sottotipi di List. Esempi di questi includono ArrayList, LinkedListecc

Se avevi una Listvariabile e avevi bisogno di sapere se era una ArrayList, potresti fare quanto segue:

List y;
...
if (y instanceof ArrayList) { 
  ...its and ArrayList...
}

Tuttavia, se ti ritrovi a pensare di doverlo fare, potresti voler ripensare al tuo approccio. Nella maggior parte dei casi, se segui i principi orientati agli oggetti, non sarà necessario farlo. Tuttavia, ci sono ovviamente delle eccezioni a ogni regola.

In realtà è abbastanza facile eseguire il test del proprio tester, abusando della capacità di sovraccarico del metodo di Java. Anche se sono ancora curioso di sapere se esiste un metodo ufficiale in sdk.

Esempio:

class Typetester {
    void printType(byte x) {
        System.out.println(x + " is an byte");
    }
    void printType(int x) {
        System.out.println(x + " is an int");
    }
    void printType(float x) {
        System.out.println(x + " is an float");
    }
    void printType(double x) {
        System.out.println(x + " is an double");
    }
    void printType(char x) {
        System.out.println(x + " is an char");
    }
}

poi:

Typetester t = new Typetester();
t.printType( yourVariable );

a.getClass().getName()- ti fornirà il tipo di dati dell'oggetto effettivo a cui fa riferimento a, ma non il tipo di dati con cui la variabile è astata originariamente dichiarata o su cui è stato eseguito successivamente il cast.

boolean b = a instanceof String- ti darà se l'oggetto effettivo a cui afa riferimento è un'istanza di una classe specifica. Di nuovo, il tipo di dati che la variabilea stata originariamente dichiarata o a cui è stato eseguito il cast non ha alcuna relazione con il risultato dell'operatore instanceof.

Ho preso queste informazioni da: Come conosci un tipo di variabile in java?

Può succedere. Sto cercando di analizzare a Stringin un int e mi piacerebbe sapere se il mio Integer.parseInt(s.substring(a, b))sta eliminando un int o garbage prima di provare a riassumerlo.

A proposito, questo è noto come riflessione. Ecco alcune ulteriori informazioni sull'argomento: http://docs.oracle.com/javase/tutorial/reflect/

Puoi lavorare con Integer invece di int, Double invece di double, ecc. (Tali classi esistono per tutti i tipi primitivi). Quindi puoi usare l'operatore instanceof, comeif(var instanceof Integer){...}

Usa solo:

.getClass().getSimpleName();

Esempio:

StringBuilder randSB = new StringBuilder("just a String");
System.out.println(randSB.getClass().getSimpleName());

Produzione:

StringBuilder

Bene, penso che il controllo del tipo di variabile possa essere fatto in questo modo.

public <T extends Object> void checkType(T object) {    
    if (object instanceof Integer)
        System.out.println("Integer ");
    else if(object instanceof Double)
        System.out.println("Double ");
    else if(object instanceof Float)
        System.out.println("Float : ");
    else if(object instanceof List)
        System.out.println("List! ");
    else if(object instanceof Set)
        System.out.println("Set! ");
}

In questo modo non è necessario disporre di più metodi sovraccaricati. Penso che sia una buona pratica utilizzare le raccolte su array a causa dei vantaggi aggiuntivi. Detto questo, non so come verificare un tipo di array. Forse qualcuno può migliorare questa soluzione. Spero che questo ti aiuti!

PS Sì, lo so che anche questo non controlla le primitive.

La prima parte della tua domanda è priva di significato. Non ci sono circostanze in cui non si conosce il tipo di una variabile primitiva in fase di compilazione.

Per la seconda parte, l'unica circostanza in cui non sai già se una variabile è un array è se è un Object. In tal caso te object.getClass().isArray()lo dirò.

L'ho fatto usando: if(x.getClass() == MyClass.class){...}

Non ero soddisfatto di nessuna di queste risposte, e quella giusta non ha spiegazioni e voti negativi, quindi ho cercato in giro, ho trovato alcune cose e le ho modificate in modo che fosse facile da capire. Gioca con esso, non così diretto come si potrebbe sperare.

//move your variable into an Object type
Object obj=whatYouAreChecking;
System.out.println(obj);

// moving the class type into a Class variable
Class cls=obj.getClass();
System.out.println(cls);

// convert that Class Variable to a neat String
String answer = cls.getSimpleName();
System.out.println(answer);

Ecco un metodo:

public static void checkClass (Object obj) {
    Class cls = obj.getClass();
    System.out.println("The type of the object is: " + cls.getSimpleName());       
}

Nessuna di queste risposte funziona se la variabile è un tipo generico non inizializzato

E da quello che posso trovare, è possibile solo usando una soluzione alternativa estremamente brutta , o passando un parametro inizializzato alla tua funzione, rendendolo sul posto, vedi qui:

<T> T MyMethod(...){ if(T.class == MyClass.class){...}}

NON è valido perché non è possibile estrarre il tipo Tdirettamente dal parametro, poiché viene cancellato in fase di runtime.

<T> void MyMethod(T out, ...){ if(out.getClass() == MyClass.class){...}}

Questo funziona perché il chiamante è responsabile di creare un'istanza della variabile outprima della chiamata. Questo genererà comunque un'eccezione se out è nullo quando viene chiamato, ma rispetto alla soluzione collegata, questo è di gran lunga il modo più semplice per farlo

So che questo è un tipo di applicazione specifica, ma poiché questo è il primo risultato su google per trovare il tipo di una variabile con java (e dato che Tè una sorta di variabile), sento che dovrebbe essere incluso

Puoi controllarlo facilmente usando Java.lang.Class.getSimpleName()Metodo Solo se la variabile ha un tipo non primitivo. Non funziona con i tipi primitivi int, long ecc.

riferimento - Ecco il collegamento ai documenti Oracle

Fondamentalmente, ad esempio:

public class Kerem
{
    public static void main(String[] args)
    {
        short x = 10;
        short y = 3;
        Object o = y;
        System.out.println(o.getClass()); // java.lang.Short
    }

}

public class Demo1 {

Object printType(Object o)
{
    return o;
}
 public static void main(String[] args) {

    Demo1 d=new Demo1();
    Object o1=d.printType('C');
    System.out.println(o1.getClass().getSimpleName());

}

}