La conversion d'Entier Long

J'ai besoin d'obtenir la valeur d'un champ à l'aide de la réflexion. Il se trouve que je ne suis pas toujours sûr de ce que le type de données du champ. Pour cela, et afin d'éviter certains duplication de code, j'ai créé la méthode suivante:

@SuppressWarnings("unchecked")
private static <T> T getValueByReflection(VarInfo var, Class<?> classUnderTest, Object runtimeInstance) throws Throwable {
  Field f = classUnderTest.getDeclaredField(processFieldName(var));
  f.setAccessible(true);
  T value = (T) f.get(runtimeInstance);

  return value;
}

Et d'utiliser cette méthode comme:

Long value1 = getValueByReflection(inv.var1(), classUnderTest, runtimeInstance);

Double[] value2 = getValueByReflection(inv.var2(), classUnderTest, runtimeInstance);

Le problème est que je n'arrive pas à lancer Integer à Long:

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

Est-il un meilleur moyen pour y parvenir?

J'utilise la version 1.6 de Java.

InformationsquelleAutor Tiago Veloso | 2011-07-14

84

Non, vous ne pouvez pas jeter Integer à Long, même si vous pouvez convertir int à long. Pour un personne valeur qui est connu pour être un certain nombre et vous souhaitez obtenir le long de la valeur, vous pouvez utiliser:
```
Number tmp = getValueByReflection(inv.var1(), classUnderTest, runtimeInstance);
Long value1 = tmp.longValue();
```
Pour les tableaux, c'est plus délicat...
- Pour les tableaux, je peux utiliser un Number[] et une boucle pour créer une façon appropriée tableau typé, droit?
- Cela dépend de ce que la méthode en fait, de retour. Qui ne travaille pas pour une double[] par exemple, mais aurait de travail pour un Double[].
- Pourquoi ne pouvez-vous pas jeté d'un Entier Long?
- Parce qu'ils sont séparés les types de référence, les deux sous-classes directes de Number. Ou pour le dire d'une autre façon: qui règle de conversion croyez-vous t vous permettent de convertir de l'un à l'autre?
- Ok. Le problème est l'héritage. Je suis en train de penser en termes de précision. Un entier peut être converti en un entier long, sans perte d'information. Mais la structure d'héritage n'a pas toute l'information qui permettrait de dire au compilateur.
InformationsquelleAutor Jon Skeet
127

Simplement:
```
Integer i = 7;
Long l = new Long(i);
```
- NPE est levée si l'Entier est null
- Fonctionne pour int valeurs.
- Long.valueof doit être utilisé: stackoverflow.com/questions/2974561/new-integer-vs-valueof
- Ce code fonctionne (Java implicitement unboxes la Integer à int et jette alors à long avant de passer à la désormais obsolète Long(long) constructeur.
InformationsquelleAutor vahid kh
48
```
Integer i = 5; //example

Long l = Long.valueOf(i.longValue());
```
Cela permet d'éviter la dégradation des performances de la conversion en Chaîne de caractères. Le longValue() méthode en Entier est juste une distribution de la valeur int. Le Long.valueOf() méthode donne de la vm une chance d'utiliser une valeur mise en cache.
- Nulle enregistrer: Long l = i == null ? null : je.longValue()
InformationsquelleAutor Rich MacDonald
19

Bizarrement j'ai trouvé que si vous analyser à partir d'une chaîne, il fonctionne.
```
 int i = 0;
 Long l = Long.parseLong(String.valueOf(i));
 int back = Integer.parseInt(String.valueOf(l));
```
Gagner.
- Il ne fait absolument aucun sens pour moi, mais il fonctionne comme un charme. Merci beaucoup!
- L'introduction d'une chaîne de conversion pour aucune raison n'est vraiment pas une bonne idée... il y a tout simplement aucun intérêt à faire cela.
- D'accord avec @JonSkeet, mieux avec ceci:Objet i = 10;Long l = ((Nombre) i).longValue();
- Cette méthode fonctionne très bien mais est relativement lent et utilise plus de mémoire que les autres méthodes de le faire...
- ressemble beaucoup à partir d'un développeur front-end en perspective
InformationsquelleAutor Anon
8

De convertir un entier directement à la longue par l'ajout de " L " à la fin de l'Entier.
```
Long i = 1234L;
```
- Je suis sûr que vous avez répondu sans lire la totalité de la question!
- cette question est le premier résultat lors de la recherche "int en long" sur Google, cette réponse peut être utile à d'autres
- Je ne dis pas que cette réponse est fausse, Mais je suis en train de dire la réponse à cette question est erroné. Vous avez raison,C'est utile pour ceux qui ne lisent pas la question et de regarder la réponse seulement.
InformationsquelleAutor Jeff Johny
8

La conversion d'Entier Long Très Simple et de nombreuses façons de conversion qui

Exemple 1
```
 new Long(your_integer);
```
Exemple 2
```
Long.valueOf(your_integer); 
```
Exemple 3
```
Long a = 12345L;
```
Exemple 4

Si vous avez déjà l'int tapé comme un Entier vous pouvez le faire:
```
Integer y = 12;
long x = y.longValue();
```
InformationsquelleAutor Naresh Kumar
6

Si l'Entier n'est pas null
```
Integer i;
Long long = Long.valueOf(i);
```
i sera automatiquement catalogués à un long.

À l'aide de valueOf au lieu de new permet la mise en cache de cette valeur (si son petites) par le compilateur ou de la JVM , ce qui accélère le code.
- Je ne peux pas trouver une.valueOf(Integer i) la méthode, les seuls que je trouve sont valueOf(long l), valueOf(String s) et valueOf(String s, int base). Vérifié pour Java8 et Java9 docs.
- Entier est implicitement converti en une primitive de type long.
- Ce doit être la accepté de répondre, oui?
InformationsquelleAutor lostintranslation

((Number) intOrLongOrSomewhat).longValue()

InformationsquelleAutor cingulata

2

Si vous savez que l'Entier n'est pas NULL, vous pouvez simplement faire ceci:
```
Integer intVal = 1;
Long longVal = (long) (int) intVal
```
InformationsquelleAutor Steven Spungin

new Long(Integer.longValue());

new Long(Integer.toString());

InformationsquelleAutor Pavlo Zvarych

Un analyseur de int variables à la long type est inclus dans le Integer classe. Voici un exemple:

int n=10;
long n_long=Integer.toUnsignedLong(n);

Vous pouvez facilement utiliser ce construit de fonction pour créer une méthode d'analyse de int à long:

    public static long toLong(int i){
    long l;
    if (i<0){
        l=-Integer.toUnsignedLong(Math.abs(i));
    }
    else{
        l=Integer.toUnsignedLong(i);
    }
    return l;
}

InformationsquelleAutor Bremsstrahlung

C'est null-safe

Number tmp = getValueByReflection(inv.var1(), classUnderTest, runtimeInstance);
Long value1 = tmp == null ? null : tmp.longValue();

InformationsquelleAutor adkisson

-1

Dans le cas d'une Liste de type Long, l'Ajout de L à la fin de chaque valeur entière
```
List<Long> list = new ArrayList<Long>();
list  = Arrays.asList(1L, 2L, 3L, 4L);
```
InformationsquelleAutor Joydeep Dutta

Vous devez vous connecter pour publier un commentaire.