Perché non è possibile eseguire il cast di Integer su String in java?

Ho trovato qualche strana eccezione:

java.lang.ClassCastException: java.lang.Integer 
 cannot be cast to java.lang.String

Come può essere possibile? Ogni oggetto può essere lanciato su String, non è vero?

Il codice è:

String myString = (String) myIntegerObject;

Grazie.

Perché questo non è possibile:

Perché String e Integer non si trovano nella stessa gerarchia di oggetti.

      Object
     /      \
    /        \
String     Integer

Il casting che stai provando, funziona solo se sono nella stessa gerarchia, ad es

      Object
     /
    /
   A
  /
 /
B

In questo caso, (A) objBo (Object) objBo (Object) objAfunzionerà.

Quindi, come altri hanno già detto, per convertire un intero in una stringa usa:

String.valueOf(integer), o Integer.toString(integer)per primitivo,

o

Integer.toString() per l'oggetto.

No, Integere Stringsono tipi diversi. Per convertire un intero in una stringa usa:, String.valueOf(integer)o Integer.toString(integer)per primitivo, o Integer.toString()per l'oggetto.

Per i inttipi utilizzare:

int myInteger = 1;
String myString = Integer.toString(myInteger);

Per i Integertipi utilizzare:

Integer myIntegerObject = new Integer(1);
String myString = myIntegerObject.toString();

No. Ogni oggetto può essere lanciato a un java.lang.Object, non a String. Se vuoi una rappresentazione di stringa di qualsiasi oggetto, devi invocare il toString()metodo; non è la stessa cosa che lanciare l'oggetto su una stringa.

Gli oggetti possono essere convertiti in una stringa utilizzando il toString()metodo:

String myString = myIntegerObject.toString();

Non esiste una regola del genere sul casting . Affinché il casting funzioni, l'oggetto deve essere effettivamente del tipo a cui stai eseguendo il casting.

Non puoi trasmettere esplicitamente nulla a un file Stringche non sia a String. Dovresti usare uno:

"" + myInt;

o:

Integer.toString(myInt);

o:

String.valueOf(myInt);

Preferisco la seconda forma, ma credo sia una scelta personale.

Modifica OK, ecco perché preferisco la seconda forma. La prima forma, una volta compilata, potrebbe istanziare a StringBuffer(in Java 1.4) o a StringBuilderin 1.5; un'altra cosa da raccogliere nella spazzatura. Il compilatore non lo ottimizza per quanto ne so. La seconda forma ha anche un analogo, Integer.toString(myInt, radix)che ti permette di specificare se vuoi esadecimale, ottale, ecc. Se vuoi essere coerente nel tuo codice (puramente esteticamente, immagino) la seconda forma può essere usata in più posti.

Modifica 2 Ho pensato che volessi dire che il tuo numero intero fosse un inte non un Integer. Se è già un Integer, usalo toString()e fallo.

Dovresti chiamare myIntegerObject.toString () se vuoi la rappresentazione di stringa.

Il casting è diverso dalla conversione in Java, per usare una terminologia informale.

Eseguire il cast di un oggetto significa che l'oggetto è già ciò a cui lo stai trasmettendo e lo stai solo dicendo al compilatore. Ad esempio, se ho un Fooriferimento che so essere FooSubclassun'istanza, allora (FooSubclass)Foodice al compilatore, "non modificare l'istanza, sappi solo che in realtà è un file FooSubclass.

D'altra parte, an nonInteger è a , sebbene (come fai notare) ci siano metodi per ottenere a che rappresenta un . Dal momento che nessun alcuna istanza di può mai essere una , non puoi lanciare a .StringStringIntegerIntegerStringIntegerString

Nel tuo caso non è necessario il casting, devi chiamare toString ().

Integer i = 33;
String s = i.toString();
//or
s = String.valueOf(i);
//or
s = "" + i;

Casting. Come funziona?

Dato:

class A {}
class B extends A {}

(A)
  |
(B)

B b = new B(); //no cast
A a = b;  //upcast with no explicit cast
a = (A)b; //upcast with an explicit cast
b = (B)a; //downcast

A e B nello stesso albero ereditario e possiamo questo:

a = new A();
b = (B)a;  // again downcast. Compiles but fails later, at runtime: java.lang.ClassCastException

Il compilatore deve consentire cose che potrebbero funzionare in fase di esecuzione. Tuttavia, se il compilatore sa al 100% che il cast non potrebbe funzionare, la compilazione fallirà.
Dato:

class A {}
class B1 extends A {}
class B2 extends A {}

        (A)
      / \
(B1) (B2)

B1 b1 = new B1();
B2 b2 = (B2)b1; // B1 can't ever be a B2

Errore: tipi invertibili B1 e B2. Il compilatore sa al 100% che il cast non potrebbe funzionare. Ma puoi imbrogliare il compilatore:

B2 b2 = (B2)(A)b1;

ma comunque in fase di esecuzione:

Eccezione nel thread "main" java.lang.ClassCastException: impossibile eseguire il cast di B1 su B2

nel tuo caso:

          (Oggetto)
            / \
(Intero) (Stringa)

Integer i = 33;
//String s = (String)i; - compiler error
String s = (String)(Object)i;

in fase di esecuzione: eccezione nel thread "main" java.lang.ClassCastException: java.lang.Integer non può essere cast su java.lang.String

Usa String.valueOf (intero) .

Restituisce una rappresentazione di stringa di numero intero.

Usa .toString invece come di seguito:

String myString = myIntegerObject.toString();