Diffuser en toute sécurité du long vers l'int en Java

Quelle est la manière la plus idiomatique en Java pour vérifier qu'une distribution de longà intne perd aucune information?

Voici ma mise en œuvre actuelle:

public static int safeLongToInt(long l) {
    int i = (int)l;
    if ((long)i != l) {
        throw new IllegalArgumentException(l + " cannot be cast to int without changing its value.");
    }
    return i;
}

Pour cela, une nouvelle méthode a été ajoutée avec Java 8 .

import static java.lang.Math.toIntExact;

long foo = 10L;
int bar = toIntExact(foo);

Va jeter un ArithmeticExceptionen cas de débordement.

Voir: Math.toIntExact(long)

Plusieurs autres méthodes de sécurité anti-débordement ont été ajoutées à Java 8. Elles se terminent par exact .

Exemples:

• Math.incrementExact(long)
• Math.subtractExact(long, long)
• Math.decrementExact(long)
• Math.negateExact(long),
• Math.subtractExact(int, int)

Je pense que je le ferais aussi simplement que:

public static int safeLongToInt(long l) {
    if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
        throw new IllegalArgumentException
            (l + " cannot be cast to int without changing its value.");
    }
    return (int) l;
}

Je pense que cela exprime l'intention plus clairement que le casting répété ... mais c'est quelque peu subjectif.

Note d'intérêt potentiel - en C # ce serait juste:

return checked ((int) l);

Avec la classe Ints de Google Guava , votre méthode peut être modifiée en:

public static int safeLongToInt(long l) {
    return Ints.checkedCast(l);
}

À partir des documents liés:

vérifiéCast

public static int checkedCast(long value)

Renvoie la valeur int qui est égale à value, si possible.

Paramètres: value - toute valeur dans la plage du inttype

Renvoie: la intvaleur égale àvalue

Lance: IllegalArgumentException - si valueest supérieur Integer.MAX_VALUEou inférieur àInteger.MIN_VALUE

Soit safeLongToIntdit en passant , vous n'avez pas besoin de l' encapsuleur, sauf si vous voulez le laisser en place pour modifier la fonctionnalité sans refactorisation approfondie bien sûr.

Avec BigDecimal:

long aLong = ...;
int anInt = new BigDecimal(aLong).intValueExact(); // throws ArithmeticException
                                                   // if outside bounds

voici une solution, au cas où vous ne vous souciez pas de la valeur au cas où elle serait plus grande que nécessaire;)

public static int safeLongToInt(long l) {
    return (int) Math.max(Math.min(Integer.MAX_VALUE, l), Integer.MIN_VALUE);
}

DONT: Ce n'est pas une solution!

Ma première approche a été:

public int longToInt(long theLongOne) {
  return Long.valueOf(theLongOne).intValue();
}

Mais cela ne fait que convertir le long en un entier, créant potentiellement de nouvelles Longinstances ou les récupérant du pool Long.

Les inconvénients

1. Long.valueOfcrée une nouvelle Longinstance si le nombre ne se trouve pas dans Longla plage du pool de [-128, 127].

2. L' intValueimplémentation ne fait rien de plus que:

   return (int)value;

Cela peut donc être considéré comme pire que de simplement lancer le longto int.

Je prétends que la façon évidente de voir si la conversion d'une valeur a changé la valeur serait de convertir et de vérifier le résultat. Je voudrais cependant supprimer le casting inutile lors de la comparaison. Je ne suis pas non plus trop intéressé par les noms de variables à une lettre (exception xet y, mais pas quand ils signifient ligne et colonne (parfois respectivement)).

public static int intValue(long value) {
    int valueInt = (int)value;
    if (valueInt != value) {
        throw new IllegalArgumentException(
            "The long value "+value+" is not within range of the int type"
        );
    }
    return valueInt;
}

Cependant, je voudrais vraiment éviter cette conversion si possible. Évidemment, ce n'est parfois pas possible, mais dans ces cas, IllegalArgumentExceptionc'est presque certainement la mauvaise exception à lancer en ce qui concerne le code client.

Les types d'entiers Java sont représentés comme signés. Avec une entrée entre 2 ³¹ et 2 ³² (ou -2 ³¹ et -2 ³² ), le lancer réussirait mais votre test échouerait.

Ce qu'il faut vérifier est de savoir si tous les bits hauts du longsont tous les mêmes:

public static final long LONG_HIGH_BITS = 0xFFFFFFFF80000000L;
public static int safeLongToInt(long l) {
    if ((l & LONG_HIGH_BITS) == 0 || (l & LONG_HIGH_BITS) == LONG_HIGH_BITS) {
        return (int) l;
    } else {
        throw new IllegalArgumentException("...");
    }
}

(int) (longType + 0)

mais Long ne peut pas dépasser le maximum :)

Une autre solution peut être:

public int longToInt(Long longVariable)
{
    try { 
            return Integer.valueOf(longVariable.toString()); 
        } catch(IllegalArgumentException e) { 
               Log.e(e.printstackstrace()); 
        }
}

J'ai essayé ceci pour les cas où le client fait un POST et la base de données du serveur ne comprend que les entiers alors que le client a un Long.