Quelle est la meilleure façon de parcourir les lignes de Java String?

Actuellement, je suis en utilisant quelque chose comme :

String[]lines = textContent.split(System.getProperty("line.separator"));
for(String tmpLine : lines){
   //do something
}

Je ne suis pas très content de cette méthode, car il créer un lourd tableau (disons textContent peut contenir un livre).

Est-il une meilleure solution pour itérer sur les lignes d'une String?

Aussi maintenant avec JDK/11, on peut utiliser String.lines, qui fournit de meilleures performances que de le découper.

InformationsquelleAutor alain.janinm | 2012-02-13

java string

56

Vous pouvez utiliser :
```
BufferedReader bufReader = new BufferedReader(new StringReader(textContent));
```
Et l'utilisation de la readLine() méthode :
```
String line=null;
while( (line=bufReader.readLine()) != null )
{

}
```
- Merci pour la réponse. Cette solution offrir de meilleures performances? J'ai remarqué que cette solution utiliser 3 de l'objet. Je veux limiter la création de l'objet de suffisamment de mémoire, afin de ne BufferedReader et StringReader sont plus légers que d'un tableau de Chaîne?
- Comme la javadoc pour BufferedReader états, à l'aide de ladite classe est un moyen valable d'emballage coûteux méthodes de lecture pour le coût-efficacité lit. Voir docs.oracle.com/javase/6/docs/api/java/io/BufferedReader.html
InformationsquelleAutor Guillaume Polet
19

Pour ajouter le Java 8 chemin à cette question:
```
Arrays.stream(content.split("\\r?\\n")).forEach(line -> /*do something */)
```
De malédiction vous pouvez également utiliser System.lineSeparator()à split si vous êtes sûr que le fichier est produit par les mêmes plattform que la machine virtuelle s'exécute sur l'.

Ou encore mieux utiliser le flux d'api encore plus agressiv avec filtre, d'une carte et de recueillir:
```
String result = Arrays.stream(content.split(System.lineSeparator()))
                     .filter(/* filter for lines you are interested in*/)
                     .map(/*convert string*/)
                     .collect(Collectors.joining(";"));
```
- le réel java8 façon serait probablement utiliser System.lineSeparator() au lieu de la propriété directement
- vous avez raison! Modifié la réponse en conséquence.
- Vous avez accidentellement édité loin le content dans le deuxième exemple.
InformationsquelleAutor leo

Vous pourriez utiliser des chaînes de caractères.indexOf()/Chaîne.substring()

String separator = System.getProperty("line.separator");
int index = textContent.indexOf(separator);

while (index > 0)
{
  int nextIndex = textContent.indexOf(separator, index + separator.length());
  String line = textContent.substring(index + separator.length(), nextIndex);

  //do something with line.
}

InformationsquelleAutor Brendan

5

Goyave est Splitter fonctionne bien. Surtout que vous pouvez supprimer des lignes vides
```
Splitter splitter = Splitter.on(System.getProperty("line.separator"))
                            .trimResults()
                            .omitEmptyStrings();
for (String line : splitter.split(input)){
   //do work here
}
```
- De goyave du code source: Splitter.on(Pattern.compile("\r?\n")).split(entireFile)
- Plus précisément, c'est dans la Javadoc de Splitter#on: google.github.io/goyave/releases/snapshot/api/docs/com/google/...
InformationsquelleAutor John B
5

Scanner

Ce sujet de la java.util.Scanner classe ajoutée dans Java 1.5?

En résumé:

Un texte simple scanner qui peut analyser les types primitifs et les chaînes de caractères
à l'aide d'expressions régulières.

Un Scanner sauts de de son entrée en jetons à l'aide d'un séparateur de modèle,
qui, par défaut, correspond aux espaces. La résultante des jetons peuvent ensuite être
convertis en valeurs de différents types, en utilisant les différents suivant
des méthodes.

et de la note de votre scénario:
Le scanner peut également utiliser des délimiteurs autres que les espaces. Cette
exemple lit plusieurs éléments à partir d'une chaîne:
```
     String input = "1 fish 2 fish red fish blue fish";
     Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
     System.out.println(s.nextInt());
     System.out.println(s.nextInt());
     System.out.println(s.next());
     System.out.println(s.next());
     s.close();
```
InformationsquelleAutor Alex
2

Vous pouvez réellement se quereller Scanner pour vous permettre d'utiliser une normale for boucle:
```
import java.util.Scanner;
public class IterateLines {
    public static void main(String[] args) {
        Iterable<String> sc = () ->
            new Scanner("foo bar\nbaz\n").useDelimiter("\n");
        for (String line: sc) {
            System.out.println(line);
        }
    }
}
```
nous donne:
```
$ javac IterateLines.java && java IterateLines 
foo bar
baz
```
- Cela permettra de diviser la chaîne sur les deux espaces et retours à la ligne, ce qui n'est pas ce que la question est à la recherche pour.
- Merci @Zulakis - j'ai corrigé le code pour utiliser explicitement un délimiteur.
- Je pense que ça pourrait être améliorée par l'utilisation du Système.getProperty("line.séparateur").
InformationsquelleAutor Andy Balaam
1

utilisation BufferedReader avec StringReader argument. BufferedReader a une méthode readLine() de sorte que vous pouvez lire votre texte ligne par ligne.
```
    StringReader reader = new StringReader(myBigTextString);
    BufferedReader br = new BufferedReader(reader);
    String line;
    while((line=br.readLine())!=null)
    {
        //do what you want
    }
```
- lorsque vous gardez un tableau de splitted lignes de ce tableau prend beaucoup de mémoire comme vous l'avez dit. Dans ce cas, toutes les lignes de votre texte ne sont pas chargés en mémoire. BufferedReader juste se souvient de la dernière lecture et lorsque vous appelez readLine() la méthode qu'il lit juste à côté de la ligne de votre chaîne de caractères (avec l'aide de StringReader). Donc, à chaque itération, vous avez une seule ligne de votre texte dans la mémoire (en line variable) au lieu de toutes les lignes.
InformationsquelleAutor shift66
1

Combiner java.io.StringReader et java.io.LineNumberReader
- Merci pour la réponse. d'autres projets de BufferedReader. Qu'est-ce que les avantages de java.io.LineNumberReader?
- En fait, j'ai juste ne se rendent pas compte BufferedReader a la readLine() la méthode de mise en œuvre ainsi.
- Pour les futurs lecteurs: LineNumberReader s'étend BufferedReader, donc LineNumberReader est une baisse-dans le remplacement pour BufferedReader, avec en plus le comportement de suivi du numéro de la ligne que vous venez de lire. Voir docs.oracle.com/javase/8/docs/api/java/io/LineNumberReader.html.
InformationsquelleAutor david a.
1

Je crois que vous avez une meilleure API disponibles avec JDK/11 où vous pouvez faire de même en utilisant le String.lines() API qui retourne le flux des chaînes extraites de cette chaîne partitionné en ligne terminateurs.
```
public Stream<String> lines()
```
L'utilisation de la même chose pourrait être :-
```
Stream<String> linesFromString = textContent.lines();
linesFromString.forEach(l -> { 
    //do sth
});
```
Important API Note :-
```
@implNote This method provides better performance than
          split("\R") by supplying elements lazily and
          by faster search of new line terminators.
```
InformationsquelleAutor Naman

Vous devez vous connecter pour publier un commentaire.

Scanner

`Scanner`