ความแตกต่างระหว่าง 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;

อะไรคือเหตุผลที่อยู่เบื้องหลังการเปลี่ยนแปลง? มันเป็นปัญหาด้านประสิทธิภาพหรือเป็นสไตล์หรือไม่?

ฉันสามารถจินตนาการได้ว่าการเปรียบเทียบกับศูนย์นั้นเร็วกว่า แต่ทำการลบอย่างสมบูรณ์เพื่อตรวจสอบว่ามันเป็นลบหรือเปล่า นอกจากนี้ในแง่ของ bytecode นี้จะเกี่ยวข้องกับสองคำสั่ง ( 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จะถูกบังคับให้โดยไม่คำนึงถึงminCapacityoldCapacity

กรณีโอเวอร์โฟลว์นี้ได้รับการจัดการโดยถัดไปหาก เมื่อnewCapacityมี overflowed นี้จะtrue: MAX_ARRAY_SIZEถูกกำหนดให้เป็นInteger.MAX_VALUE - 8และเป็นInteger.MIN_VALUE - (Integer.MAX_VALUE - 8) > 0 จึงถูกต้องจัดการ: วิธีการส่งกลับหรือtruenewCapacityhugeCapacityMAX_ARRAY_SIZEInteger.MAX_VALUE

หมายเหตุ: นี่คือสิ่งที่// overflow-conscious codeความคิดเห็นในวิธีนี้พูด

ฉันพบคำอธิบายนี้ :

ในวันอังคารที่ 9 มีนาคม 2010 เวลา 03:02 น. Kevin L. Stern เขียนว่า:

ฉันทำการค้นหาอย่างรวดเร็วและดูเหมือนว่า Java เป็นส่วนประกอบสองอย่างแน่นอน อย่างไรก็ตามโปรดให้ฉันชี้ให้เห็นว่าโดยทั่วไปแล้วรหัสประเภทนี้ทำให้ฉันกังวลเพราะฉันคาดหวังอย่างเต็มที่ว่าเมื่อถึงจุดหนึ่งบางคนก็จะเข้ามาทำสิ่งที่ Dmytro แนะนำ นั่นคือใครบางคนจะเปลี่ยน:

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)จะกลับเท็จและคุณอาจเข้าใจผิดคิดว่าเพิ่มขึ้นArrayListlen

ดูรหัส:

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

หากoldCapacityมีขนาดค่อนข้างใหญ่จะทำให้เกิดการล้นและnewCapacityจะเป็นจำนวนลบ การเปรียบเทียบเช่นnewCapacity < oldCapacityจะประเมินอย่างไม่ถูกต้องtrueและArrayListจะไม่เติบโต

แต่รหัสเป็นลายลักษณ์อักษร ( newCapacity - minCapacity < 0ผลตอบแทนเท็จ) จะช่วยให้ค่าเชิงลบของการnewCapacityที่จะได้รับการประเมินต่อไปในบรรทัดถัดไปมีผลในการคำนวณnewCapacityโดยการเรียกhugeCapacity( newCapacity = hugeCapacity(minCapacity);) เพื่อให้สามารถที่จะเติบโตขึ้นไปArrayListMAX_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