une bibliothèque Java IO en python?

Lecture d'un fichier ligne par ligne en Java:

BufferedReader in = new BufferedReader(new FileReader("myfile.txt"));

String line;
while ((line = in.readLine()) != null) {
    // Do something with this line
    System.out.println(line);
}

in.close();

la plupart des classes d'e/s sont dans le paquet java.io. Voir la documentation de L'API pour ce paquet. Jetez un oeil à Java de Sun I/O tutoriel pour plus d'informations.

ajout: L'exemple ci-dessus va utiliser le codage de caractères par défaut de votre système pour lire le fichier texte. Si vous voulez spécifier explicitement le codage de caractères, par exemple UTF-8, changez le premier ligne à ceci:

BufferedReader in = new BufferedReader(
    new InputStreamReader(new FileInputStream("myfile.txt"), "UTF-8"));

Si vous avez déjà des dépendances Apache commons lang et communes io ce qui pourrait être une alternative:

String[] lines = StringUtils.split(FileUtils.readFileToString(new File("myfile.txt")), '\n');
for(String line: lines){
      //do something with the line from file
}

(je préfère Jesper réponse)

si vous voulez itérer à travers un fichier par des chaînes, une classe que vous pourriez trouver utile est le Scanner classe.

import java.io.*;
import java.util.Scanner;

    public class ScanXan {
        public static void main(String[] args) throws IOException {
            Scanner s = null;
            try {
                s = new Scanner(new BufferedReader(new FileReader("myFile.txt")));

                while (s.hasNextLine()) {
                    System.out.println(s.nextLine());
                }
            } finally {
                if (s != null) {
                    s.close();
                }
            }
        }
    }

L'API est assez utile: http://java.sun.com/javase/7/docs/api/java/util/Scanner.html Vous pouvez également analyser le fichier en utilisant des expressions régulières.

Je ne me lasse jamais du proxénétisme de Google goyave, les bibliothèques, ce qui prend beaucoup de la douleur... la plupart des choses à Java.

Que Diriez-vous de:

for (String line : Files.readLines(new File("file.txt"), Charsets.UTF_8)) {
   // Do something
}

dans le cas où vous avez un gros fichier, et que vous voulez un rappel ligne par ligne (plutôt que de lire le tout en mémoire), vous pouvez utiliser un LineProcessor, ce qui ajoute un peu de boilerplate (en raison de l'absence de fermetures... soupir), mais encore vous protège de traiter avec la lecture elle-même, et tous les associés Exceptions:

int matching = Files.readLines(new File("file.txt"), Charsets.UTF_8, new LineProcessor<Integer>(){
  int count;

  Integer getResult() {return count;}

  boolean processLine(String line) {
     if (line.equals("foo")
         count++;
     return true;
  }
});

si vous ne voulez pas réellement un résultat de retour hors du processeur, et vous n'abandonnez jamais prématurément (la raison pour le retour booléen de processLine) faire quelque chose comme:

class SimpleLineCallback extends LineProcessor<Void> {
    Void getResult{ return null; }

    boolean processLine(String line) {
       doProcess(line);
       return true;
    }

    abstract void doProcess(String line);
}

et puis votre code pourrait être:

Files.readLines(new File("file.txt"), Charsets.UTF_8, new SimpleLineProcessor(){
  void doProcess(String line) {
     if (line.equals("foo");
         throw new FooException("File shouldn't contain 'foo'!");
  }
});

qui est donc plus propre.

  public static void main(String[] args) throws FileNotFoundException {
    Scanner scanner = new Scanner(new File("scan.txt"));
    try {
      while (scanner.hasNextLine()) {
        System.out.println(scanner.nextLine());
      }
    } finally {
      scanner.close();
    }
  }

Quelques mises en garde:

• qui utilise l'encodage du système par défaut, mais vous devriez spécifier l'encodage du fichier
• le Scanner avale les I / O exceptions, donc vous pouvez vérifier ioException () à la fin pour une bonne gestion des erreurs

exemple Simple utilisant Files.readLines() à partir de goyave-io avec un LineProcessor rappel:

import java.io.File;
import java.io.IOException;

import com.google.common.base.Charsets;
import com.google.common.io.Files;
import com.google.common.io.LineProcessor;

public class GuavaIoDemo {

    public static void main(String[] args) throws Exception {
        int result = Files.readLines(new File("/home/pascal/.vimrc"), //
            Charsets.UTF_8, // 
            new LineProcessor<Integer>() {
                int counter;

                public Integer getResult() {
                    return counter;
                }

                public boolean processLine(String line) throws IOException {
                    counter++;
                    System.out.println(line);
                    return true;
                }
            });
    }
}

Vous pouvez utiliser python qui vous permet d'exécuter la syntaxe Python en Java.

bel exemple ici: itération ligne par ligne

Essayez de regarder groovy!

C'est un super-ensemble de Java qui fonctionne en HTE JVM. Le code Java le plus valide est également valide Groovy de sorte que vous avez accès à l'un des millions D'API java directement.

en outre, il a beaucoup des contructs de niveau supérieur familiers aux Pythonistes, plus un certain nombre d'extensions pour enlever la douleur des cartes, listes, sql, xml et vous l'avez deviné -- fichier IO.