Transmitindo com segurança por muito tempo para int em Java

Qual é a maneira mais idiomática em Java para verificar se uma conversão de longpara intnão perde nenhuma informação?

Esta é minha implementação atual:

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;
}

Um novo método foi adicionado ao Java 8 para fazer exatamente isso.

import static java.lang.Math.toIntExact;

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

Jogará um ArithmeticExceptionem caso de estouro.

Vejo: Math.toIntExact(long)

Vários outros métodos seguros de estouro foram adicionados ao Java 8. Eles terminam com exatidão .

Exemplos:

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

Eu acho que faria isso simplesmente:

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;
}

Eu acho que expressa a intenção mais claramente do que o elenco repetido ... mas é um pouco subjetivo.

Nota de interesse em potencial - em C # seria apenas:

return checked ((int) l);

Com a classe Ints do Google Guava , seu método pode ser alterado para:

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

Dos documentos vinculados:

CheckerCast

public static int checkedCast(long value)

Retorna o valor int igual a value , se possível.

Parâmetros: value - qualquer valor na faixa doint tipo

Retorna: o intvalor igual avalue

Lança: IllegalArgumentException - se valuefor maior Integer.MAX_VALUEou menor queInteger.MIN_VALUE

Aliás, você não precisa do safeLongToIntwrapper, a menos que queira deixá-lo no lugar para alterar a funcionalidade sem refatoração extensiva, é claro.

Com BigDecimal:

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

aqui está uma solução, caso você não se importe com valor, caso seja maior que o necessário;)

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

NÃO: Esta não é uma solução!

Minha primeira abordagem foi:

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

Mas isso apenas converte o long para um int, potencialmente criando novas Longinstâncias ou recuperando-as do pool Long.

As desvantagens

1. Long.valueOfcria uma nova Longinstância se o número não estiver dentro Longdo intervalo do pool [-128, 127].

2. A intValueimplementação nada mais faz do que:

   return (int)value;

Portanto, isso pode ser considerado ainda pior do que apenas lançar o longpara int.

Afirmo que a maneira óbvia de ver se a conversão de um valor alterou o valor seria lançar e verificar o resultado. No entanto, eu removeria o elenco desnecessário ao comparar. Também não gosto muito de nomes de variáveis ​​de uma letra (exceção xe y, mas não quando eles significam linha e coluna (às vezes respectivamente)).

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;
}

No entanto, eu realmente gostaria de evitar essa conversão, se possível. Obviamente, às vezes não é possível, mas nesses casos IllegalArgumentExceptioné quase certamente a exceção errada a ser lançada no que diz respeito ao código do cliente.

Os tipos inteiros Java são representados como assinados. Com uma entrada entre 2 ³¹ e 2 ³² (ou -2 ³¹ e -2 ³² ), o elenco terá êxito, mas seu teste falhará.

O que verificar é se todos os bits altos do longsão todos iguais:

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)

mas Long não pode exceder o máximo :)

Uma outra solução pode ser:

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

Eu tentei isso nos casos em que o cliente está executando um POST e o banco de dados do servidor entende apenas números inteiros enquanto o cliente possui um Long.