Differenza tra if (a - b <0) e if (a <b)

Stavo leggendo il ArrayListcodice sorgente di Java e ho notato alcuni confronti nelle dichiarazioni if.

In Java 7, il metodo grow(int)utilizza

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

In Java 6, grownon esisteva. Il metodo ensureCapacity(int)tuttavia utilizza

if (newCapacity < minCapacity)
    newCapacity = minCapacity;

Qual è stato il motivo del cambiamento? È stato un problema di prestazioni o solo uno stile?

Potrei immaginare che il confronto con lo zero sia più veloce, ma eseguire una sottrazione completa solo per verificare se è negativo mi sembra un po 'eccessivo. Anche in termini di bytecode, ciò implicherebbe due istruzioni ( ISUBe IF_ICMPGE) anziché una ( IFGE).

a < be a - b < 0può significare due cose diverse. Considera il seguente codice:

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

Quando eseguito, verrà stampato solo a - b < 0. Quello che succede è a < bchiaramente falso, ma a - btrabocca e diventa -1, il che è negativo.

Ora, detto questo, considera che l'array ha una lunghezza molto vicina Integer.MAX_VALUE. Il codice ArrayListentra in questo modo:

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è molto vicino a Integer.MAX_VALUEcosì newCapacity(che è oldCapacity + 0.5 * oldCapacity) potrebbe traboccare e diventare Integer.MIN_VALUE(cioè negativo). Quindi, sottraendo i minCapacity underflow ritorna in un numero positivo.

Questo controllo assicura che ifnon sia eseguito. Se il codice fosse scritto come if (newCapacity < minCapacity), sarebbe truein questo caso (poiché newCapacityè negativo), quindi newCapacitysarebbe costretto a minCapacityprescindere da oldCapacity.

Questo caso di overflow viene gestito dal successivo if. Quando newCapacitysarà traboccato, questo sarà true: MAX_ARRAY_SIZEè definito come Integer.MAX_VALUE - 8ed Integer.MIN_VALUE - (Integer.MAX_VALUE - 8) > 0è true. Il newCapacityè quindi giustamente gestito: hugeCapacitymetodo restituisce MAX_ARRAY_SIZEo Integer.MAX_VALUE.

NB: questo è ciò che // overflow-conscious codedice il commento in questo metodo.

Ho trovato questa spiegazione :

Martedì 9 marzo 2010 alle 03:02, Kevin L. Stern ha scritto:

Ho fatto una ricerca veloce e sembra che Java sia davvero basato sul complemento di due. Tuttavia, mi permetta di sottolineare che, in generale, questo tipo di codice mi preoccupa poiché mi aspetto pienamente che a un certo punto qualcuno verrà e farà esattamente ciò che Dmytro ha suggerito; cioè qualcuno cambierà:

if (a - b > 0)

per

if (a > b)

e l'intera nave affonderà. Personalmente, mi piace evitare oscurità come rendere il trabocco di numeri interi una base essenziale per il mio algoritmo, a meno che non ci siano buone ragioni per farlo. In generale, preferirei evitare del tutto l'overflow e rendere più esplicito lo scenario di overflow:

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

È un buon punto.

In ArrayListnon possiamo farlo (o almeno non in modo compatibile), perché ensureCapacityè un'API pubblica e accetta effettivamente numeri negativi come richieste per una capacità positiva che non può essere soddisfatta.

L'API corrente viene utilizzata in questo modo:

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

Se si desidera evitare il trabocco, è necessario passare a qualcosa di meno naturale

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

Ad ogni modo, sto mantenendo il codice attento all'overflow, ma aggiungendo altri commenti di avvertimento e "creando" un'enorme creazione di array in modo che ArrayListil codice ora assomigli a:

/**
 * 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 rigenerato.

balestruccio

In Java 6, se si utilizza l'API come:

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

E newCounttrabocca (questo diventa negativo), if (minCapacity > oldCapacity)restituirà falso e potresti erroneamente supporre che sia ArrayListstato aumentato di len.

Guardando il codice:

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

Se oldCapacityè abbastanza grande, questo traboccerà e newCapacitysarà un numero negativo. Un confronto come newCapacity < oldCapacityverrà valutato in modo errato truee ArrayListnon riuscirà a crescere.

Al contrario, il codice scritto ( newCapacity - minCapacity < 0restituisce false) consentirà di newCapacityvalutare ulteriormente il valore negativo di nella riga successiva, risultando nel ricalcolo newCapacityinvocando hugeCapacity( newCapacity = hugeCapacity(minCapacity);) per consentire la ArrayListcrescita MAX_ARRAY_SIZE.

Questo è ciò che il // overflow-conscious codecommento sta cercando di comunicare, anche se in modo piuttosto obliquo.

Quindi, in conclusione, il nuovo confronto protegge dall'allocazione di un valore ArrayListsuperiore a quello predefinito MAX_ARRAY_SIZE, consentendo al contempo di crescere fino a quel limite, se necessario.

Le due forme si comportano esattamente allo stesso modo a meno che l'espressione non a - btrabocchi, nel qual caso sono opposte. Se aè un grande negativo ed bè un grande positivo, allora (a < b)è chiaramente vero, ma a - btraboccerà per diventare positivo, quindi (a - b < 0)è falso.

Se hai familiarità con il codice assembly x86, considera che (a < b)è implementato da a jge, che si ramifica attorno al corpo dell'istruzione if quando SF = OF. D'altra parte, (a - b < 0)agirà come un jns, che si ramifica quando SF = 0. Quindi, questi si comportano in modo diverso precisamente quando OF = 1.