Comment puis-je convertir de int en Long en Java?

Je continue de trouver à la fois ici et sur Google des personnes ayant des troubles allant de long à int et non l'inverse. Pourtant, je suis sûr que je ne suis pas le seul qui a exécuté ce scénario avant d'aller de int à Long.

Les seuls autres réponses que j'ai trouvées étaient "Juste mis aussi Longtemps à la première place", ce qui n'est pas vraiment répondre à la question.

J'ai d'abord essayé de casting, mais je reçois un "Cannot cast from int to Long"

for (int i = 0; i < myArrayList.size(); ++i ) {
    content = new Content();
    content.setDescription(myArrayList.get(i));
    content.setSequence((Long) i);
    session.save(content);
}

Comme vous pouvez l'imaginer, je suis un peu perplexe, je suis bloqué à l'aide de int depuis quelques contenu est à venir dans un ArrayList et l'entité pour laquelle je suis le stockage de cette information nécessite le numéro de séquence comme une Longue.

for (long i = 0; i < myList.size(); ++i) travaille trop
Oui qui va travailler pour la boucle, mais comme je l'ai spécifié au fond de ma question, la liste de tableaux, je travaille avec nécessite la primitive int lors de la spécification de ce que l'indice de position pour obtenir
long longValue = intValue | 0L;
Ce que j'ai fait est: fonte int à long d'abord, puis d'attribuer long à Long. e.g int x = 2; Long y = (long)x;

InformationsquelleAutor Ghosty | 2009-08-19

227

Remarque qu'il y a une différence entre une troupe de long et une fonte de Long. Si vous lancez à long (une valeur primitive), alors il devrait être automatiquement boîte à Long (le type de référence que l'enveloppe).

Vous pouvez également utiliser new pour créer une instance de Long, l'initialiser avec la int valeur.
- Pour démontrer ce Earwicker dit que tu pourrais appeler Longue.valueOf(i), qui prend un long temps, mais permettra d'élargir un int et vous redonner un objet assez Long.
- L'autoboxing est préférable, parce qu'il n'ont pas forcément besoin de créer un nouveau Long objet à chaque fois.
- (Avertissement: le reste de ce commentaire est de conjectures et des suppositions) Si les valeurs données à Long terme.valueOf() se situent entre 0 et 128, ce qui est très fréquent, et il retourne une instance mise en cache, cela sera préférable par rapport à l'autoboxing? (J'ai peut poser une nouvelle question si vous pensez que ça vaut le coup...)
- L'autoboxing fait la même chose que ça. Par ailleurs, il est entre -127 et 128.
- L'autoboxing utilise Long.valueOf() (si je me souviens bien), donc il n'y aurait pas de différence du tout. Mon commentaire était en réponse à la réponse, pas à votre commentaire.
- Et attention aux accidentellement écrit a == b de comparer les deux en boîte valeurs! Apparaîtra à travailler si elles sont dans le "stage" de la gamme, ne va pas si pas. Et la gamme est un minimum de -128 à 127, mais peut-être plus. (Je pense que c'est vrai, on dirait que j'ai tapé à l'envers dans mon dernier commentaire).
- ah je vois, merci. @Earwicker: - je l'audace de suggérer qu'il y a certaines informations dans ces commentaires qui permettrait de gagner votre réponse au moins un autre +1, s'il devait être inclus? 🙂
- merci, mais serait probablement plus de sens sur une question à propos de ce que l'autoboxing est équivalent, par exemple, vous pourriez upvote cette réponse: stackoverflow.com/questions/766468/...
InformationsquelleAutor Daniel Earwicker
179

Utiliser les éléments suivants: Long.valueOf(int);.
- Est-il une telle méthode?
- Il y a Longtemps.valueOf(long), qui travaille pour les int en tant que bien.
- Attention, car cela va générer une exception NullPointerException si vous recevez un objet Integer qui est nulle.
- correct si suis wron j'ai pensé que peut-être la réponse est vieux becuse je ne peux pas trouver la méthode la Long.valueOf(int) !!
- une primitive int variable ne peut pas être null.
- voir serg commentaire - mais je pense que cette méthode jette l'int d'une longue qui autoboxes avec une Longue... donc, semble redondant
- un Integer, c'est ce qu'il a dit.
- de toute façon, c'est un leurre: si un Entier a été reçu ensuite un nullpointer ne serait pas généré par cet appel, mais par la tentative pour obtenir le nombre dans la primitive: longue (Long.valueOf(int) n'existe pas)
InformationsquelleAutor serg
14

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

utilisation

new Long(your_integer);

Long.valueOf(your_integer);

InformationsquelleAutor User User

5

