Lire des données d'un fichier texte en utilisant Java
Je dois lire un fichier texte ligne par ligne en utilisant Java. J'utilise la méthode available() de FileInputStream pour vérifier le fichier en boucle. Mais lors de la lecture, la boucle se termine après la ligne précédant la dernière. i.e. , si le fichier a 10 lignes, la boucle ne lit que les 9 premières lignes. Extrait utilisé:
while(fis.available() > 0)
{
char c = (char)fis.read();
.....
.....
}
Vous ne devriez pas utiliser available(). Cela ne donne aucune garantie quoi que ce soit. À partir des Documents API de available() :
Renvoie une estimation du nombre d'octets pouvant être lus (ou ignorés) à partir de ce flux d'entrée sans blocage par le prochain appel d'une méthode pour ce flux d'entrée.
Vous voudrez probablement utiliser quelque chose comme
try {
BufferedReader in = new BufferedReader(new FileReader("infilename"));
String str;
while ((str = in.readLine()) != null)
process(str);
in.close();
} catch (IOException e) {
}
(extrait de http://www.exampledepot.com/egs/Java.io/ReadLinesFromFile.html )
Que diriez-vous d'utiliser Scanner? Je pense que l'utilisation du scanner est plus facile
private static void readFile(String fileName) {
try {
File file = new File(fileName);
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
System.out.println(scanner.nextLine());
}
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
Si vous voulez lire ligne par ligne, utilisez un BufferedReader . Il a une méthode readLine() qui renvoie la ligne sous forme de chaîne ou null si la fin du fichier est atteinte Ainsi, vous pouvez faire quelque chose comme:
BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
String line;
while ((line = reader.readLine()) != null) {
// Do something with line
}(Notez que ce code ne gère pas les exceptions et ne ferme pas le flux, etc.)
String file = "/path/to/your/file.txt";
try {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String line;
// Uncomment the line below if you want to skip the fist line (e.g if headers)
// line = br.readLine();
while ((line = br.readLine()) != null) {
// do something with line
}
br.close();
} catch (IOException e) {
System.out.println("ERROR: unable to read file " + file);
e.printStackTrace();
}
Vous pouvez essayer FileUtils depuis org.Apache.commons.io.FileUtils, essayez de télécharger jar à partir d’ici
et vous pouvez utiliser la méthode suivante: FileUtils.readFileToString ("yourFileName");
J'espère que ça vous aide ..
La raison pour laquelle votre code a ignoré la dernière ligne est que vous avez mis fis.available() > 0 au lieu de fis.available() >= 0
Dans Java 8 , vous pouvez facilement transformer votre fichier texte en une liste de chaînes avec des flux en utilisant Files.lines et collect:
private List<String> loadFile() {
URI uri = null;
try {
uri = ClassLoader.getSystemResource("example.txt").toURI();
} catch (URISyntaxException e) {
LOGGER.error("Failed to load file.", e);
}
List<String> list = null;
try (Stream<String> lines = Files.lines(Paths.get(uri))) {
list = lines.collect(Collectors.toList());
} catch (IOException e) {
LOGGER.error("Failed to load file.", e);
}
return list;
}
//The way that I read integer numbers from a file is...
import Java.util.*;
import Java.io.*;
public class Practice
{
public static void main(String [] args) throws IOException
{
Scanner input = new Scanner(new File("cards.txt"));
int times = input.nextInt();
for(int i = 0; i < times; i++)
{
int numbersFromFile = input.nextInt();
System.out.println(numbersFromFile);
}
}
}
Essayez ceci juste une petite recherche dans Google
import Java.io.*;
class FileRead
{
public static void main(String args[])
{
try{
// Open the file that is the first
// command line parameter
FileInputStream fstream = new FileInputStream("textfile.txt");
// Get the object of DataInputStream
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
//Read File Line By Line
while ((strLine = br.readLine()) != null) {
// Print the content on the console
System.out.println (strLine);
}
//Close the input stream
in.close();
}catch (Exception e){//Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
}
Essayez d’utiliser Java.io.BufferedReader comme ceci.
Java.io.BufferedReader br = new Java.io.BufferedReader(new Java.io.InputStreamReader(new Java.io.FileInputStream(fileName)));
String line = null;
while ((line = br.readLine()) != null){
//Process the line
}
br.close();
public class FilesStrings {
public static void main(String[] args) throws FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream("input.txt");
InputStreamReader input = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(input);
String data;
String result = new String();
while ((data = br.readLine()) != null) {
result = result.concat(data + " ");
}
System.out.println(result);
File file = new File("Path");
FileReader reader = new FileReader(file);
while((ch=reader.read())!=-1)
{
System.out.print((char)ch);
}
Cela a fonctionné pour moi
scanner utilisateur cela devrait fonctionner
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
System.out.println(scanner.nextLine());
}
scanner.close();
Oui, la mise en mémoire tampon doit être utilisée pour de meilleures performances. Utilisez BufferedReader OR octet [] pour stocker vos données temporaires.
merci.
public class ReadFileUsingFileInputStream {
/**
* @param args
*/
static int ch;
public static void main(String[] args) {
File file = new File("C://text.txt");
StringBuffer stringBuffer = new StringBuffer("");
try {
FileInputStream fileInputStream = new FileInputStream(file);
try {
while((ch = fileInputStream.read())!= -1){
stringBuffer.append((char)ch);
}
}
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("File contents :");
System.out.println(stringBuffer);
}
}