Comment puis-je lire un .fichier txt en un seul Java string tout en conservant les sauts de ligne?

Pratiquement chaque exemple de code y lit un fichier TXT, ligne par ligne, et il les stocke dans un tableau de chaînes. Je ne veux pas ligne par ligne de traitement parce que je pense que c'est un gaspillage inutile de ressources pour mes besoins: Tout ce que je veux faire est de rapidement et efficacement le vidage de l' .txt contenu dans une seule Chaîne. La méthode ci-dessous fait le travail, mais avec un inconvénient:

private static String readFileAsString(String filePath) throws java.io.IOException{
    byte[] buffer = new byte[(int) new File(filePath).length()];
    BufferedInputStream f = null;
    try {
        f = new BufferedInputStream(new FileInputStream(filePath));
        f.read(buffer);
        if (f != null) try { f.close(); } catch (IOException ignored) { }
    } catch (IOException ignored) { System.out.println("File not found or invalid path.");}
    return new String(buffer);
}

... l'inconvénient est que les sauts de ligne sont convertis en long espaces par exemple, " ".

Je veux les sauts de ligne pour être converti à partir d' \n ou \r (balise HTML) à la place.

Vous en remercie d'avance.

J'ai essayé d'ajouter cette méthode pour convertir les sauts de ligne du fichier texte au format HTML balises, mais il ne fonctionne pas: string.replaceAll("(\r\n|\n)", " ");
Traitement ligne par ligne sera tout aussi efficace (si ce n'est plus) que le dumping, l'ensemble du fichier, puis de revenir et de remplacer les sauts de ligne avec   tags
Vraiment, une boucle en passant par chaque ligne est tout aussi efficace? Intéressant ... je pourrais aller avec le. Merci!
qu'est-ce que l'encodage des données de caractère dans le fichier?
Où sont  's à venir? Il pourrait être enlevant l' \r et \n que vous cherchez à prendre soin de ici.

OriginalL'auteur slashline | 2011-05-25

3

Ce sujet à l'aide d'un Scanner et en ajoutant les sauts de ligne de vous-même:
```
sc = new java.util.Scanner ("sample.txt")
while (sc.hasNext ()) {
 buf.append (sc.nextLine ());
 buf.append (" ");
}
```
Je ne vois pas où vous obtenez votre long des espaces.

C'est encore en ligne-par-ligne de traitement, mais quelqu'un a dit que ce n'est pas plus lent que directement un dumping .fichier txt dans une Chaîne de base. Donc je pourrais le faire ligne par ligne de traitement ensuite, mais cela soulève une question: Qui est plus rapide, Scanner ou BufferedReader?
Si vous ne vous sentez pas une différence, peut-être qu'il n'est pas si grande que cela? Pour les tailles typiques de pages html, je ne m'attends pas à une différence pertinente. Il ya tellement de nombreuses influences (disque dur de vitesse, cache de disque dur, système d'exploitation, la taille du fichier, la version java, ...) que vous devriez faire vos mesures sur un système proche du système cible et avec les mêmes entrées.
N'est-ce pas en supposant que la dernière ligne du fichier doit avoir un saut de ligne est ajouté à la fin? Qui pourrait être dangereux dans certains cas.
Pas de. Avez-vous tester. Quel système?

OriginalL'auteur user unknown

Vous pouvez lire directement dans la mémoire tampon, puis de créer une Chaîne de caractères à partir de la mémoire tampon:

    File f = new File(filePath);
    FileInputStream fin = new FileInputStream(f);
    byte[] buffer = new byte[(int) f.length()];
    new DataInputStream(fin).readFully(buffer);
    fin.close();
    String s = new String(buffer, "UTF-8");

OriginalL'auteur Robert

1

Vous pourriez ajouter ce code:
```
return new String(buffer).replaceAll("(\r\n|\r|\n|\n\r)", " ");
```
Est-ce ce que vous recherchez?

Cela ne marchera pas. Je pense que le problème est que le tampon variable byte, afin de ne pas avoir \r\n. Au lieu de \r\n il a espaces.. ce qui rend plus difficile pour insérer correctement .
J'ai essayé sur un pc Windows et qu'il fonctionne correctement.

OriginalL'auteur Fabrizio D'Ammassa
1

Le code va lire le contenu du fichier comme ils apparaissent dans le fichier, y compris les sauts de ligne.
Si vous souhaitez modifier la casse dans quelque chose d'autre, comme l'affichage en html etc, vous aurez besoin pour le post-traitement, ou le faire par la lecture du fichier ligne par ligne. Puisque vous ne voulez pas le cas, vous pouvez remplacer votre retour par la suite qui devrait faire la conversion -
```
return (new String(buffer)).replaceAll("\r[\n]?", " ");
```
Cela aussi n'a pas de travail. Je pense que le problème est que le tampon variable byte, de sorte que le \r\n sont probablement enlevée. Au lieu de \r\n il a espaces.. ce qui rend plus difficile pour insérer correctement .
\r et \n ascii 10 et 13, respectivement. Je ne suis d'accord avec qu'ils ne peuvent pas tenir dans un octet. Essayez de le remplacer de toute façon - je ne vois pas pourquoi il l'habitude de travailler autrement, vous devez vérifier votre fichier source si elle a un de ces caractères. Ou essayez le code avec n'importe quel autre fichier texte créé à l'aide du bloc-notes, etc. Si vous voyez des modifications, vous devez nous dire quel type de fichier texte que vous utilisez.

OriginalL'auteur d-live

StringBuilder sb = new StringBuilder();
        try {
            InputStream is = getAssets().open("myfile.txt");
            byte[] bytes = new byte[1024];
            int numRead = 0;
            try {
                while((numRead = is.read(bytes)) != -1)
                    sb.append(new String(bytes, 0, numRead));
            }
            catch(IOException e) {

            }
            is.close();
        }
        catch(IOException e) {

        }

votre String: String result = sb.toString();

puis remplacer tout ce que vous voulez dans ce result.

OriginalL'auteur binnyb

0

Je suis d'accord avec l'approche générale par @Sanket Patel, mais à l'aide de Communes I/O, vous auriez probablement souhaitez Fichier Utils.

De sorte que votre mot de code ressembler à:
```
String myString = FileUtils.readFileToString(new File(filePath));
```
Il y a aussi une autre version de spécifier un autre codage de caractères.

OriginalL'auteur demongolem
0

Vous devriez essayer org.apache.commons.io.IOUtils.toString(InputStream), pour obtenir le fichier de contenu comme une Chaîne de caractères. De là, vous pouvez passer InputStream objet qui vous permettra d'obtenir de
```
getAssets().open("xml2json.txt") *<<- belongs to Android, which returns InputStream* 
```
dans votre Activité. Pour obtenir la Chaîne de caractères utilisez ceci :
```
String xml = IOUtils.toString((getAssets().open("xml2json.txt")));
```
Donc,
```
String xml = IOUtils.toString(*pass_your_InputStream_object_here*);
```
N'est-ce pas getAssets spécifiques à Android?
Oui. Mais IOUtils classe est de java et de sa méthode toString fonctionnera comme solution. Je suis d'accord, j'ai besoin d'être précis dans les sna. Merci pour le rappel.

OriginalL'auteur Sanket Patel

Vous devez vous connecter pour publier un commentaire.