J'ai ce petit jouet, qui traite également avec les interfaces génériques.
Je suis OK avec lui jetant un ClassCastException si l'alimentation de mal (OK et heureux)
```
public class TypeUtil {
    public static long castToLong(Object o) {
        Number n = (Number) o;
        return n.longValue();
    }
}
```
InformationsquelleAutor Maxim Veksler
4

En Java que vous pouvez faire:
```
 int myInt=4;
 Long myLong= new Long(myInt);
```
dans votre cas, il serait:
```
content.setSequence(new Long(i));
```
InformationsquelleAutor cloudy_weather

Nous aurons le long de la valeur à l'aide de Number de référence.

public static long toLong(Number number){
    return number.longValue();
}

Il fonctionne pour tous les types de numéro, voici un test:

public static void testToLong() throws Exception {
    assertEquals(0l, toLong(0));   //an int
    assertEquals(0l, toLong((short)0)); //a short
    assertEquals(0l, toLong(0l)); //a long
    assertEquals(0l, toLong((long) 0)); //another long
    assertEquals(0l, toLong(0.0f));  //a float
    assertEquals(0l, toLong(0.0));  //a double

}

InformationsquelleAutor Thamme Gowda

2

Comment Sur
```
int myInt = 88;
```
//Ne compile pas
```
Long myLong = myInt;
```
//Compile, et conserve la non-NULL esprit de int. Le meilleur cast est pas de fonte à tous les. Bien sûr, votre cas d'utilisation peut nécessiter de Longues et possible, les valeurs NULL. Mais si l'int, ou d'autres longs sont votre seule entrée, et votre méthode peut être modifiée, je vous suggère cette approche.
```
long myLong = myInt;
```
//Compile, est le moyen le plus efficace, et il est clair que la valeur de la source, est et ne sera jamais NULLE.
```
Long myLong = (long) myInt;
```
InformationsquelleAutor Steven Spungin
2
```
 1,new Long(intValue);
 2,Long.valueOf(intValue);
```
- Ce n'est pas de fournir une réponse à la question. Une fois que vous avez suffisamment de réputation vous serez en mesure de commentaire sur post; au lieu de cela, fournir des réponses qui ne nécessitent pas de clarification de la asker. - Revue
- Je ne me suis pas clair
InformationsquelleAutor Vicky
1

J'ai eu beaucoup de mal avec cela. Je voulais juste:
```
thisBill.IntervalCount = jPaidCountSpinner.getValue();
```
Où IntervalCount est Longue, et la JSpinner était le retour d'une Longue. Finalement, j'ai eu à écrire cette fonction:
```
    public static final Long getLong(Object obj) throws IllegalArgumentException {
    Long rv;

    if((obj.getClass() == Integer.class) || (obj.getClass() == Long.class) || (obj.getClass() == Double.class)) {
        rv = Long.parseLong(obj.toString());
    }
    else if((obj.getClass() == int.class) || (obj.getClass() == long.class) || (obj.getClass() == double.class)) {
        rv = (Long) obj;
    }
    else if(obj.getClass() == String.class) {
        rv = Long.parseLong(obj.toString());
    }
    else {
        throw new IllegalArgumentException("getLong: type " + obj.getClass() + " = \"" + obj.toString() + "\" unaccounted for");
    }

    return rv;
}
```
qui semble faire l'affaire. Aucun montant de la fonderie simple, aucune des deux solutions n'a fonctionné pour moi. Très frustrant.
- si jPaidCountSpinner.getValue() retourne un Objet qui est en fait un Long, vous avez certainement besoin seulement de mettre un (Long) fonte en face. Essayer aussi de mettre un point d'arrêt sur votre chèque de int.class ou long.class etc. Ne jamais frapper? Et si vous avez un certain nombre-comme l'objet, il soutiendra java.util.Number, afin de le jeter et appeler la longValue méthode. Pas besoin de passer par l'intermédiaire d'une chaîne de caractères dans ce cas. De sorte que cette fonction pourrait être simplifié un peu, même si vous avez également besoin de traiter avec des chaînes. (Partie du problème ici, c'est le revers de la documentation de référence pour JSpinner).
- J'ai moi aussi fini par faire quelque chose comme cela. Je n'étais pas sûr de ce genre de numéro, je voudrais recevoir et était prêt à le convertir à la Longue avec peu de souci de l'efficacité, mais veulent éviter une passe-partout.
InformationsquelleAutor MaskedCoder

 //Suppose you have int and you wan to convert it to Long
 int i=78;
 //convert to Long
 Long l=Long.valueOf(i)

InformationsquelleAutor Virendra Singh

0

Dès qu'il existe une seule méthode Long.valueOf(long), fonte de int à long sera fait de façon implicite dans le cas de l'utilisation Long.valueOf(intValue).

Le plus clair façon de le faire est
```
Integer.valueOf(intValue).longValue()
```
InformationsquelleAutor Стас Цепа

Vous devez vous connecter pour publier un commentaire.