Een gids voor de Java FileReader-klasse

1. Overzicht

Zoals de naam al doet vermoeden, FileReader is een Java-klasse die het gemakkelijk maakt om de inhoud van een bestand te lezen.

In deze tutorial leren we het basisconcept van a Lezer en hoe we de FileReader class voor het uitvoeren van leesbewerkingen op een tekenstroom in Java.

2. Lezer Basics

Als we kijken naar de code van de FileReader class, dan zullen we zien dat de class minimale code bevat voor het maken van een FileReader object en geen andere methoden.

Dit roept vragen op als "Wie doet het zware werk achter deze klas?"

Om deze vraag te beantwoorden, moeten we het concept en de hiërarchie van de Lezer klasse in Java.

Lezer is een abstracte basisklasse die het lezen van karakters mogelijk maakt door middel van een van zijn concrete implementaties. Het definieert de volgende basisbewerkingen voor het lezen van tekens van elk medium, zoals geheugen of het bestandssysteem:

  • Lees een enkel teken
  • Lees een reeks tekens
  • Markeer en reset een bepaalde positie in een reeks tekens
  • Sla positie over tijdens het lezen van een personagestream
  • Sluit de invoerstroom

Uiteraard zijn alle implementaties van Lezer class moet alle abstracte methoden implementeren, namelijk lezen() en dichtbij(). Bovendien overschrijven de meeste implementaties ook andere overgeërfde methoden om extra functionaliteit of betere prestaties te bieden.

2.1. Wanneer gebruik je een FileReader

Nu we enig begrip hebben over a Lezer, we zijn klaar om onze focus terug te brengen naar de FileReader klasse.

FileReader erft zijn functionaliteit van InputStreamReader, wat een is Lezer implementatie ontworpen om bytes uit een invoerstroom als tekens te lezen.

Laten we deze hiërarchie eens bekijken in de klassendefinities:

openbare klasse InputStreamReader breidt Reader uit {} openbare klasse FileReader breidt InputStreamReader {} uit

Over het algemeen kunnen we een InputStreamReader voor het lezen van tekens van elke invoerbron.

Als het echter aankomt op het lezen van tekst uit een bestand, gebruik dan een InputStreamReader zou zijn als het snijden van een appel met een zwaard. Het juiste gereedschap is natuurlijk een mes, en dat is precies wat FileReader belooft.

Wij kunnen gebruik een FileReader wanneer we tekst uit een bestand willen lezen met de standaardtekenset van het systeem. Voor elke andere geavanceerde functionaliteit zou het ideaal zijn om gebruik van te maken InputStreamReader klas direct.

3. Een tekstbestand lezen met een FileReader

Laten we een codeeroefening doorlopen waarbij we tekens uit een HalloWorld.txt bestand met een FileReader voorbeeld.

3.1. Een FileReader

Als gemaksklasse, FileReader biedt drie overbelaste constructeurs aan die kan worden gebruikt om een ​​lezer te initialiseren die als invoerbron uit een bestand kan lezen.

Laten we deze constructeurs eens bekijken:

openbare FileReader (String bestandsnaam) gooit FileNotFoundException {super (nieuwe FileInputStream (bestandsnaam)); } openbare FileReader (bestandsbestand) gooit FileNotFoundException {super (nieuwe FileInputStream (bestand)); } openbare FileReader (FileDescriptor fd) {super (nieuwe FileInputStream (fd)); }

In ons geval kennen we de bestandsnaam van het invoerbestand. Daarom kunnen we de eerste constructor gebruiken om een ​​lezer te initialiseren:

FileReader fileReader = nieuwe FileReader (pad);

3.2. Een enkel personage lezen

Laten we vervolgens maken readAllCharactersOneByOne (), een methode om tekens één voor één uit het bestand te lezen:

openbare statische String readAllCharactersOneByOne (Reader-lezer) gooit IOException {StringBuilder content = new StringBuilder (); int nextChar; while ((nextChar = reader.read ())! = -1) {content.append ((char) nextChar); } return String.valueOf (inhoud); }

Zoals we kunnen zien aan de hand van de bovenstaande code, hebben we gebruikte delezen() methode in een lus om de tekens één voor één te lezen totdat deze -1 retourneert, wat betekent dat er geen tekens meer zijn om te lezen.

Laten we nu onze code testen door te valideren dat de tekst die uit het bestand wordt gelezen overeenkomt met de verwachte tekst:

@Test openbare leegte gegevenFileReader_whenReadAllCharacters_thenReturnsContent () gooit IOException {String verwachtText = "Hallo, wereld!"; Bestandsbestand = nieuw bestand (FILE_PATH); probeer (FileReader fileReader = nieuwe FileReader (bestand)) {String content = FileReaderExample.readAllCharactersOneByOne (fileReader); Assert.assertEquals (verwachte tekst, inhoud); }}

3.3. Lezen van een reeks karakters

We kunnen zelfs meerdere tekens tegelijk lezen met behulp van de overgeërfde lezen (char cbuf [], int off, int len) methode:

openbare statische String readMultipleCharacters (Reader reader, int length) gooit IOException {char [] buffer = new char [length]; int charactersRead = reader.read (buffer, 0, lengte); if (charactersRead! = -1) {return new String (buffer, 0, charactersRead); } else {return ""; }}

Er is een subtiel verschil in de geretourneerde waarde van lezen() als het gaat om het lezen van meerdere tekens in een array. De retourwaarde hier is ofwel het aantal gelezen tekens of -1 als de lezer het einde van de inputstroom heeft bereikt.

Laten we vervolgens de juistheid van onze code testen:

@Test openbare leegte gegevenFileReader_whenReadMultipleCharacters_thenReturnsContent () gooit IOException {String verwachtText = "Hallo"; Bestandsbestand = nieuw bestand (FILE_PATH); probeer (FileReader fileReader = nieuwe FileReader (bestand)) {String content = FileReaderExample.readMultipleCharacters (fileReader, 5); Assert.assertEquals (verwachte tekst, inhoud); }}

4. Beperkingen

We hebben gezien dat de FileReader class is afhankelijk van de standaard karaktercodering van het systeem.

Dus voor situaties, waar we aangepaste waarden moeten gebruiken voor de tekenset, buffergrootte of invoerstroom moeten we gebruik InputStreamReader.

Bovendien weten we allemaal dat I / O-cycli duur zijn en latency in onze applicatie kunnen introduceren. Het is dus in ons eigen belang minimaliseer het aantal I / O-bewerkingen door een BufferedReader rond onze FileReader voorwerp:

BufferedReader in = nieuwe BufferedReader (fileReader);

5. Conclusie

In deze tutorial hebben we geleerd over de basisconcepten van a Lezer en hoe FileReader maakt het eenvoudig om leesbewerkingen op tekstbestanden uit te voeren door middel van enkele voorbeelden.

Zoals altijd is de volledige broncode voor de tutorial beschikbaar op GitHub.