convertir 'int' en 'long' ou accéder à un tableau trop long avec 'long'

Question

Disons que j'ai un tableau qui est assez long pour accéder à l'un de ses index avec int, est-il un moyen d'accéder à l'index d'un tel tableau avec long? Et comment le Java gère ce genre de tableau? Exemple:

int[] a = new int[]{1,5,2,4........9,2,1} 

On suppose dans le tableau ci-dessus que 9,2,1 sont à des indices qui sont au-delà de la plage de int (2). Comment accéder à ces éléments?

Answer 1

Vous ne voulez pas - les index de tableau sont toujours int en Java. Il ne permet pas un tableau avec plus de Integer.MAX_VALUE éléments. La longueur d'un tableau est représentée par le champ length, qui est de type int. Par conséquent, il est impossible de créer un tableau d'une longueur supérieure à Integer.MAX_VALUE.

Le spec ne l'appelle pas explicitement, mais vous pouvez le déduire des types impliqués.

Answer 2

Vous ne pouvez pas avoir un tableau aussi long. Mais cette idée a été proposée pour la pièce du projet.

Les tableaux doivent être indexés par int valeurs; Les valeurs short, byte ou char peuvent également être utilisées comme valeurs d'index car elles sont soumises à une promotion numérique unaire (§5.6.1) et deviennent des valeurs int. Une tentative d'accès à un composant de tableau avec une valeur d'index long entraîne une erreur de compilation.

---

Ressources:

• JLS - Array Access
• JLS - Array Creation Expressions
• Project coin - Large array V1 - V2

Answer 3

En ot elle a mentionné, les valeurs de longueur et d'index doivent être ints. Si vous en avez vraiment besoin, il existe des solutions de contournement. Par exemple, vous pourriez avoir un tableau de très grands tableaux int. Vous pouvez ensuite faire un peu d'arithmétique modulo sur un long pour déterminer quel tableau vous voulez et quel index dans ce tableau est nécessaire.

Answer 4

Vous auriez besoin d'une structure de données personnalisée, essayez ceci:

/** 
* Because java uses signed primitives only the least significant 31 bits of an int are used to index arrays, 
* therefore only the least significant 62 bits of a long are used to index a LongArray 
* 
* @author aaron 
*/ 
public class LongArray<Element> { 

    //inclusive 
    public static final long maximumSize = (~0)>>>2;//0x 00 FF FF FF FF FF FF FF 
    public static final long minimumSize = 0; 

    //Generic arrays are forbidden! Yay dogma! 
    private Object[][] backingArray; 

    private static int[] split(long L) { 
     int[] rtn = new int[2]; 
     rtn[1] = Integer.MAX_VALUE & (int)(L>>7); 
     rtn[0] = Integer.MAX_VALUE & (int)L; 
     return rtn; 
    } 
    private static long join(int[] ia) { 
     long rtn = 0; 
     rtn |= ia[0]; 
     rtn <<= 7; 
     rtn |= ia[1]; 
     return rtn; 
    } 

    private static boolean isValidSize(long L) { 
     return L<=maximumSize && L>=minimumSize; 
    } 

    public LongArray(long size){ 
     if (!isValidSize(size)) throw new IllegalArgumentException("Size requested was invalid, too big or negative"); 

     //This initialises the arrays to be only the size we need them to be 
     int[] sizes = split(size); 
     backingArray = new Object[sizes[0]][]; 
     for (int index = 0; index<backingArray.length-1; index+=1) { 
      backingArray[index] = new Object[Integer.MAX_VALUE]; 
     } 
     backingArray[backingArray.length-1] = new Object[sizes[1]]; 
    } 

    public Element get(long index) { 
     int[] ia = split(index); 
     return (Element)backingArray[ia[0]][ia[1]]; 
    } 
    public void set(long index, Element element) { 
     int[] ia = split(index); 
     backingArray[ia[0]][ia[1]] = element; 
    } 

}