Почему не делает java.lang. Сопоставимая реализация числа? [дубликат]

Для ответа посмотрите ошибку Java bugparade 4414323 . Можно также найти, что обсуждение от comp.lang.java.programmer

заключает в кавычки от ответа Sun до отчета об ошибках с 2001:

Все "числа" не сопоставимы; сопоставимый предполагает, что общее упорядочивание чисел возможно. Это даже не верно для чисел с плавающей запятой; NaN (не число) не является ни меньше, чем, больше, чем, ни равный никакому значению с плавающей точкой, даже самому. {Плавание, дважды} .compare налагают общее упорядочивание, отличающееся от упорядочивания "<" с плавающей точкой; и "=" операторы. Кроме того, как в настоящее время реализовано, подклассы Числа только сопоставимы с другими экземплярами того же класса. Существуют другие случаи, как комплексные числа, где никакое стандартное общее упорядочивание не существует, хотя можно было быть определен. Короче говоря, сопоставим ли подкласс Числа, должен быть оставлен как решение для того подкласса.

Очень, вероятно, потому что это было бы довольно неэффективно для сравнения чисел - единственное представление, которому каждое Число может соответствовать для разрешения такого сравнения, был бы BigDecimal.

Вместо этого неатомарные подклассы Числа реализуют Сопоставимый самого.

Атомарные изменяемы, так не может реализовать атомарное сравнение.

для реализации сопоставимый на числе, необходимо было бы написать код для каждой пары подкласса. Его более легкое вместо этого, чтобы просто позволить подклассам реализовывать сопоставимый.

нет никакого stardard сравнения для Чисел различных типов. Однако можно записать собственный Компаратор и использовать его для создания TreeMap< Число, Объект>, TreeSet< Число> или Collections.sort (List< Число>, Компаратор) или Arrays.sort (Число [], Компаратор);

Мое предположение - то, что, не реализовывая Сопоставимый, это дает больше гибкости классам с реализацией для реализации его или нет. Все общие числа (Целое число, Долго, дважды, и т.д.) действительно реализуют Сопоставимый. Можно все еще назвать Collections.sort, пока сами элементы реализуют Сопоставимый.

Рассмотрение иерархии классов. Классы обертки как Длинный, Целочисленное, и т.д., реализуют Сопоставимый, т.е. Целое число сопоставимо с целым числом, и длинное сопоставимо с длинным, но Вы не можете смешать их. По крайней мере, с этой парадигмой дженериков. То, которое я предполагаю, отвечает на Ваш вопрос 'почему'.

byte (примитивный) int (примитивны). Примитивы имеют только одно значение за один раз.
правила проектирования Языка позволяет это.

int i = 255

// down cast primitive
(byte) i == -1

А Byte не Integer. Byte Number, и Integer Number. Number объекты могут иметь больше чем одно значение одновременно.

Integer iObject = new Integer(255);
System.out.println(iObject.intValue());   // 255
System.out.println(iObject.byteValue());  // -1

, Если Byte Integer и Integer, Number, Какое значение Вы будете использовать в compareTo(Number number1, Number number2) метод?

Вы можете использовать Transmorph для сравнения чисел, используя его класс NumberComparator.

NumberComparator numberComparator = new NumberComparator();
assertTrue(numberComparator.compare(12, 24) < 0);
assertTrue(numberComparator.compare((byte) 12, (long) 24) < 0);
assertTrue(numberComparator.compare((byte) 12, 24.0) < 0);
assertTrue(numberComparator.compare(25.0, 24.0) > 0);
assertTrue(numberComparator.compare((double) 25.0, (float) 24.0) > 0);
assertTrue(numberComparator.compare(new BigDecimal(25.0), (float) 24.0) > 0);

Напишите свой собственный компаратор

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

public class NumberComparator implements Comparator {
    @SuppressWarnings("unchecked")
    @Override
    public int compare(Number number1, Number number2) {
 if (((Object) number2).getClass().equals(((Object) number1).getClass())) {
     // both numbers are instances of the same type!
     if (number1 instanceof Comparable) {
  // and they implement the Comparable interface
  return ((Comparable) number1).compareTo(number2);
     }
 }
 // for all different Number types, let's check there double values
 if (number1.doubleValue() < number2.doubleValue())
     return -1;
 if (number1.doubleValue() > number2.doubleValue())
     return 1;
 return 0;
    }

    /**
     * DEMO: How to compare apples and oranges.
     */
    public static void main(String[] args) {
 ArrayList listToSort = new ArrayList();
 listToSort.add(new Long(10));
 listToSort.add(new Integer(1));
 listToSort.add(new Short((short) 14));
 listToSort.add(new Byte((byte) 10));
 listToSort.add(new Long(9));
 listToSort.add(new AtomicLong(2));
 listToSort.add(new Double(9.5));
 listToSort.add(new Double(9.0));
 listToSort.add(new Double(8.5));
 listToSort.add(new AtomicInteger(2));
 listToSort.add(new Long(11));
 listToSort.add(new Float(9));
 listToSort.add(new BigDecimal(3));
 listToSort.add(new BigInteger("12"));
 listToSort.add(new Long(8));
 System.out.println("unsorted: " + listToSort);
 Collections.sort(listToSort, new NumberComparator());
 System.out.println("sorted:   " + listToSort);
 System.out.print("Classes:  ");
 for (Number number : listToSort) {
     System.out.print(number.getClass().getSimpleName() + ", ");
 }
    }
}