Java array avec plus de 4gb éléments

Question

J'ai un gros fichier, il devrait être d'environ 12 GB. Je veux charger tout en mémoire sur une machine 64 bits costaud avec 16 Go de RAM, mais je pense que Java ne supporte pas les tableaux d'octets que grand:

File f = new File(file); 
long size = f.length(); 
byte data[] = new byte[size]; // <- does not compile, not even on 64bit JVM 

Est-il possible avec Java?

L'erreur de compilation du compilateur Eclipse est:

Type mismatch: cannot convert from long to int 

javac donne:

possible loss of precision 
found : long 
required: int 
     byte data[] = new byte[size]; 

Answer 1

Java indices de tableau sont de type int (4 octets ou 32 bits), donc je suis peur vous êtes limité à 2 - 1 ou 2147483647 emplacements dans votre tableau. Je lisais les données dans une autre structure de données, comme un tableau 2D.

Answer 2

Si nécessaire, vous pouvez charger les données dans un tableau de tableaux, ce qui vous donnera un maximum de 0maxValeur au carré octets, plus que même la machine la plus solide serait bien en mémoire.

Answer 3

Je vous suggère de définir des objets "bloc", dont chacun contient (disons) 1Gb dans un tableau, puis en faire un tableau.

Answer 4

Les tableaux Java utilisent des entiers pour leurs indices. Par conséquent, la taille maximale du tableau est Integer.MAX_VALUE.

(Malheureusement, je ne trouve aucune preuve de Sun se à ce sujet, mais il y a plenty de discussions sur leur forums à ce sujet déjà.)

Je pense que vous pourriez faire la meilleure solution dans l'intervalle serait être de faire un tableau 2D, à savoir:

byte[][] data; 

Answer 5

Non, les tableaux sont indexés par int s (sauf certaines versions de JavaCard qui utilisent short s). Vous aurez besoin de le découper en plus petits tableaux, en l'enveloppant probablement dans un type qui vous donne get(long), set(long,byte), etc. Avec des sections de données de cette taille, vous pourriez vouloir mapper le fichier en utilisant java.nio.

Answer 6

Comme d'autres l'ont dit, tous les tableaux Java de tous les types sont indexés par int, et peuvent donc être de taille max 2 -1 ou 2147483647 éléments (~ 2 milliards). Ceci est spécifié par le Java Language Specification, donc le passage à un autre système d'exploitation ou à une machine virtuelle Java n'aidera pas.

Si vous vouliez écrire une classe pour surmonter cela comme suggéré plus haut que vous pourriez, qui pourrait utiliser un tableau de tableaux (pour beaucoup de flexibilité) ou modifier les types (un long est de 8 octets donc un long[] peut être 8 fois plus grand qu'un byte[]).

Answer 7

Vous pouvez envisager d'utiliser FileChannel et MappedByteBuffer à la mémoire carte du fichier,

FileChannel fCh = new RandomAccessFile(file,"rw").getChannel(); 
long size = fCh.size(); 
ByteBuffer map = fCh.map(FileChannel.MapMode.READ_WRITE, 0, fileSize); 

Edit:

Ok, je suis un idiot, il ressemble ByteBuffer ne prend un indice 32 bits ainsi ce qui est étrange puisque le paramètre de taille de FileChannel.map est long ...Mais si vous décidez de diviser le fichier en plusieurs morceaux de 2 Go pour le chargement, je recommanderais quand même des E/S mappées en mémoire, car il peut y avoir de gros avantages en termes de performances. Vous déplacez essentiellement toutes les responsabilités IO vers le noyau OS.

Answer 8

package com.deans.rtl.util; 

import java.io.FileInputStream; 
import java.io.IOException; 

/** 
* 
* @author william.deans@gmail.com 
* 
* Written to work with byte arrays requiring address space larger than 32 bits. 
* 
*/ 

public class ByteArray64 { 

    private final long CHUNK_SIZE = 1024*1024*1024; //1GiB 

    long size; 
    byte [][] data; 

    public ByteArray64(long size) { 
     this.size = size; 
     if(size == 0) { 
      data = null; 
     } else { 
      int chunks = (int)(size/CHUNK_SIZE); 
      int remainder = (int)(size - ((long)chunks)*CHUNK_SIZE); 
      data = new byte[chunks+(remainder==0?0:1)][]; 
      for(int idx=chunks; --idx>=0;) { 
       data[idx] = new byte[(int)CHUNK_SIZE]; 
      } 
      if(remainder != 0) { 
       data[chunks] = new byte[remainder]; 
      } 
     } 
    } 
    public byte get(long index) { 
     if(index<0 || index>=size) { 
      throw new IndexOutOfBoundsException("Error attempting to access data element "+index+". Array is "+size+" elements long."); 
     } 
     int chunk = (int)(index/CHUNK_SIZE); 
     int offset = (int)(index - (((long)chunk)*CHUNK_SIZE)); 
     return data[chunk][offset]; 
    } 
    public void set(long index, byte b) { 
     if(index<0 || index>=size) { 
      throw new IndexOutOfBoundsException("Error attempting to access data element "+index+". Array is "+size+" elements long."); 
     } 
     int chunk = (int)(index/CHUNK_SIZE); 
     int offset = (int)(index - (((long)chunk)*CHUNK_SIZE)); 
     data[chunk][offset] = b; 
    } 
    /** 
    * Simulates a single read which fills the entire array via several smaller reads. 
    * 
    * @param fileInputStream 
    * @throws IOException 
    */ 
    public void read(FileInputStream fileInputStream) throws IOException { 
     if(size == 0) { 
      return; 
     } 
     for(int idx=0; idx<data.length; idx++) { 
      if(fileInputStream.read(data[idx]) != data[idx].length) { 
       throw new IOException("short read"); 
      } 
     } 
    } 
    public long size() { 
     return size; 
    } 
} 
} 

