Java создает байтовый массив, размер которого представлен длинным

(Возможно, это немного поздно для OP, но все же может быть полезно для других)

К сожалению, Java не поддерживает массивы с более чем 2 ³¹ −1 элементом. Максимальное потребление составляет 2 ГиБ для массива byte[] или 16 ГиБ для массива long[].

Хотя в данном случае это, вероятно, неприменимо, но если массив будет разреженным, вы можете уметь обойтись без использования ассоциативной структуры данных, такой как Map, чтобы каждое использованное смещение соответствовало соответствующему значению. Кроме того, Trove предоставляет более эффективную с точки зрения памяти реализацию для хранения примитивных значений, чем стандартные коллекции Java.

Если массив не является разреженным и вам действительно действительно нужен весь большой двоичный объект в памяти, вам, вероятно, придется использовать двумерную структуру, например с Map совпадающими смещениями по модулю 1024 в правильный массив размером 1024 байта. Такой подход может быть более эффективным с точки зрения памяти даже для разреженных массивов, поскольку соседние заполненные ячейки могут использовать одну и ту же запись Map.

byte[] с размером максимального 32-битного целого числа со знаком потребует 2 ГБ непрерывного адресного пространства. Не стоит пытаться создать такой массив. В противном случае, если размер на самом деле не такой большой (а это просто больший тип), вы можете безопасно преобразовать его в int и использовать его для создания массива.

Вероятно, вам следует использовать поток для чтения ваших данных и другой для их записи. Если вам понадобится доступ к данным позже в файле, сохраните их. Если вам нужен доступ к чему-то, с чем вы еще не сталкивались, вам нужна двухпроходная система, в которой вы проходите один раз и сохраняете «материал, который вам понадобится для второго прохода, а затем проходите снова».

Так работают компиляторы.

Единственный случай одновременной загрузки всего массива - это многократный случайный доступ ко многим местам в массиве. Если это так, я предлагаю вам загрузить его в несколько байтовых массивов, которые хранятся в одном классе-контейнере.

Класс контейнера будет иметь массив байтовых массивов, но извне все обращения кажутся непрерывными. Вы просто запросите байт 49874329128714391837, и ваш класс разделит ваш Long на размер каждого байтового массива, чтобы вычислить, к какому массиву получить доступ, а затем использовать остаток для определения байта.

У него также могут быть методы для хранения и извлечения «фрагментов», которые могут охватывать границы байтового массива, что потребует создания временной копии, но затраты на создание нескольких временных массивов будут более чем компенсированы тем фактом, что вы не используете У меня нет выделенного заблокированного места в 2 ГБ, что, как я думаю, может просто испортить вашу производительность.

Изменить: ps. Если вам действительно нужен произвольный доступ и вы не можете использовать потоки, тогда реализация содержащего класса является очень хорошей идеей. Это позволит вам на лету менять реализацию с однобайтового массива на группу байтовых массивов на файловую систему без каких-либо изменений в остальной части вашего кода.

Это не сразу поможет, но создание массивов большего размера (с помощью long) - это предлагаемое изменение языка для Java 7. Ознакомьтесь с предложениями Project Coin для получения дополнительной информации

Один из способов «сохранить» массив - записать его в файл, а затем получить к нему доступ (если вам нужно обращаться к нему как к массиву) с помощью RandomAccessFile. API для этого файла использует long как индекс в файле вместо int. Это будет медленнее, но с меньшей нагрузкой на память.

Это когда вы не можете извлечь то, что вам нужно, во время первоначального сканирования ввода.