Сравнение значений двух универсальных Чисел

System.out.println(new BigDecimal(0.1d).toPlainString());
System.out.println(BigDecimal.valueOf(0.1d).toPlainString());
System.out.println(BigDecimal.valueOf(0.1f).toPlainString());
System.out.println(Float.valueOf(0.1f).toString());
System.out.println(Float.valueOf(0.1f).doubleValue());

if(yourNumber instanceof Double) {
    boolean greaterThanOtherNumber = yourNumber.doubleValue() > otherNumber.doubleValue();
    // [...]
}

Примечание: Проверка instanceof не обязательно нужна - зависит от того, как именно вы хотите их сравнивать. Конечно, вы можете просто всегда использовать .doubleValue () , так как каждое Number должно предоставлять методы, перечисленные здесь .

Изменить : Как указано в комментариях, вам (всегда) придется проверять BigDecimal и друзей. Но они предоставляют метод .compareTo () :

if(yourNumber instanceof BigDecimal && otherNumber instanceof BigDecimal) { 
    boolean greaterThanOtherNumber = ((BigDecimal)yourNumber).compareTo((BigDecimal)otherNumber) > 0;
} 

Предположим, у вас есть такой метод, как:

public <T extends Number> T max (T a, T b) {
   ...
   //return maximum of a and b
}

Если вы знаете, что в качестве параметров можно передавать только целые числа, длинные и двойные числа, тогда вы можете изменить сигнатуру метода на:

public <T extends Number> T max(double a, double b) {
   return (T)Math.max (a, b);
}

Это будет работать для байтов, коротких , целое, длинное и двойное.

Если вы предполагаете, что BigInteger или BigDecimal или смесь чисел с плавающей запятой и двойных чисел могут быть переданы, то вы не можете создать один общий метод для сравнения всех этих типов параметров.

Если ваши экземпляры Number never Atomic (т.е. AtomicInteger), то вы можете сделать что-то вроде:

private Integer compare(Number n1, Number n2) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

 Class<? extends Number> n1Class = n1.getClass();
 if (n1Class.isInstance(n2)) {
  Method compareTo = n1Class.getMethod("compareTo", n1Class);
  return (Integer) compareTo.invoke(n1, n2);
 }

 return -23;
}

Это так все неатомные числа реализуют Comparable

EDIT :

Это дорого из-за отражения: я знаю

EDIT 2 :

Это, конечно, не принимать во внимание случай, в котором вы хотите сравнить десятичные дроби с целыми числами или что-то в этом роде ...

РЕДАКТИРОВАТЬ 3 :

Это предполагает, что нет определенных пользователем потомков Number, которые не реализуют Comparable ( спасибо @DJClayworth)

Самый "общий" примитивный номер Java - двойной, поэтому в большинстве случаев достаточно просто

a.doubleValue() > b.doubleValue()

, но ... есть тонкие проблемы здесь при преобразовании чисел в двойные. Например, с BigInteger возможно следующее:

    BigInteger a = new BigInteger("9999999999999992");
    BigInteger b = new BigInteger("9999999999999991");
    System.out.println(a.doubleValue() > b.doubleValue());
    System.out.println(a.doubleValue() == b.doubleValue());

приводит к:

false
true

Хотя я ожидаю, что это будет очень крайний случай, но это возможно. И нет - универсального 100% точного способа не существует. У числового интерфейса нет метода преобразования точного значения () в некоторый тип, который мог бы идеально представлять число без потери какой-либо информации.

На самом деле иметь такие совершенные числа невозможно вообще - например, представление числа Пи невозможно с помощью какой-либо арифметики с использованием конечного пространства.

А что насчет этого? Определенно нехорошо, но он касается всех упомянутых необходимых случаев.

public class SimpleNumberComparator implements Comparator<Number>
    {
        @Override
        public int compare(Number o1, Number o2)
        {
            if(o1 instanceof Short && o2 instanceof Short)
            {
                return ((Short) o1).compareTo((Short) o2);
            }
            else if(o1 instanceof Long && o2 instanceof Long)
            {
                return ((Long) o1).compareTo((Long) o2);
            }
            else if(o1 instanceof Integer && o2 instanceof Integer)
            {
                return ((Integer) o1).compareTo((Integer) o2);
            }
            else if(o1 instanceof Float && o2 instanceof Float)
            {
                return ((Float) o1).compareTo((Float) o2);
            }
            else if(o1 instanceof Double && o2 instanceof Double)
            {
                return ((Double) o1).compareTo((Double) o2);
            }
            else if(o1 instanceof Byte && o2 instanceof Byte)
            {
                return ((Byte) o1).compareTo((Byte) o2);
            }
            else if(o1 instanceof BigInteger && o2 instanceof BigInteger)
            {
                return ((BigInteger) o1).compareTo((BigInteger) o2);
            }
            else if(o1 instanceof BigDecimal && o2 instanceof BigDecimal)
            {
                return ((BigDecimal) o1).compareTo((BigDecimal) o2);
            }
            else
            {
                throw new RuntimeException("Ooopps!");
            }

        }

    }

Вы можете просто использовать метод doubleValue () Number, чтобы сравнить их; однако вы можете обнаружить, что результаты недостаточно точны для ваших нужд.