Meilleure façon de lire un flux d'entrée pour un tampon

Pour lire n'importe quel flux d'entrée pour un tampon, il y a deux méthodes. Quelqu'un peut-il m'aider à comprendre quelle est la meilleure méthode, et pourquoi? Et dans quelle situation nous devons utiliser chaque méthode?

  • La lecture ligne par ligne et d'ajouter de la mémoire tampon.

Par exemple:

public String fileToBuffer(InputStream is, StringBuffer strBuffer) throws IOException{
    StringBuffer buffer = strBuffer;
    InputStreamReader isr = null;

    try {
        isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        String line = null;

        while ((line = br.readLine()) != null) {
            buffer.append(line + "\n");
        }
    } finally {
        if (is != null) {
            is.close();
        }
        if (isr != null) {
            isr.close();
        }
    }

    return buffer.toString();
}
  • La lecture jusqu'à la taille de la mémoire tampon ie 1024 octets dans un tableau de char.

Par exemple:

InputStreamReader isr = new InputStreamReader(is);
final int bufferSize = 1024;
char[] buffer = new char[bufferSize];
StringBuffer strBuffer = new StringBuffer();

/* read the base script into string buffer */
try {
    while (true) {
        int read = isr.read(buffer, 0, bufferSize);
        if (read == -1) {
           break;
        }

        strBuffer.append(buffer, 0, read);
     }
} catch (IOException e) {
}

OriginalL'auteur user1731553 | 2013-01-18

  1. 3

    Envisager

    public String fileToBuffer(InputStream is, StringBuffer strBuffer) throws IOException {
    StringBuilder sb = new StringBuilder(strBuffer);
    try (BufferedReader rdr = new BufferedReader(new InputStreamReader(is))) { 
        for (int c; (c = rdr.read()) != -1;) {
            sb.append((char) c);

        }
    }
    return sb.toString();
}
    +1 pour montrer essayer de la clause de java 7 🙂
    Envisager, pourquoi?
    Vous êtes offrant à un seul octet de la mémoire tampon de la version comme un améliorer?

    OriginalL'auteur Evgeniy Dorofeev

  2. 0

    Dépend de l'objectif.

    Pour travailler avec des fichiers texte lu les lignes (si vous en avez besoin).

    Pour travailler avec des données binaires brutes utiliser des blocs d'octets.

    En vous des exemples de morceaux d'octets sont plus robustes.
    Que faire si une ligne est trop longue et les sauts de certains objets intermédiaires?

    Si votre fichier est binaire, savez-vous quelle est la ligne?
    Peut-être la taille de fichier.

    Essayer à "avaler" une trop grande Chaîne peut provoquer ErrorOutOfMemory.
    Avec 1024 octets (ok presque) n'arrive jamais.

    De segmentation par 1024 octets peut prendre plus longtemps, mais sa plus fiable.

    Il n'a pas de blocs d'octets dans son exemple. Il a des morceaux de caractères.
    Merci, mais ça ne change pas beaucoup. La logique est toujours la même.

    OriginalL'auteur Alex Kreutznaer

  3. 0

    À l'aide de la "readLine" n'est pas si propre. Le sens de la méthode 2 est tout à fait standard, mais la méthode ci-dessous est unique (et probablement mieux):

    //read the whole inputstream and put into a string
public String inputstream2str(InputStream stream) {
  Scanner s = new Scanner(stream).useDelimiter("\\A");
  return s.hasNext()? s.next():"";
}

    À partir d'une Chaîne, vous pouvez convertir le tableau d'octets, ou quel que soit le tampon.

    Pourquoi est-ce la lecture ligne par ligne dangereux? (Non pas que je suis en désaccord, mais vous devez indiquer vos raisons). Et étant donné que, quelle est la différence entre la lecture ligne par ligne et de numérisation avec un saut de ligne délimiteur? Réponse: zéro. Alors pourquoi vous le recommander?
    ok, juste assez 😐
    Lecture ligne par ligne peut être dangereux parce que si le démarrage de la lecture ligne par ligne un fichier binaire, la taille de la ligne peut être égale à la taille du fichier. Les lignes de sens, tout en travaillant avec des fichiers texte.

    OriginalL'auteur jondinham