Unterschied zwischen if (a - b <0) und if (a <b)

Ich las Javas ArrayListQuellcode und bemerkte einige Vergleiche in if-Anweisungen.

In Java 7 werden die Verfahren grow(int)Verwendungen

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

In Java 6 grownicht vorhanden. Die Methode verwendet ensureCapacity(int)jedoch

if (newCapacity < minCapacity)
    newCapacity = minCapacity;

Was war der Grund für die Änderung? War es ein Leistungsproblem oder nur ein Stil?

Ich könnte mir vorstellen, dass der Vergleich mit Null schneller ist, aber eine vollständige Subtraktion durchzuführen, um zu überprüfen, ob sie negativ ist, scheint mir ein bisschen übertrieben. Auch in Bezug auf den Bytecode würde dies zwei Anweisungen ( ISUBund IF_ICMPGE) anstelle von einer ( IFGE) beinhalten.

a < bund a - b < 0kann zwei verschiedene Dinge bedeuten. Betrachten Sie den folgenden Code:

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

Beim Ausführen wird nur gedruckt a - b < 0. Was passiert ist, dass a < bdas eindeutig falsch ist, aber a - büberläuft und wird -1, was negativ ist.

Bedenken Sie nun, dass das Array eine Länge hat, die wirklich nahe liegt Integer.MAX_VALUE. Der Code in ArrayListlautet wie folgt:

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

oldCapacityist wirklich nah an Integer.MAX_VALUEso newCapacity(was ist oldCapacity + 0.5 * oldCapacity) könnte überlaufen und werden Integer.MIN_VALUE(dh negativ). Dann subtrahiert man die minCapacity Unterläufe zurück in eine positive Zahl.

Diese Prüfung stellt sicher, dass die if nicht ausgeführt wird. Wenn der Code als geschrieben if (newCapacity < minCapacity)wäre, wäre es truein diesem Fall (da newCapacityist negativ), so dass der newCapacitygezwungen wäre, minCapacityunabhängig von der oldCapacity.

Dieser Überlauffall wird vom nächsten if behandelt. Wenn newCapacityübergelaufen ist, ist dies true: MAX_ARRAY_SIZEdefiniert alsInteger.MAX_VALUE - 8 und Integer.MIN_VALUE - (Integer.MAX_VALUE - 8) > 0ist true. Das newCapacitywird daher richtig gehandhabt: hugeCapacityMethode gibt MAX_ARRAY_SIZEoder zurück Integer.MAX_VALUE.

NB: das ist was die // overflow-conscious code Kommentar in dieser Methode sagt.

Ich habe diese Erklärung gefunden :

Am Dienstag, den 9. März 2010 um 03:02 Uhr schrieb Kevin L. Stern:

Ich habe eine schnelle Suche durchgeführt und es scheint, dass Java tatsächlich auf zwei Komplementen basiert. Gestatten Sie mir dennoch, darauf hinzuweisen, dass mich diese Art von Code im Allgemeinen beunruhigt, da ich davon ausgehe, dass irgendwann jemand vorbeikommt und genau das tut, was Dmytro vorgeschlagen hat. das heißt, jemand wird sich ändern:

if (a - b > 0)

zu

if (a > b)

und das ganze Schiff wird sinken. Ich persönlich möchte Unklarheiten vermeiden, z. B. den Überlauf von Ganzzahlen zu einer wesentlichen Grundlage für meinen Algorithmus zu machen, es sei denn, es gibt einen guten Grund dafür. Im Allgemeinen würde ich es vorziehen, einen Überlauf insgesamt zu vermeiden und das Überlaufszenario deutlicher zu machen:

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

Das ist ein guter Punkt.

In können ArrayListwir das nicht (oder zumindest nicht kompatibel) machen, weil ensureCapacity es sich um eine öffentliche API handelt und negative Zahlen effektiv bereits als Anforderungen für eine positive Kapazität akzeptiert, die nicht erfüllt werden kann.

Die aktuelle API wird folgendermaßen verwendet:

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

Wenn Sie einen Überlauf vermeiden möchten, müssen Sie zu etwas weniger Natürlichem wechseln

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

Wie auch immer, ich behalte den überlaufbewussten Code bei, füge aber weitere Warnkommentare hinzu und "skizziere" die Erstellung riesiger Arrays, sodass der ArrayListCode jetzt wie folgt aussieht:

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

Martin

Wenn Sie in Java 6 die API verwenden als:

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

Und newCountÜberläufe (dies wird negativ) if (minCapacity > oldCapacity)geben false zurück und Sie können fälschlicherweise annehmen, dass der Wert um ArrayListerhöht wurde len.

Den Code betrachten:

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

Wenn oldCapacityes ziemlich groß ist, läuft es über und newCapacityist eine negative Zahl. Ein Vergleich wie newCapacity < oldCapacitywird falsch bewertet trueund der ArrayListwird nicht wachsen.

Stattdessen ermöglicht der geschriebene Code ( newCapacity - minCapacity < 0gibt false zurück), dass der negative Wert von newCapacityin der nächsten Zeile weiter ausgewertet wird, was zu einer Neuberechnung newCapacitydurch Aufrufen von hugeCapacity( newCapacity = hugeCapacity(minCapacity);) führt, damit der Wert bis zu ArrayListwachsen kann MAX_ARRAY_SIZE.

Dies ist, was der // overflow-conscious codeKommentar zu kommunizieren versucht, wenn auch eher schräg.

Unterm Strich schützt der neue Vergleich also davor, einen ArrayListgrößeren als den vordefinierten zuzuweisenMAX_ARRAY_SIZE während es bei Bedarf bis zu diesem Grenzwert wachsen kann.

Die beiden Formen verhalten sich genau gleich, es sei denn, der Ausdruck a - bläuft über. In diesem Fall sind sie entgegengesetzt. Wenn aes ein großes Negativ und bein großes Positiv ist, dann (a < b)ist dies eindeutig wahr, wird aber a - büberlaufen, um positiv zu werden(a - b < 0) ist daher falsch.

Wenn Sie mit x86-Assemblycode vertraut sind, beachten Sie, dass dieser (a < b)durch a implementiert wird jge, der sich um den Hauptteil der if-Anweisung verzweigt, wenn SF = OF. Auf der anderen Seite verhält es sich (a - b < 0)wie a jns, das sich verzweigt, wenn SF = 0. Daher verhalten sich diese genau anders, wenn OF = 1.