Comment convertir de int en Long en Java?

Je continue à trouver à la fois ici et les gens de Google ayant des problèmes allant de longla , intet non l'inverse. Pourtant, je suis sûr que je ne suis pas le seul à avoir rencontré ce scénario avant de passer de intà Long.

Les seules autres réponses que j'ai trouvées étaient "Il suffit de le définir comme Long en premier lieu", ce qui ne répond vraiment pas à la question.

J'ai d'abord essayé le casting mais j'obtiens 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 coincé à utiliser intcar certains contenus arrivent en tant que ArrayListet l'entité pour laquelle je stocke ces informations nécessite le numéro de séquence en tant que Long.

Notez qu'il existe une différence entre un cast vers longet un cast vers Long. Si vous transtypez en long(une valeur primitive), il doit alors être automatiquement encadré en un Long(le type de référence qui l'enveloppe).

Vous pouvez également utiliser newpour créer une instance de Long, l'initialiser avec la intvaleur.

Utilisez ce qui suit: Long.valueOf(int);.

Si vous avez déjà l'intégré comme entier, vous pouvez le faire:

Integer y = 1;
long x = y.longValue();

utilisation

new Long(your_integer);

ou

Long.valueOf(your_integer);

J'ai ce petit jouet, qui traite également des interfaces non génériques. Je suis d'accord avec le lancement d'une exception ClassCastException si le flux est incorrect (OK et heureux)

public class TypeUtil {
    public static long castToLong(Object o) {
        Number n = (Number) o;
        return n.longValue();
    }
}

En Java, vous pouvez faire:

 int myInt=4;
 Long myLong= new Long(myInt);

dans votre cas ce serait:

content.setSequence(new Long(i));

Que diriez-vous

int myInt = 88;

// Ne compile pas

Long myLong = myInt;

// Compile et conserve l'esprit non NULL de int. Le meilleur casting n'est pas du tout lancé . Bien sûr, votre cas d'utilisation peut nécessiter des valeurs NULL longues et possibles. Mais si l'int, ou d'autres longs sont votre seule entrée, et que votre méthode peut être modifiée, je suggère cette approche.

long myLong = myInt;

// Compile, est le moyen le plus efficace et indique clairement que la valeur source est et ne sera jamais NULL.

Long myLong = (long) myInt;

Nous obtiendrons la valeur longue en utilisant la Numberréférence.

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

Cela fonctionne pour tous les types de nombres, 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

}

 1,new Long(intValue);
 2,Long.valueOf(intValue);

J'ai eu beaucoup de mal avec ça. Je voulais juste:

thisBill.IntervalCount = jPaidCountSpinner.getValue();

Où IntervalCount est un Long et le JSpinner a été défini pour renvoyer un Long. Finalement, j'ai dû é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. Aucune quantité de casting simple, aucune des solutions ci-dessus n'a fonctionné pour moi. Très frustrant.

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

Dès qu'il n'y a qu'une méthode Long.valueOf(long), le cast de intà longse fera implicitement en cas d'utilisation Long.valueOf(intValue).

La façon la plus claire de le faire est

Integer.valueOf(intValue).longValue()