Java >> Java tutorial >  >> Java

Sådan læser du en fil i Java

Java

At tage input fra brugeren er en vigtig del af at lave et program, og der kan være mange måder at tage input på for at bruge det i vores program. En sådan måde er at læse data fra en fil. At tage input fra filen kan være en smule besværligt og svært at forstå, men det er en fordel til at gemme en stor mængde data.

Læs data fra en fil

Scanner-klassen bruges til at tage input i et java-program. Således kan vi bruge scannerklassen til at læse data fra en fil. System.in sendes som et argument i scannerobjektet, som specificerer at tage input fra tastaturet i stedet for System.in. Vi kan sende et filobjekt som vist.

File myFile = new File("Customers.txt");
Scanner inputFile = new Scanner(myFile);

Så den første sætning opretter et objekt i filen, fil-nøgleordet bruges til at definere en fil, der repræsenterer filen customers.txt. Den anden linje tager input og sender en reference til filobjektet som input. Til dette skal vi importere to biblioteker.

import java.util.Scanner; // Needed for Scanner class
import java.io.*; //needed for file and IO Exception

Når vi er færdige med at læse fra filen, lukker følgende sætning filen, der er objektets outputkilde:

inputFile.close();

Læsning af linjer fra en fil

nextline() metode i java bruges til at læse en linje med input og returnerer en streng som output. nextline() metode kan også bruges til at læse input fra filer. For nu at se, hvordan dette virker, skal vi først oprette en fil i samme mappe som koden. Opret en fil med navnet hello.txt og følg eksemplet illustreret nedenfor:

 import java.util.Scanner; // Needed for Scanner class
 import java.io.*; // Needed for File and IOException

 /**
 This program reads the first line from a file.
 */
 public class ReadFirstLine
 {
   public static void main(String[] args) throws IOException
   {

   // Open the file.
   File file = new File("Hello.txt");
   Scanner inputFile = new Scanner(file);

   // Read the first line from the file.
   String line = inputFile.nextLine();

   // Display the line.
   System.out.println("The first line in the file is:");
   System.out.println(line);

   // Close the file.
   inputFile.close();
   }
 }

Nu, da java er et objektorienteret sprog, bør al den skrevne kode være inde i en klasse. Ovenstående program åbner en fil med navnet Hello.txt, læser den første linje og viser outputtet.

Når en fil åbnes til læsning, opretholdes en særlig værdi kendt som læseposition for en fil, selvom vi ikke kan se den, men den er der internt. En fils læseposition markerer placeringen af ​​det næste element, den vil læse. Når en fil åbnes, peger læsepositionen på det første punkt, og efter at have læst det punkt og derefter går læsepositionen videre til det næste punkt.

Hvad gør vi, hvis vi ønsker at læse flere linjer indtil slutningen af ​​filen? Vi vil blot gennemgå hele fillæsningsprocessen.

Detektering af slutningen af ​​fil

Nogle gange har vi brug for at læse indholdet af hele filen og er uvidende om antallet af linjer, vi skal gå igennem. I denne situation bruger vi while-løkken og hasNext()-metoden. hasNext()-metoden er en funktion af scannerklassen, der bestemmer, om filen har flere data at læse eller ej. Hvis der er flere data at læse, returnerer hasNext() metoden true, og når vi når slutningen af ​​filen, returnerer den falsk.

 import java.util.Scanner; // Needed for the Scanner class
 import java.io.*; // Needed for the File and IOException

 /**
 This program reads data from a file.
 */

 public class FileRead
 {
   public static void main(String[] args) throws IOException
   {
     // Open the file.
     File file = new File("days.txt");
     Scanner inFile = new Scanner(file);

     // Read lines from the file until no more are left.
     while (inFile.hasNext())
     {
     // Read the next day.
     String days = inFile.nextLine();

     // Display the last day read.
     System.out.println(days);
     }

     // Close the file.
     inFile.close();
     }
   }

Læsning af en binær fil

En binær fil er ikke som en tekstfil, fordi den ikke har data i tekstform. Derfor kan vi ikke se indholdet af en binær fil. En binær fil er meget mere effektiv end en tekstfil, fordi der er minimal konvertering, når du læser den.

For at håndtere binære filer har vi følgende klasse:

  • FileInputStream:Denne klasse giver dig mulighed for at åbne en binær fil og etablere en forbindelse med den. Men det giver kun grundlæggende funktionalitet som at læse bytes.
  • DataInputStream:Denne klasse bruges sammen med FileInputStream og giver dig mulighed for at læse data af den primitive type og strengobjekter fra den binære fil.

Nu åbner vi en binær fil til læsning af input. Vi tager input fra en .dat-fil som vist nedenfor i kodestykket.

FileInputStream fstream = new FileInputStream("Info.dat");
DataInputStream inputFile = new DataInputStream(fstream);

Her har vi åbnet en info.dat-fil. Når DataInputStream-objektet er blevet oprettet, kan vi bruge det til at læse dataene fra den binære fil. Koden nedenfor viser, hvordan vi kan læse en binær fil og derefter vise tal fra den.

import java.io.*;

 /**
 This program opens a binary file, reads
 and displays the contents.
 */

 public class ReadBinaryFile
 {
 public static void main(String[] args) throws IOException
 {
 int number; // A number read from the file
 boolean endOfFile = false; // EOF flag

 // Create the binary file input objects.
 FileInputStream fstream =
 new FileInputStream("Integers.dat");
 DataInputStream inFile =
 new DataInputStream(fstream);

 System.out.println("Reading numbers from the file:");

   // Read the contents of the file.
   // read until End of File is reached
   while (!endOfFile)
   {
   try
   {
   number = inFile.readInt();
   System.out.print(number + " ");
   }
   catch (EOFException e)
   {
   endOfFile = true;
   }
   }

   System.out.println("\nDone.");

   // Close the file.

     inFile.close();
 }
 }

Ovenstående kode er knyttet til koden nedenfor. Filen åbnes først til skrivning i koden nedenfor, og en række tal skrives ind i filen, som vist nedenfor. Denne .dat-fil bruges i ovenstående kode til at læse data fra en binær fil. Outputtet af ovenstående kode vil være det antal array, der er vist i koden nedenfor.

import java.io.*;

 /**
 This program opens a binary file and writes the contents
 of an int array to the file.
 */

 public class WriteBinaryFile
 {
   public static void main(String[] args)
   throws IOException
   {
   // An array to write to the file
   int[] numbers = { 1, 3, 5, 7, 9, 11, 13 };

   // Create the binary output objects.
   FileOutputStream fstream =
   new FileOutputStream("Integers.dat");
   DataOutputStream outFile =
   new DataOutputStream(fstream);

   System.out.println("Writing the numbers to the file...");

   // Write the array elements to the file.
   for (int i = 0; i < numbers.length; i++)
   outFile.writeInt(numbers[i]);

   System.out.println("Done.");

   // Close the file.
   outFile.close();
   }
 }

Konklusion

Så spørgsmålet, der opstår, er, at "Hvorfor læse input fra en fil, når vi simpelthen kan læse det fra tastaturet?". Svaret på dette spørgsmål er, at filbehandlingen er effektiv og fleksibel. Desuden bruges arkivering til at gemme og vise en stor mængde data, hvilket ikke ville være muligt på en konsol.


Java tag