Java에서 일반 텍스트 파일 읽기
자바에서는 파일 데이터를 읽고 쓰는 방법이 다른 것 같습니다.
파일에서 ASCII 데이터를 읽고 싶습니다.가능한 방법 및 차이점은 무엇입니까?
작은 파일을 읽는 가장 좋은 방법은 BufferedReader와 StringBuilder를 사용하는 것입니다.이것은 매우 간단하고 요점(특별히 효과적이지는 않지만 대부분의 경우 충분합니다):
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();
}
일부에서는 Java 7 이후 리소스 사용(즉, 자동 닫기) 기능을 사용해야 한다고 지적했습니다.
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();
}
이런 스트링을 읽을 때는 어차피 한 줄에 몇 가지 스트링 처리를 하고 싶기 때문에 이 실장을 합니다.
파일을 String에 읽기만 하면 되는데 항상 IOUtils.toString() 클래스의 Apache Commons IO를 사용합니다.출처는 다음과 같습니다.
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();
}
Java 7을 사용하면 더욱 심플해집니다.
try(FileInputStream inputStream = new FileInputStream("foo.txt")) {
String everything = IOUtils.toString(inputStream);
// do something with everything string
}
ASCII는 TEXT 파일이기 때문에 판독에 사용합니다.Java는 를 사용하여 바이너리 파일을 읽을 수도 있습니다.읽는 파일이 큰 경우 위에 를 사용하여 읽기 성능을 향상시킬 수 있습니다.
이 문서의 사용 방법에 대해 자세히 읽어보십시오.Reader
또, 「Thinking In Java」라고 하는 훌륭한(그러나 무료) 책을 다운로드해 읽는 것도 추천합니다.
Java 7의 경우:
new String(Files.readAllBytes(...))
(표준) 또는
Files.readAllLines(...)
Java 8의 경우:
Files.lines(..).forEach(...)
은 '우리'를 입니다.ScannerJava FileReader " " " 。[ ] :
Scanner in = new Scanner(new FileReader("filename.txt"));
Scanner문자열, 숫자 등을 읽는 몇 가지 방법이 있습니다.자바.
, 전체 요, 다 읽는다, 다 읽다.String:
StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
sb.append(in.next());
}
in.close();
outString = sb.toString();
, 는, 「 」 「 」 「 」 「 」 「 」 「 」 「 」 「 」 「 」FileReader:
new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
간단한 해결책은 다음과 같습니다.
String content = new String(Files.readAllBytes(Paths.get("sample.txt")));
또는 목록으로 읽으려면:
List<String> content = Files.readAllLines(Paths.get("sample.txt"))
외부 라이브러리를 사용하지 않고 이를 수행할 수 있는 또 다른 방법은 다음과 같습니다.
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;
}
나는 다른 방법을 벤치마킹해야 했다.조사 결과에 대해 코멘트를 드리지만, 간단히 말하면 FileInputStream보다 일반 오래된 BufferedInputStream을 사용하는 것이 가장 빠른 방법입니다.많은 파일을 읽어야 하는 경우, 3개의 스레드로 인해 총 실행 시간이 약 절반으로 단축되지만, 스레드를 추가하면 스레드 1개보다 20개의 스레드로 완료하는 데 3배 더 오래 걸릴 때까지 성능이 점차 저하됩니다.
파일을 읽고, 그 내용에 대해 의미 있는 작업을 실시할 필요가 있는 것을 전제로 하고 있습니다.이 예에서는 로그에서 행을 읽고 특정 임계값을 초과하는 값을 포함하는 행을 카운트하고 있습니다. 저는 8은 이라고 합니다.Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))선택사항이 아닙니다.
Java 1.8, Windows 7 및 SSD 및 HDD 드라이브에서 테스트했습니다.
6개의 다른 구현을 작성했습니다.
rawParse:FileInputStream을 통해 BufferedInputStream을 사용한 후 바이트 단위로 읽어내는 행을 잘라냅니다.이것은 다른 어떤 싱글 스레드 방식보다 성능이 뛰어나지만 ASCII 이외의 파일에서는 매우 불편할 수 있습니다.
lineReaderParse:FileReader 위에 BufferedReader를 사용하여 String.split()를 호출하여 한 줄씩 읽고 분할 행을 읽습니다.이것은 rawParse보다 약 20% 느립니다.
lineReaderParseParallel:이는 lineReaderParse와 동일하지만 여러 스레드를 사용합니다.이것은 모든 경우에 있어서 전체적으로 가장 빠른 옵션입니다.
nioFilesParse:java.nio를 사용합니다.files.Files.lines()
nioAsyncParse:완료 핸들러 및 스레드풀과 함께 Asynchronous File Channel을 사용합니다.
nio Memory Mapped Parse:메모리 매핑된 파일을 사용합니다.이는 다른 구현보다 최소 3배 긴 실행 시간을 산출하는 매우 좋지 않은 아이디어입니다.
쿼드코어 i7 및 SSD 드라이브에서 각각 4MB씩 204개의 파일을 읽는 평균 시간입니다.디스크 캐싱을 방지하기 위해 파일이 즉시 생성됩니다.
rawParse 11.10 sec
lineReaderParse 13.86 sec
lineReaderParseParallel 6.00 sec
nioFilesParse 13.52 sec
nioAsyncParse 16.06 sec
nioMemoryMappedParse 37.68 sec
SSD에서 실행하는 것과 SSD보다 약 15% 빠른 HDD 드라이브의 차이가 생각보다 작았습니다.이는 파일이 조각화되지 않은 HDD에서 생성되고 순차적으로 읽히기 때문에 회전 드라이브가 SSD와 거의 같은 성능을 발휘할 수 있기 때문일 수 있습니다.
nioAsyncParse 구현의 낮은 성능에 놀랐습니다.잘못된 방법으로 구현했거나 NIO를 사용한 멀티 스레드 구현과 완료 핸들러는 java.io API를 사용한 싱글 스레드 구현과 동일한(또는 더 나쁜) 작업을 수행합니다.또한 CompletionHandler를 사용한 비동기 해석은 오래된 스트림에 직접 구현하는 것보다 코드 행이 훨씬 길고 올바르게 구현하기가 어렵습니다.
6개의 구현에 이어 이들 모두를 포함하는 클래스와 파일 수, 파일 크기 및 동시성 정도를 재생할 수 있는 파라미터 지정 가능한 main() 메서드가 있습니다.파일의 사이즈는 플러스 마이너스 20%에 달합니다.이는 모든 파일의 크기가 완전히 동일하기 때문에 영향을 받지 않기 위한 것입니다.
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);
}
}
}
lineReaderParse
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) {
}
};
모든 케이스의 풀 실행 가능한 구현
https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java
다음은 작동 및 테스트된 세 가지 방법입니다.
「」를 사용합니다.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
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());
}
}
}
「」를 사용합니다.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);
}
}
}
하지 않고 .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());
}
}
또한 다음과 같은 방법으로 매우 편리할 수 있습니다.
/**
* 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)
텍스트로 무엇을 하고 싶으세요?파일이 메모리에 들어갈 정도로 작습니까?고객님의 필요에 따라 가장 간단하게 파일을 처리할 수 있는 방법을 찾아보겠습니다.FileUtils 라이브러리는 이 문제를 매우 잘 처리합니다.
for(String line: FileUtils.readLines("my-text-file"))
System.out.println(line);
Java에서 파일을 읽는 15가지 방법을 문서화하여 다양한 파일 크기(1KB에서 1GB까지)로 속도를 테스트했습니다.이것을 실현하는 상위 3가지 방법은 다음과 같습니다.
java.nio.file.Files.readAllBytes()Java 7, 8, 및 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()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()이것은 Java 8과 9에서 동작하도록 테스트되었지만 람다 표현 요건이 있기 때문에 Java 7에서는 동작하지 않습니다.
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); }); } } }
자바8을 사용합니다.정 text.txt이클립스
Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
버퍼링된 스트림클래스는 실제로 훨씬 퍼포먼스가 뛰어나기 때문에 NIO.2 API에는 이러한 스트림클래스를 반환하는 메서드가 포함되어 있습니다.이는 어플리케이션에서 항상 버퍼링된 스트림을 사용하도록 권장하는 부분이기도 합니다.
다음은 예를 제시하겠습니다.
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...
}
이 코드를 바꿀 수 있습니다.
BufferedReader reader = Files.newBufferedReader(path);
와 함께
BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));
Java NIO와 IO의 주요 용도를 알아보려면 이 문서를 추천합니다.
BufferedReader 사용:
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();
}
이것은 기본적으로 Jesus Ramos의 답변과 동일합니다.단, FileReader가 아닌 File과 파일의 내용을 확인하는 반복을 사용합니다.
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
을 던지다FileNotFoundException
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는 수십 년 동안 이런 사치를 누려왔습니다!☺
버퍼링된 I/O만큼 빠르지는 않지만 매우 간결합니다.
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
그\Z패턴은Scanner딜리미터가 EOF임을 나타냅니다.
Java에서 파일로부터 데이터를 읽는 가장 간단한 방법은 파일 클래스를 사용하여 파일을 읽고 스캐너 클래스를 사용하여 파일 내용을 읽는 것입니다.
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: java.util을 Import하는 것을 잊지 마십시오.*; 스캐너가 작동합니다.
readAllLines 및join전체 파일 내용을 한 줄로 가져오는 방법:
String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));
기본적으로는 UTF-8 인코딩을 사용하여 ASCII 데이터를 올바르게 읽습니다.
또한 readAllBytes를 사용할 수 있습니다.
String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);
readAllBytes가 더 빠르고 더 정확하다고 생각합니다. 왜냐하면 새로운 행이 다음 행으로 대체되지 않기 때문입니다.\n또한 새로운 라인은\r\n어떤 것이 적합한지에 따라 다릅니다.
다른 답변에서는 아직 언급되지 않은 것 같습니다.그러나 "최고"가 속도를 의미한다면, 새로운 Java I/O(NIO)가 가장 빠른 성능을 제공할 수 있지만 학습자에게 가장 쉽게 이해되는 것은 아닙니다.
http://download.oracle.com/javase/tutorial/essential/io/file.html
Guava는 이를 위한 단일 라인:
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);
선인장은 선언적인 한 줄의 선인장을 제공합니다.
new TextOf(new File("a.txt")).asString();
이것은 질문에 대한 정확한 답이 아닐 수 있습니다.이는 Java 코드에서 파일 경로를 명시적으로 지정하지 않고 명령줄 인수로 읽는 파일을 읽는 또 다른 방법입니다.
다음 코드와 함께
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);
}
}
}
다음으로 실행해 주세요.
java InputReader < input.txt
이것은, 의 내용을 읽습니다.input.txt콘솔로 출력합니다.
또, 그 유저희망으로System.out.println()명령줄을 사용하여 다음과 같이 특정 파일에 씁니다.
java InputReader < input.txt > output.txt
이것은 에서 읽을 수 있다.input.txt편지를 쓰다output.txt.
JSF 기반의 Maven 웹 어플리케이션의 경우 ClassLoader와Resources원하는 파일에서 읽을 폴더:
- 읽을 파일을 Resources 폴더에 넣습니다.
Apache Commons IO 의존성을 POM에 넣습니다.
<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-io</artifactId> <version>1.3.2</version> </dependency>다음 코드를 사용하여 읽습니다(예: 아래는 .json 파일로 읽습니다).
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;
텍스트 파일, .properties 파일, XSD 스키마 등에 대해서도 동일한 작업을 수행할 수 있습니다.
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();
}
import static kiss.API.*;
class App {
void run() {
String line;
try (Close in = inOpen("file.dat")) {
while ((line = readLine()) != null) {
println(line);
}
}
}
}
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();
}
}
}
java 8 Stream을 사용하면 됩니다.
대용량 파일이 있는 경우 Apache Commons IO를 사용하여 사용 가능한 메모리를 소진하지 않고 파일을 반복적으로 처리할 수 있습니다.
try (LineIterator it = FileUtils.lineIterator(theFile, "UTF-8")) {
while (it.hasNext()) {
String line = it.nextLine();
// do something with line
}
}
내가 프로그래밍한 이 코드는 매우 큰 파일의 경우 훨씬 더 빠릅니다.
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;
}
언급URL : https://stackoverflow.com/questions/4716503/reading-a-plain-text-file-in-java
'source' 카테고리의 다른 글
| 이 날짜 형식은 무엇입니까?2011-08-12T20:17:46.384Z (0) | 2022.08.20 |
|---|---|
| 웹 소켓 돌연변이를 사용하여 vuex를 구성하는 방법 (0) | 2022.08.20 |
| 매개 변수화된 테스트 이름 변경 (0) | 2022.08.19 |
| laravel-vujs 프로젝트의 루트/베이스 URL을 설정하려면 어떻게 해야 합니까? (0) | 2022.08.19 |
| 지점 예측 변수에 지점을 따를 가능성을 알려줄 수 있습니까? (0) | 2022.08.19 |