Как правильно сравнивать длинные и плавающие примитивы?

Question

По какой-то причине мне нужно сравнить два примитива: long и float.

Могу ли я использовать следующий код для этого?

long a = 111L; 
float b = 111.1f 

if (a > b) { 
    ... 
} 

Я знаю, что поплавок и поплавок можно сравнить с некоторой точностью с использованием значения эпсилон и т.д.

Но как я могу выполнить сравнение для моего случая более правильно?

Спасибо всем.

Answer 1

Вы можете обернуть их обоих в BigDecimal и их сравнить их:

long a = 111L; 
float b = 111.1f; 
BigDecimal first = new BigDecimal(a); 
BigDecimal second = new BigDecimal(b, MathContext.DECIMAL32); 
if (first.compareTo(second) > 0) { ... } 

Для того, чтобы понять, почему мы заинтересованы иметь как операндов под того же типа, давайте копать немного в JLS 5.6.2 Binary Numeric Promotion:

Когда оператор применяет двоичного цифрового продвижение к паре операндов, каждый из которых должен обозначать значение, которое является обратимым в NUM тип Эрика, применяются следующие правила, в следующем порядке:

1. Если какие-либо из операндов имеют ссылочный типа, он подвергается распаковке преобразования (§5.1.8).

2. примитивные преобразования Добавления новое (§5.1.2) применяются для преобразования либо или оба операнда, как указано по следующим правилам:

   • Если один из операндов имеют типа double, другой преобразуются в double.

   • В противном случае, если один из операндов имеет тип float, другой преобразуется в float.

   • В противном случае, если один из операндов имеет тип long, другой преобразуется в long.

   • В противном случае оба операнда преобразуются в тип int.

С этим можно сделать вывод, что для сравнения a > blong операнд будет неявно повышен до float.Это, однако, может в конечном итоге с потерей точности, как указано в JLS 5.1.2 Widening primitive conversion:

расширяющейся Превращение int или значение long для float или длинного значения в два раза, может привести к потере точность - то есть результат может потерять часть наименее значимых бит значения. В этом случае результирующее значение с плавающей запятой будет правильно округленной версией целочисленного значения с использованием режима IEEE 754, близкого к ближайшему, (§4.2.4).

Answer 2

Если вы хотите использовать эпсилон вы можете сделать

// allow for the smallest rounding error 
if (a > b + Math.sign(b) * Float.ulp(b)) 

или

// assume six digits of precision 
static final double ERR = 1e-6; 

// allow for the smallest rounding error 
if (a > b + Math.sign(b) * b * ERR) 

Вы можете оставить Math.sign (б), если можно предположить, неотрицательные числа.

Однако использование BigDecimal может быть более ясным в этом случае, см. Ответ @ kocko.

BTW: Простейшее изменение, которое повысит вашу точность, заключается в использовании double вместо float. double буквально полмиллиарда раз более точен, и если у вас нет миллиарда из них, то извлеченная память, которую вы используете, не имеет значения.

Answer 3

Сравнение longs и floats напрямую поддерживается Java. Однако есть некоторые оговорки:

Если вы сравниваете длинный и плавающий, длинный преобразуется в поплавок, потому что float считается более широким, чем длинный. Однако это преобразование может потерять точность: длинное значение будет передано в ближайшее значение float; поэтому для длинного a и поплавок b, a > b может быть ложным, хотя a больше b, если b - фактически значение поплавка, ближайшее к b.

Каждый длинный и поплавок значение может быть представлено BigDecimal, так что вы можете также использовать BigDecimal класс для сравнения длинный в поплавок:

long a = ...; 
float b = ...; 
if (BigDecimal.valueOf(a).compareTo(BigDecimal.valueOf(b)) > 0) { 
    ... 
}