Різниця між if (a - b <0) та if (a <b)

Я читав ArrayListвихідний код Java і помітив деякі порівняння у if-операторах.

У Java 7 grow(int)використовується метод

if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;

У Java 6 growне існувало. Однак метод ensureCapacity(int)використовує

if (newCapacity < minCapacity)
    newCapacity = minCapacity;

Що було причиною змін? Це було питання про виставу чи просто стиль?

Я міг би уявити, що порівняння проти нуля швидше, але виконання повного віднімання просто для того, щоб перевірити, чи це негатив, здається мені трохи надмірним. Також з точки зору байт-коду, це передбачає дві інструкції ( ISUBі IF_ICMPGE) замість однієї ( IFGE).

a < bі a - b < 0може означати дві різні речі. Розглянемо наступний код:

int a = Integer.MAX_VALUE;
int b = Integer.MIN_VALUE;
if (a < b) {
    System.out.println("a < b");
}
if (a - b < 0) {
    System.out.println("a - b < 0");
}

Під час запуску це буде тільки друкувати a - b < 0. Що відбувається, a < bце явно помилково, але a - bпереповнює і стає -1, що є негативним.

Тепер, сказавши це, врахуйте, що масив має довжину, яка насправді близька Integer.MAX_VALUE. Код у ArrayListйде так:

int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);

oldCapacityдійсно близький до Integer.MAX_VALUEтого, що newCapacity(що є oldCapacity + 0.5 * oldCapacity) може переповнитися і стати Integer.MIN_VALUE(тобто негативним). Потім віднімання minCapacity підтіків повертається в додатне число.

Ця перевірка гарантує, що ifвона не виконується. Якби код був написаний так if (newCapacity < minCapacity), він був би trueв цьому випадку (оскільки newCapacityє негативним), тому newCapacityвін буде змушений робити minCapacityнезалежно від oldCapacity.

Цей випадок переповнення обробляється наступним, якщо. Коли newCapacityпереповнюється, це буде true: MAX_ARRAY_SIZEвизначається як Integer.MAX_VALUE - 8і Integer.MIN_VALUE - (Integer.MAX_VALUE - 8) > 0є true. newCapacityТому правильно обробляються: hugeCapacityметод повертає MAX_ARRAY_SIZEабо Integer.MAX_VALUE.

NB: Про це говорить // overflow-conscious codeкоментар у цьому методі.

Я знайшов таке пояснення :

У вівторок, 9 березня 2010 року о 03:02, Кевін Л. Стерн написав:

Я швидко здійснив пошук, і, здається, що Java справді заснована на двох. Тим не менш, дозвольте мені зазначити, що в цілому цей тип коду хвилює мене, оскільки я повністю сподіваюся, що в якийсь момент хтось підійде і зробить саме те, що запропонував Дмитро; тобто хтось змінить:

if (a - b > 0)

до

if (a > b)

і весь корабель затопить. Мені особисто подобається уникати незрозумілих цінностей, таких як переповнення цілого числа, що є важливою основою мого алгоритму, якщо для цього немає вагомих причин. Я б взагалі вважав за краще уникати переповнення і робити сценарій переповнення більш чітким:

if (oldCapacity > RESIZE_OVERFLOW_THRESHOLD) {
   // Do something
} else {
  // Do something else
}

Це хороший момент.

В ArrayListми не можемо зробити це (або , по крайней мере , не сумісне), оскільки ensureCapacityє публічною API і ефективно вже приймає негативні числа як запити позитивного потенціалу , який не може бути задоволений.

Поточний API використовується так:

int newcount = count + len;
ensureCapacity(newcount);

Якщо ви хочете уникнути переповнення, вам потрібно буде перейти на щось менш природне, як

ensureCapacity(count, len);
int newcount = count + len;

У будь-якому випадку, я зберігаю переповнюваний код, але додаю більше попереджувальних коментарів та створюю величезний масив "накреслюючи" так, що ArrayListкод тепер виглядає так:

/**
 * Increases the capacity of this <tt>ArrayList</tt> instance, if
 * necessary, to ensure that it can hold at least the number of elements
 * specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
public void ensureCapacity(int minCapacity) {
    modCount++;

    // Overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
 * The maximum size of array to allocate.
 * Some VMs reserve some header words in an array.
 * Attempts to allocate larger arrays may result in
 * OutOfMemoryError: Requested array size exceeds VM limit
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    // Overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);

    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

Webrev відроджується.

Мартін

У Java 6, якщо ви використовуєте API як:

int newcount = count + len;
ensureCapacity(newcount);

І newCountпереповнення (це стає негативним) if (minCapacity > oldCapacity)повернеться помилковим, і ви можете помилково припустити, що значення ArrayListбуло збільшене на len.

Дивлячись на код:

int newCapacity = oldCapacity + (oldCapacity >> 1);

Якщо oldCapacityвін досить великий, це переповниться, і newCapacityце буде від’ємне число. Порівняння на зразок newCapacity < oldCapacityбуде неправильно оцінено, trueі ArrayListволя не зможе зростати.

Натомість код, записаний ( newCapacity - minCapacity < 0повертає помилкове), дозволить newCapacityдодатково оцінити негативне значення у наступному рядку, в результаті чого перерахунок newCapacityза допомогою виклику hugeCapacity( newCapacity = hugeCapacity(minCapacity);) дозволить ArrayListзростати до MAX_ARRAY_SIZE.

Це те, що // overflow-conscious codeкоментар намагається донести, хоча досить косо.

Отже, підсумок , нове порівняння захищає від виділення ArrayListбільшого за попередньо визначене MAX_ARRAY_SIZE, дозволяючи йому зростати аж до цієї межі, якщо потрібно.

Дві форми поводяться абсолютно однаково, якщо вираз не a - bпереповнює, і в цьому випадку вони протилежні. Якщо aвеликий негатив і bвеликий позитив, то (a < b)це явно вірно, але a - bпереповниться, щоб стати позитивним, так (a - b < 0)це помилково.

Якщо ви знайомі з кодом асемблери x86, врахуйте, що (a < b)реалізований a jge, який розгалужується навколо тіла оператора if, коли SF = OF. З іншого боку, він (a - b < 0)буде діяти як a jns, який розгалужується, коли SF = 0. Отже, вони поводяться по-різному точно, коли OF = 1.