ArrayList è <Integer> ottimizzato da JDK per funzionare come int []?

Question

Ci viene insegnato che l'ArrayList di Java è meno efficiente per i numeri interi, perché la lista contiene effettivamente dei puntatori, mentre una serie di interi contiene gli interi, evitando così allocazioni di memoria e accesso.

La mia domanda è se il compilatore JDK/JIT ottimizza questo tipo di inefficienza di distanza? Ha tutte le informazioni per concludere che queste implementazioni sono funzionalmente equivalenti, quindi potrebbe anche sostituire ArrayList con un'implementazione int-backed sotto il cofano.

Answer 1

No, non può, perché è possibile memorizzare null in un elenco di array.

EDIT: Oh, e non può anche perché i generici vengono cancellati in fase di compilazione - in fase di esecuzione, il JRE non è in grado di distinguere le liste di array dai loro tipi di elementi. IOW, è peggio di solo null - è possibile memorizzare qualsiasi oggetto in un ArrayList<Integer>.

Answer 2

No. http://jdevelopment.nl/java/java-best-practices-4-native-arrays-and-not-using-java-5/

Answer 3

Si potrebbe, in teoria, ma non è così. Potrebbe non essere più efficiente a meno che non si possa ottimizzare anche l'auto-boxing.

È possibile invece http://trove4j.sourceforge.net/javadocs/gnu/trove/TIntArrayList.html che esegue il wrapping int [].

Answer 4

Così l'attuazione di tale varietà può essere come questo

 
import java.util.AbstractList; 
import java.util.List; 
import java.util.RandomAccess; 

public class IntArrayList extends AbstractList<Integer> 
implements List<Integer> , RandomAccess /* todo , Cloneable, java.io.Serializable */{ 

    private static final int INT_SIZE_MINUS_ONE = 15; 
    private static final int RIGHT_SHIFT = 4; 

    private int size; 
    private int isNull[]; 
    private int data[]; 

    IntArrayList(int size) { 
     if (size < 0) { 
      throw new RuntimeException("invalid size"); 
     } 
     this.size = size; 
     isNull = new int[(size + INT_SIZE_MINUS_ONE) >>> RIGHT_SHIFT]; 
     data = new int[size]; 
    } 

    private void rangeCheck(int index) { 
     if (index < 0 || index >= size) { 
      throw new IndexOutOfBoundsException(); 
     } 
    } 

    public Integer set(int index, Integer element) { 
     rangeCheck(index); 

     Integer oldValue = get(index); 
     if (element == null) { 
      isNull[index >>> RIGHT_SHIFT] &= ~(1 << (index & INT_SIZE_MINUS_ONE)); 
     } else { 
      isNull[index >>> RIGHT_SHIFT] |= (1 << (index & INT_SIZE_MINUS_ONE)); 
      data[index] = element; 
     } 
     return oldValue; 
    } 

    @Override 
    public Integer get(int index) { 
     rangeCheck(index); 
     if ((isNull[index >>> RIGHT_SHIFT] & (1 << (index & INT_SIZE_MINUS_ONE))) == 0) { 
      return null; 
     } 
     return new Integer(data[index]); 
    } 

    @Override 
    public int size() { 
     return size; 
    } 

    public boolean isEmpty() { 
     return size == 0; 
    } 
} 

Può essere utilizzato ovunque come List<Integer>

Tale tipo di oggetto può essere utile per la conservazione a lungo termine delle informazioni che raramente utilizzato. Ridurrà la frammentazione dell'heap a un costo di maggiore generazione di rifiuti sull'accesso agli elementi.