Answer 9

java ne supporte pas un tableau direct avec plus de 2^32 éléments à l'heure,

espoir de voir cette fonctionnalité de Java dans le futur

Answer 10

Je pense que l'idée de mappage mémoire le fichier (en utilisant le matériel de mémoire virtuelle du processeur) est la bonne approche. Sauf que MappedByteBuffer a la même limitation de 2 Go que les tableaux natifs. Ce gars prétend avoir résolu le problème avec une alternative assez simple à MappedByteBuffer:

http://nyeggen.com/post/2014-05-18-memory-mapping-%3E2gb-of-data-in-java/

https://gist.github.com/bnyeggen/c679a5ea6a68503ed19f#file-mmapper-java

Malheureusement, la machine virtuelle Java se bloque lorsque vous lisez au-delà de 500Mo.

Answer 11

ne limite pas votre auto avec Integer.MAX_VALUE

bien que cette question a été posée il y a plusieurs années, mais ai voulu participer avec un exemple simple en utilisant uniquement java se sans bibliothèques externes

d'abord, disons qu'il est théoriquement impossible, mais pratiquement possible

un nouveau look: si le tableau est un objet d'éléments que d'avoir un objet qui est un tableau de tableaux

est ici l'exemple

import java.lang.reflect.Array; 
import java.util.ArrayList; 
import java.util.List; 

/** 
* 
* @author Anosa 
*/ 
public class BigArray<t>{ 

private final static int ARRAY_LENGTH = 1000000; 

public final long length; 
private List<t[]> arrays; 

public BigArray(long length, Class<t> glasss) 
{ 
    this.length = length; 
    arrays = new ArrayList<>(); 
    setupInnerArrays(glasss); 

} 

private void setupInnerArrays(Class<t> glasss) 
{ 
    long numberOfArrays = length/ARRAY_LENGTH; 
    long remender = length % ARRAY_LENGTH; 
    /* 
     we can use java 8 lambdas and streams: 
     LongStream.range(0, numberOfArrays). 
         forEach(i -> 
         { 
          arrays.add((t[]) Array.newInstance(glasss, ARRAY_LENGTH)); 
         }); 
    */ 

    for (int i = 0; i < numberOfArrays; i++) 
    { 
     arrays.add((t[]) Array.newInstance(glasss, ARRAY_LENGTH)); 
    } 
    if (remender > 0) 
    { 
     //the remainer will 100% be less than the [ARRAY_LENGTH which is int ] so 
     //no worries of casting (: 
     arrays.add((t[]) Array.newInstance(glasss, (int) remender)); 
    } 
} 

public void put(t value, long index) 
{ 
    if (index >= length || index < 0) 
    { 
     throw new IndexOutOfBoundsException("out of the reange of the array, your index must be in this range [0, " + length + "]"); 
    } 
    int indexOfArray = (int) (index/ARRAY_LENGTH); 
    int indexInArray = (int) (index - (indexOfArray * ARRAY_LENGTH)); 
    arrays.get(indexOfArray)[indexInArray] = value; 

} 

public t get(long index) 
{ 
    if (index >= length || index < 0) 
    { 
     throw new IndexOutOfBoundsException("out of the reange of the array, your index must be in this range [0, " + length + "]"); 
    } 
    int indexOfArray = (int) (index/ARRAY_LENGTH); 
    int indexInArray = (int) (index - (indexOfArray * ARRAY_LENGTH)); 
    return arrays.get(indexOfArray)[indexInArray]; 
} 

}

et est ici le test

public static void main(String[] args) 
{ 
    long length = 60085147514l; 
    BigArray<String> array = new BigArray<>(length, String.class); 
    array.put("peace be upon you", 1); 
    array.put("yes it worj", 1755); 
    String text = array.get(1755); 
    System.out.println(text + " i am a string comming from an array "); 

} 

ce code est seulement limité par seulement Long.MAX_VALUE et Java tas mais vous pouvez le dépasser comme vous vouloir (je l'ai fait 3800 Mo)

j'espère que c'est utile et fournir une réponse simple