Comment Lire un nombre fixe d'octets à partir d'un fichier dans une boucle en JAVA?

Je dois lire un de la fie, où à chaque itération, je dois lire 8 octets du fichier. Par exemple, dans la première itération, je vais lire les 8 premiers octets et la deuxième itération suivante de 8 et ainsi de suite. Comment cela peut-il être fait en Java?

public static byte[] toByteArray(File file) {
    long length = file.length();
    byte[] array = new byte[length];
    InputStream in = new FileInputStream(file);
    long offset = 0;
    while (offset < length) {
        int count = in.read(array, offset, (length - offset));
        offset += length;
    }
    in.close();
    return array;
}

J'ai trouvé ceci, mais je pense que ce que ce code est en train de faire est complètement à la lecture d'un fichier et de faire un tableau d'octets de données de fichier. Mais j'ai besoin de prêt seulement que le nombre d'octets que j'ai besoin dans une seule itération.

OriginalL'auteur Usama Sarwar | 2013-09-15

Utiliser un DataInput pour ce type de traitement:

  private void process(File file) throws IOException {
    try (RandomAccessFile data = new RandomAccessFile(file, "r")) {
      byte[] eight = new byte[8];
      for (long i = 0, len = data.length() / 8; i < len; i++) {
        data.readFully(eight);
        //do something with the 8 bytes
      }
    }
  }

J'ai utiliser un RandomAccessFile mais un DataInputStream est une alternative commune.

OriginalL'auteur McDowell

Vous pouvez facilement adapter le code à vos besoins: ajouter un offset et le comte, et appel skip pour obtenir la N octets, comme ce -

public static byte[] toByteArray(File file, long start, long count) {
      long length = file.length();
      if (start >= length) return new byte[0];
      count = Math.min(count, length - start);
      byte[] array = new byte[count];
      InputStream in = new FileInputStream(file);
      in.skip(start);
      long offset = 0;
      while (offset < count) {
          int tmp = in.read(array, offset, (length - offset));
          offset += tmp;
      }
      in.close();
      return array;
}

OriginalL'auteur dasblinkenlight

0

Diviser le code en petits morceaux, par exemple, pour lire un octet du bloc (dans votre cas 8 octets) vous avez besoin de savoir 3 choses:
1. Dans le fichier à lire
2. Par où commencer la lecture
3. Combien d'octets à lire /taille du bloc
Voyant cela comme une étape serait de vous laisser avec une méthode qui retourne un byte[] tableau, en prenant les au-dessus de 3 points en tant que paramètres, par exemple:
```
private byte[] readByteBlock(InputStream in, int offset, int noBytes) throws IOException {
    byte[] result = new byte[noBytes];
    in.read(result, offset, noBytes);
    return result;
}
```
La prochaine étape serait, pour ouvrir le fichier et l'appel à cette méthode pour chaque octet du bloc dans le fichier. Vous commencez à lire le fichier à la position zéro, appelez la méthode une fois, faire quelque chose avec le résultat, et de l'appeler tous les plus à la position = (previousPos) + taille de bloc. Ce bout de code pourrait être mis dans une autre méthode, par exemple:
```
public byte[][] toByteArray(File file, int byteBlockSize) throws IOException {

    InputStream in = new FileInputStream(file);
    long noOfBlocks = (long) Math.ceil((double)file.length() / (double)byteBlockSize);
    byte[][] result = new byte[(int)noOfBlocks][byteBlockSize];
    int offset = 0;
    for(int i = 0; i < result.length; i++) {
        result[i] = readByteBlock(in, offset, byteBlockSize);
    }
    return result;
}
```
Cela renvoie d'un byte[][] tableau avec le premier indice de la byteBlockNumber (8 premiers octets, deuxième de 8 octets, le troisième 8 octets, ...) et le deuxième indice de chaque octet:
```
byte[0][0]: the first byte block's first byte
byte[0][7]: the first byte block's second byte
byte[1][2]: the second byte block, third byte
etc..
```
Dans l'exemple de code ci-dessus le byte[][] tableau est initialisé comme:
```
long noOfBlocks = (long) Math.ceil((double)file.length() / (double)byteBlockSize);
byte[][] result = new byte[noOfBlocks][byteBlockSize];
```
De sorte que le nombre de blocs est le nombre d'octets dans le fichier divisé par la taille des blocs d'octets (8 dans l'exemple). En supposant que le fichier a 9 octets et la taille des blocs est de 8, ce qui entraînerait des 1,les géohelminthiases et arrondi à 1, de sorte que vous n'avez pas l'espace pour le dernier octet, c'est pourquoi les Mathématiques.ceil() est utilisée pour le tour jusqu'à ce que la division de la donne. Les mathématiques.ceil(9 /8) -> 2, et les 2 sont assez pour tenir le premier bloc de 8 octets, et le dernier octet dans un deuxième bloc.

C'est un défaut de ne pas vérifier la valeur de retour de la lire. Vous ne pouvez pas supposer qu'il remplit toujours la mémoire tampon. Voir le doc: Une tentative est faite pour lire autant que len octets, mais un plus petit nombre peut être lu.
Si vous utilisez le public int read(byte[] b,int off,int len) sur moins de 'len' octets disponibles, les éléments de b après le dernier octet lu juste rester inchangée (0). Puisque la taille est connue, le dernier octet à lire peut être calculé et d'octets supplémentaires ignoré. Le code n'a pas été prévu pour copier & coller comme une ultime solution parfaite 😉 Donc, oui, si, si vous avez un fichier avec 9 octets, lire des blocs de 8, le deuxième byte[] 8 éléments avec les 7 derniers ne représentent pas le contenu du fichier.
OOM exception si elle est jugée pour 200 MO d'image

OriginalL'auteur Philipp Seeger

Vous pouvez utiliser le code suivant pour lire un morceau de la mémoire avec un décalage de début et de taille:

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class FileReadingUtilities
{
public static byte[] readBytes(String file, int start, int size) throws IOException
{
Path filePath = Paths.get(file);
long fileSize = Files.size(filePath);
if(start < 0)
{
throw new IllegalArgumentException("The start may not be negative!");
}
if(size < 0)
{
throw new IllegalArgumentException("The size may not be negative!");
}
if (start + size > fileSize)
{
throw new IllegalArgumentException("Interval exceeds file size!");
}
byte[] readBytes = new byte[size];
try (InputStream inputStream = new FileInputStream(filePath.toFile()))
{
long actuallySkipped = inputStream.skip(start);
if (start != actuallySkipped)
{
throw new IllegalStateException("Error while skipping bytes ahead!");
}
int bytesReadCount = inputStream.read(readBytes, 0, size);
if (bytesReadCount != size)
{
throw new IllegalStateException("Not enough bytes have been read!");
}
}
return readBytes;
}
}

Encore mieux en terme de performance, l'utilisation d'un MappedByteBuffer:

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class FileReadingUtilities
{
public static ByteBuffer getByteBuffer(String filePath, int start, int size) throws IOException
{
File binaryFile = new File(filePath);
FileChannel binaryFileChannel = new RandomAccessFile(binaryFile, "r").getChannel();
return binaryFileChannel.map(FileChannel.MapMode.READ_ONLY, start, size);
}
}

Le tableau d'octets peut être consulté à partir de la ByteBuffer à l'aide de son array() méthode.

OriginalL'auteur BullyWiiPlaza

Vous devez vous connecter pour publier un commentaire.