Het lijkt erop dat er verschillende manieren zijn om gegevens van bestanden in Java te lezen en te schrijven.
Ik wil ASCII-gegevens uit een bestand lezen. Wat zijn de mogelijke manieren en hun verschillen?
Antwoord 1, autoriteit 100%
ASCII is een TEKST-bestand, dus u gebruikt Readersom te lezen. Java ondersteunt ook het lezen van een binair bestand met behulp van InputStreams. Als de bestanden die worden gelezen enorm zijn, zou je een BufferedReaderbovenop een FileReaderom de leesprestaties te verbeteren.
Ga door dit artikelover het gebruik van een Reader
Ik raad je ook aan om dit prachtige (maar gratis) boek genaamd Thinking te downloaden en te lezen Op Java
In Java 7:
new String(Files.readAllBytes(...))
(docs)
of
Files.readAllLines(...)
In Java 8:
Files.lines(..).forEach(...)
Antwoord 2, autoriteit 94%
Mijn favoriete manier om een klein bestand te lezen is om een BufferedReader en een StringBuilder te gebruiken. Het is heel eenvoudig en to the point (hoewel niet bijzonder effectief, maar goed genoeg voor de meeste gevallen):
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
} finally {
br.close();
}
Sommigen hebben erop gewezen dat u na Java 7 try-with-resources(dwz automatisch sluiten) functies:
try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
}
Als ik strings als deze lees, wil ik meestal toch wat string-afhandeling per regel doen, dus dan ga ik voor deze implementatie.
Als ik eigenlijk alleen een bestand in een string wil lezen, gebruik ik altijd Apache Commons IOmet de klasse IOUTils.toString() methode. Je kunt de bron hier bekijken:
http://www.docjar.com/html/api /org/apache/commons/io/IOUtils.java.html
FileInputStream inputStream = new FileInputStream("foo.txt");
try {
String everything = IOUtils.toString(inputStream);
} finally {
inputStream.close();
}
En nog eenvoudiger met Java 7:
try(FileInputStream inputStream = new FileInputStream("foo.txt")) {
String everything = IOUtils.toString(inputStream);
// do something with everything string
}
Antwoord 3, autoriteit 25%
De gemakkelijkste manier is om de klasse Scannerin Java en het FileReader-object te gebruiken. Eenvoudig voorbeeld:
Scanner in = new Scanner(new FileReader("filename.txt"));
Scannerheeft verschillende methodes voor het inlezen van strings, cijfers, enz… Meer informatie hierover kun je vinden op de Java-documentatiepagina.
Bijvoorbeeld het lezen van de hele inhoud in een String:
StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
sb.append(in.next());
}
in.close();
outString = sb.toString();
Ook als u een specifieke codering nodig heeft, kunt u deze gebruiken in plaats van FileReader:
new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
Antwoord 4, autoriteit 17%
Hier is een eenvoudige oplossing:
String content;
content = new String(Files.readAllBytes(Paths.get("sample.txt")));
Antwoord 5, autoriteit 10%
Hier is een andere manier om het te doen zonder externe bibliotheken te gebruiken:
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public String readFile(String filename)
{
String content = null;
File file = new File(filename); // For example, foo.txt
FileReader reader = null;
try {
reader = new FileReader(file);
char[] chars = new char[(int) file.length()];
reader.read(chars);
content = new String(chars);
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(reader != null){
reader.close();
}
}
return content;
}
Antwoord 6, autoriteit 7%
Ik moest de verschillende manieren benchmarken. Ik zal commentaar geven op mijn bevindingen, maar kortom, de snelste manier is om een gewone oude BufferedInputStream te gebruiken over een FileInputStream. Als er veel bestanden moeten worden gelezen, zullen drie threads de totale uitvoeringstijd tot ongeveer de helft verminderen, maar het toevoegen van meer threads zal de prestaties geleidelijk verslechteren totdat het drie keer langer duurt om twintig threads te voltooien dan met slechts één thread.
De veronderstelling is dat je een bestand moet lezen en iets zinvols moet doen met de inhoud ervan. In de voorbeelden hier leest u regels uit een logboek en telt u de regels die waarden bevatten die een bepaalde drempel overschrijden. Dus ik neem aan dat de one-liner Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))is geen optie.
Ik heb getest op Java 1.8, Windows 7 en zowel SSD- als HDD-schijven.
Ik heb zes verschillende implementaties geschreven:
rawParse: gebruik BufferedInputStream over een FileInputStream en knip de regels vervolgens byte voor byte. Dit presteerde beter dan elke andere benadering met één thread, maar het kan erg onhandig zijn voor niet-ASCII-bestanden.
lineReaderParse: gebruik een BufferedReader over een FileReader, lees regel voor regel, splits regels door String.split() aan te roepen. Dit is ongeveer 20% langzamer dan rawParse.
lineReaderParseParallel: dit is hetzelfde als lineReaderParse, maar het gebruikt verschillende threads. Dit is in alle gevallen de snelste optie.
nioFilesParse: gebruik java.nio.files.Files.lines()
nioAsyncParse: gebruik een AsynchronousFileChannel met een voltooiingshandler en een threadpool.
nioMemoryMappedParse: gebruik een aan het geheugen toegewezen bestand. Dit is echt een slecht idee, omdat de uitvoeringstijden minstens drie keer langer zijn dan bij elke andere implementatie.
Dit zijn de gemiddelde tijden voor het lezen van 204 bestanden van elk 4 MB op een quad-core i7- en SSD-schijf. De bestanden worden direct gegenereerd om schijfcaching te voorkomen.
rawParse 11.10 sec
lineReaderParse 13.86 sec
lineReaderParseParallel 6.00 sec
nioFilesParse 13.52 sec
nioAsyncParse 16.06 sec
nioMemoryMappedParse 37.68 sec
Ik vond een kleiner verschil dan ik had verwacht tussen draaien op een SSD of een HDD-schijf die de SSD ongeveer 15% sneller is. Dit kan zijn omdat de bestanden worden gegenereerd op een niet-gefragmenteerde HDD en ze opeenvolgend worden gelezen, waardoor de draaiende schijf bijna als een SSD kan werken.
Ik was verrast door de lage prestaties van de nioAsyncParse-implementatie. Of ik heb iets op de verkeerde manier geïmplementeerd of de multi-thread-implementatie met NIO en een voltooiingshandler presteert hetzelfde (of zelfs slechter) dan een single-thread-implementatie met de java.io API. Bovendien is de asynchrone ontleding met een CompletionHandler veel langer in coderegels en lastig om correct te implementeren dan een rechtstreekse implementatie op oude streams.
Nu de zes implementaties gevolgd door een klasse die ze allemaal bevat plus een parametreerbare main()-methode die het mogelijk maakt om te spelen met het aantal bestanden, de bestandsgrootte en de mate van gelijktijdigheid. Merk op dat de grootte van de bestanden plus minus 20% varieert. Dit is om elk effect te voorkomen omdat alle bestanden exact dezelfde grootte hebben.
rawParse
public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
overrunCount = 0;
final int dl = (int) ';';
StringBuffer lineBuffer = new StringBuffer(1024);
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileInputStream fin = new FileInputStream(fl);
BufferedInputStream bin = new BufferedInputStream(fin);
int character;
while((character=bin.read())!=-1) {
if (character==dl) {
// Here is where something is done with each line
doSomethingWithRawLine(lineBuffer.toString());
lineBuffer.setLength(0);
}
else {
lineBuffer.append((char) character);
}
}
bin.close();
fin.close();
}
}
public final void doSomethingWithRawLine(String line) throws ParseException {
// What to do for each line
int fieldNumber = 0;
final int len = line.length();
StringBuffer fieldBuffer = new StringBuffer(256);
for (int charPos=0; charPos<len; charPos++) {
char c = line.charAt(charPos);
if (c==DL0) {
String fieldValue = fieldBuffer.toString();
if (fieldValue.length()>0) {
switch (fieldNumber) {
case 0:
Date dt = fmt.parse(fieldValue);
fieldNumber++;
break;
case 1:
double d = Double.parseDouble(fieldValue);
fieldNumber++;
break;
case 2:
int t = Integer.parseInt(fieldValue);
fieldNumber++;
break;
case 3:
if (fieldValue.equals("overrun"))
overrunCount++;
break;
}
}
fieldBuffer.setLength(0);
}
else {
fieldBuffer.append(c);
}
}
}
Lineeraderparse
public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
String line;
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null)
doSomethingWithLine(line);
brd.close();
frd.close();
}
}
public final void doSomethingWithLine(String line) throws ParseException {
// Example of what to do for each line
String[] fields = line.split(";");
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
lineReaderParseParallel
public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
Thread[] pool = new Thread[degreeOfParalelism];
int batchSize = numberOfFiles / degreeOfParalelism;
for (int b=0; b<degreeOfParalelism; b++) {
pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
pool[b].start();
}
for (int b=0; b<degreeOfParalelism; b++)
pool[b].join();
}
class LineReaderParseThread extends Thread {
private String targetDir;
private int fileFrom;
private int fileTo;
private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private int overrunCounter = 0;
public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
this.targetDir = targetDir;
this.fileFrom = fileFrom;
this.fileTo = fileTo;
}
private void doSomethingWithTheLine(String line) throws ParseException {
String[] fields = line.split(DL);
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCounter++;
}
@Override
public void run() {
String line;
for (int f=fileFrom; f<fileTo; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
try {
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null) {
doSomethingWithTheLine(line);
}
brd.close();
frd.close();
} catch (IOException | ParseException ioe) { }
}
}
}
niofilesparse
public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
for (int f=0; f<numberOfFiles; f++) {
Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
Consumer<String> action = new LineConsumer();
Stream<String> lines = Files.lines(ph);
lines.forEach(action);
lines.close();
}
}
class LineConsumer implements Consumer<String> {
@Override
public void accept(String line) {
// What to do for each line
String[] fields = line.split(DL);
if (fields.length>1) {
try {
Date dt = fmt.parse(fields[0]);
}
catch (ParseException e) {
}
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
}
}
nioAsyncParse
public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();
for (int b=0; b<numberOfThreads; b++)
byteBuffers.add(ByteBuffer.allocate(bufferSize));
for (int f=0; f<numberOfFiles; f++) {
consumerThreads.acquire();
String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
channel.read(consumer.buffer(), 0l, channel, consumer);
}
consumerThreads.acquire(numberOfThreads);
}
class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {
private ConcurrentLinkedQueue<ByteBuffer> buffers;
private ByteBuffer bytes;
private String file;
private StringBuffer chars;
private int limit;
private long position;
private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
buffers = byteBuffers;
bytes = buffers.poll();
if (bytes==null)
bytes = ByteBuffer.allocate(bufferSize);
file = fileName;
chars = new StringBuffer(bufferSize);
frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
limit = bufferSize;
position = 0l;
}
public ByteBuffer buffer() {
return bytes;
}
@Override
public synchronized void completed(Integer result, AsynchronousFileChannel channel) {
if (result!=-1) {
bytes.flip();
final int len = bytes.limit();
int i = 0;
try {
for (i = 0; i < len; i++) {
byte by = bytes.get();
if (by=='\n') {
// ***
// The code used to process the line goes here
chars.setLength(0);
}
else {
chars.append((char) by);
}
}
}
catch (Exception x) {
System.out.println(
"Caught exception " + x.getClass().getName() + " " + x.getMessage() +
" i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
", position="+String.valueOf(position));
}
if (len==limit) {
bytes.clear();
position += len;
channel.read(bytes, position, channel, this);
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
@Override
public void failed(Throwable e, AsynchronousFileChannel channel) {
}
};
VOLLEDIG UITVOERBARE IMPLEMENTATIE VAN ALLE GEVALLEN
https://github.com/sergiomt/javaiobenchmark/blob/master/ FileReadBenchmark.java
Antwoord 7, autoriteit 5%
Hier zijn de drie werkende en geteste methoden:
Gebruik BufferedReader
package io;
import java.io.*;
public class ReadFromFile2 {
public static void main(String[] args)throws Exception {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
BufferedReader br = new BufferedReader(new FileReader(file));
String st;
while((st=br.readLine()) != null){
System.out.println(st);
}
}
}
Scanner
gebruiken
package io;
import java.io.File;
import java.util.Scanner;
public class ReadFromFileUsingScanner {
public static void main(String[] args) throws Exception {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
Scanner sc = new Scanner(file);
while(sc.hasNextLine()){
System.out.println(sc.nextLine());
}
}
}
Gebruik FileReader
package io;
import java.io.*;
public class ReadingFromFile {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.java");
int i;
while ((i=fr.read()) != -1){
System.out.print((char) i);
}
}
}
Lees het hele bestand zonder lus met de klasse Scanner
package io;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class ReadingEntireFileWithoutLoop {
public static void main(String[] args) throws FileNotFoundException {
File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
Scanner sc = new Scanner(file);
sc.useDelimiter("\\Z");
System.out.println(sc.next());
}
}
Antwoord 8, autoriteit 4%
De methoden binnen org.apache.commons.io.FileUtilskan ook erg handig zijn, bijvoorbeeld:
/**
* Reads the contents of a file line by line to a List
* of Strings using the default encoding for the VM.
*/
static List readLines(File file)
Antwoord 9, autoriteit 3%
Wat wil je met de tekst doen? Is het bestand klein genoeg om in het geheugen te passen? Ik zou proberen de eenvoudigste manier te vinden om het bestand voor uw behoeften te behandelen. De FileUtils-bibliotheek is hiervoor zeer geschikt.
for(String line: FileUtils.readLines("my-text-file"))
System.out.println(line);
Antwoord 10, autoriteit 2%
Ik heb 15 manieren beschreven om een bestand in Java te lezenen heb ze vervolgens getest op snelheid met verschillende bestandsgroottes – van 1 KB tot 1 GB en hier zijn de drie belangrijkste manieren om dit te doen:
-
java.nio.file.Files.readAllBytes()Getest om te werken in Java 7, 8 en 9.
import java.io.File; import java.io.IOException; import java.nio.file.Files; public class ReadFile_Files_ReadAllBytes { public static void main(String [] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); byte [] fileBytes = Files.readAllBytes(file.toPath()); char singleChar; for(byte b : fileBytes) { singleChar = (char) b; System.out.print(singleChar); } } } -
java.io.BufferedReader.readLine()Getest om te werken in Java 7, 8, 9.
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; public class ReadFile_BufferedReader_ReadLine { public static void main(String [] args) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; FileReader fileReader = new FileReader(fileName); try (BufferedReader bufferedReader = new BufferedReader(fileReader)) { String line; while((line = bufferedReader.readLine()) != null) { System.out.println(line); } } } } -
java.nio.file.Files.lines()Dit is getest om te werken in Java 8 en 9, maar werkt niet in Java 7 vanwege de lambda-expressievereiste.
import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.util.stream.Stream; public class ReadFile_Files_Lines { public static void main(String[] pArgs) throws IOException { String fileName = "c:\\temp\\sample-10KB.txt"; File file = new File(fileName); try (Stream linesStream = Files.lines(file.toPath())) { linesStream.forEach(line -> { System.out.println(line); }); } } }
Antwoord 11, autoriteit 2%
Hieronder staat een one-liner om het op de Java 8-manier te doen. Ervan uitgaande dat het bestand text.txtzich in de hoofdmap van de projectdirectory van de Eclipse bevindt.
Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
Antwoord 12
De gebufferde streamklassen presteren in de praktijk veel beter, zozeer zelfs dat de NIO.2 API methoden bevat die deze streamklassen specifiek retourneren, deels om u aan te moedigen altijd gebufferde streams in uw toepassing te gebruiken.
Hier is een voorbeeld:
Path path = Paths.get("/myfolder/myfile.ext");
try (BufferedReader reader = Files.newBufferedReader(path)) {
// Read from the stream
String currentLine = null;
while ((currentLine = reader.readLine()) != null)
//do your code here
} catch (IOException e) {
// Handle file I/O exception...
}
U kunt deze code vervangen
BufferedReader reader = Files.newBufferedReader(path);
met
BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));
Ik raad ditartikel aan om het belangrijkste gebruik van Java NIO en IO.
Antwoord 13
BufferedReader gebruiken:
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
BufferedReader br;
try {
br = new BufferedReader(new FileReader("/fileToRead.txt"));
try {
String x;
while ( (x = br.readLine()) != null ) {
// Printing out each line in the file
System.out.println(x);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
catch (FileNotFoundException e) {
System.out.println(e);
e.printStackTrace();
}
Antwoord 14
Dit is in principe hetzelfde als het antwoord van Jesus Ramos, behalve met Filein plaats van FileReaderplus herhaling om door de inhoud van het bestand te bladeren.
Scanner in = new Scanner(new File("filename.txt"));
while (in.hasNext()) { // Iterates each line in the file
String line = in.nextLine();
// Do something with line
}
in.close(); // Don't forget to close resource leaks
… gooit FileNotFoundException
Antwoord 15
Waarschijnlijk niet zo snel als met gebufferde I/O, maar nogal beknopt:
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
Het patroon \Zvertelt de Scannerdat het scheidingsteken EOF is.
Antwoord 16
De meest intuïtieve methode is geïntroduceerd in Java 11 Files.readString
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String args[]) throws IOException {
String content = Files.readString(Paths.get("D:\\sandbox\\mvn\\my-app\\my-app.iml"));
System.out.print(content);
}
}
PHP heeft deze luxeal tientallen jaren!
Antwoord 17
De eenvoudigste manier om gegevens uit een bestand in Java te lezen, is door de klasse Filete gebruiken om het bestand te lezen en de klasse Scannerom de inhoud van de bestand.
public static void main(String args[])throws Exception
{
File f = new File("input.txt");
takeInputIn2DArray(f);
}
public static void takeInputIn2DArray(File f) throws Exception
{
Scanner s = new Scanner(f);
int a[][] = new int[20][20];
for(int i=0; i<20; i++)
{
for(int j=0; j<20; j++)
{
a[i][j] = s.nextInt();
}
}
}
PS: vergeet niet java.util.* te importeren; om de scanner te laten werken.
Antwoord 18
Je kunt readAllLines en de joinmethode gebruiken om hele bestandsinhoud op één regel te krijgen:
String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));
Het gebruikt standaard UTF-8-codering, die ASCII-gegevens correct leest.
U kunt ook readAllBytes gebruiken:
String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);
Ik denk dat readAllBytes sneller en nauwkeuriger is, omdat het de nieuwe regel niet vervangt door \nen ook de nieuwe regel kan \r\nzijn. Het hangt af van uw behoeften welke geschikt is.
Antwoord 19
Ik zie het tot nu toe nog niet genoemd in de andere antwoorden. Maar als ‘Best’ snelheid betekent, dan biedt de nieuwe Java I/O (NIO) misschien de snelste prestaties, maar niet altijd de gemakkelijkste om uit te zoeken voor iemand die leert.
http://download.oracle.com/javase/tutorial/ essentieel/io/file.html
Antwoord 20
Guavabiedt hiervoor een one-liner:
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);
Antwoord 21
Cactoosgeven je een declaratieve one-liner:
new TextOf(new File("a.txt")).asString();
Antwoord 22
Dit is misschien niet het exacte antwoord op de vraag. Het is gewoon een andere manier om een bestand te lezen waarbij je niet expliciet het pad naar je bestand specificeert in je Java-code, maar in plaats daarvan leest als een opdrachtregelargument.
Met de volgende code,
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class InputReader{
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s="";
while((s=br.readLine())!=null){
System.out.println(s);
}
}
}
ga je gang en voer het uit met:
java InputReader < input.txt
Hierdoor wordt de inhoud van de input.txtgelezen en afgedrukt naar uw console.
U kunt uw System.out.println()ook als volgt naar een specifiek bestand laten schrijven via de opdrachtregel:
java InputReader < input.txt > output.txt
Dit zou lezen van input.txten schrijven naar output.txt.
Antwoord 23
Voor op JSF gebaseerde Maven-webapplicaties gebruikt u gewoon ClassLoader en de map Resourcesom elk gewenst bestand in te lezen:
- Plaats een bestand dat u wilt lezen in de map Bronnen.
-
Zet de Apache Commons IO-afhankelijkheid in uw POM:
<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-io</artifactId> <version>1.3.2</version> </dependency> -
Gebruik de onderstaande code om het te lezen (bijv. hieronder leest in een .json-bestand):
String metadata = null; FileInputStream inputStream; try { ClassLoader loader = Thread.currentThread().getContextClassLoader(); inputStream = (FileInputStream) loader .getResourceAsStream("/metadata.json"); metadata = IOUtils.toString(inputStream); inputStream.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return metadata;
U kunt hetzelfde doen voor tekstbestanden, .properties-bestanden, XSDschema’s, enz.
Antwoord 24
try {
File f = new File("filename.txt");
Scanner r = new Scanner(f);
while (r.hasNextLine()) {
String data = r.nextLine();
JOptionPane.showMessageDialog(data);
}
r.close();
} catch (FileNotFoundException ex) {
JOptionPane.showMessageDialog("Error occurred");
ex.printStackTrace();
}
Antwoord 25
Gebruik Java-kusals dit gaat over eenvoud van structuur:
import static kiss.API.*;
class App {
void run() {
String line;
try (Close in = inOpen("file.dat")) {
while ((line = readLine()) != null) {
println(line);
}
}
}
}
Antwoord 26
import java.util.stream.Stream;
import java.nio.file.*;
import java.io.*;
class ReadFile {
public static void main(String[] args) {
String filename = "Test.txt";
try(Stream<String> stream = Files.lines(Paths.get(filename))) {
stream.forEach(System.out:: println);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Gebruik gewoon Java 8 Stream.
Antwoord 27
Deze code die ik heb geprogrammeerd, is veel sneller voor zeer grote bestanden:
public String readDoc(File f) {
String text = "";
int read, N = 1024 * 1024;
char[] buffer = new char[N];
try {
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
while(true) {
read = br.read(buffer, 0, N);
text += new String(buffer, 0, read);
if(read < N) {
break;
}
}
} catch(Exception ex) {
ex.printStackTrace();
}
return text;
}
Antwoord 28
String fileName = 'yourFileFullNameWithPath';
File file = new File(fileName); // Creates a new file object for your file
FileReader fr = new FileReader(file);// Creates a Reader that you can use to read the contents of a file read your file
BufferedReader br = new BufferedReader(fr); //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
De bovenstaande set van de lijn kan worden geschreven in 1 enkele regel als:
BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional
Toevoegen aan String Builder (als u bestand enorm is, wordt geadviseerd om String Builder anders Normaal String-object te gebruiken)
try {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
} finally {
br.close();
}