자바에서 일반 텍스트 파일 읽기
Java에서 파일의 데이터를 읽고 쓰는 방법은 여러 가지가 있습니다.
파일에서 ASCII 데이터를 읽고 싶습니다. 가능한 방법과 차이점은 무엇입니까?
ASCII는 TEXT 파일이므로 Readers읽기에 사용 합니다. Java는 또한 InputStreams. 읽고있는 파일이 큰 경우 다음 당신은을 사용할 것 BufferedReader(A)의 상단에 FileReader읽기 성능을 향상 할 수 있습니다.
를 통해 이동 이 문서 을 사용하는 방법에Reader
또한 Thinking In Java 라는이 멋진 (아직 무료) 책을 다운로드하여 읽어 보는 것이 좋습니다 .
Java 7에서 :
new String(Files.readAllBytes(...))
(문서) 또는
Files.readAllLines(...)
Java 8에서 :
Files.lines(..).forEach(...)
작은 파일을 읽는 가장 좋은 방법은 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-with-resources (즉, 자동 닫기) 기능 을 사용해야한다고 지적했습니다 .
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
}
가장 쉬운 방법은 ScannerJava 의 클래스와 FileReader 객체 를 사용하는 것입니다. 간단한 예 :
Scanner in = new Scanner(new FileReader("filename.txt"));
Scanner 문자열, 숫자 등을 읽을 수있는 몇 가지 방법이 있습니다. 이에 대한 자세한 정보는 Java 문서 페이지에서 찾을 수 있습니다.
예를 들어 전체 콘텐츠를 다음과 같이 읽습니다 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;
content = new String(Files.readAllBytes(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 배 더 오래 걸릴 때까지 성능이 점차 저하됩니다.
파일을 읽고 그 내용으로 의미있는 일을해야한다고 가정합니다. 여기의 예에서는 로그에서 행을 읽고 특정 임계 값을 초과하는 값을 포함하는 행을 계산합니다. 그래서 저는 한 줄짜리 Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))이 옵션이 아니라고 가정합니다 .
Java 1.8, Windows 7 및 SSD 및 HDD 드라이브에서 테스트했습니다.
나는 여섯 가지 다른 구현을 썼다.
rawParse : FileInputStream을 통해 BufferedInputStream을 사용한 다음 바이트 단위로 읽는 줄을 자릅니다. 이것은 다른 단일 스레드 접근 방식보다 성능이 좋지만 ASCII가 아닌 파일에는 매우 불편할 수 있습니다.
lineReaderParse : FileReader를 통해 BufferedReader를 사용하고, 한 줄씩 읽고, String.split ()을 호출하여 줄을 분할합니다. 이것은 rawParse보다 약 20 % 느립니다.
lineReaderParseParallel : lineReaderParse 와 동일하지만 여러 스레드를 사용합니다. 이것은 모든 경우에 전반적으로 가장 빠른 옵션입니다.
nioFilesParse : java.nio.files.Files.lines () 사용
nioAsyncParse : 완료 핸들러 및 스레드 풀과 함께 AsynchronousFileChannel을 사용합니다.
nioMemoryMappedParse : 메모리 매핑 파일을 사용합니다. 이것은 다른 어떤 구현보다 실행 시간이 최소 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에서 실행하는 것과 HDD 드라이브에서 실행하는 것 사이의 차이가 예상보다 약 15 % 더 빠르다는 것을 발견했습니다. 파일이 조각화되지 않은 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());
}
}
다음과 같은 방법 org.apache.commons.io.FileUtils도 매우 편리 할 수 있습니다.
/**
* 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까지)로 속도를 테스트했으며이를 수행하는 세 가지 방법이 있습니다.
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); }); } } }
다음은 Java 8 방식으로 수행하는 한 줄입니다. text.txt파일이 Eclipse의 프로젝트 디렉토리 루트에 있다고 가정 합니다.
Files.lines(Paths.get("text.txt")).collect(Collectors.toList());
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();
}
이것은 FileReader 대신 File 과 파일 내용을 단계별로 반복하는 것을 제외하고는 Jesus Ramos의 대답과 똑같습니다 .
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
아마도 버퍼링 된 I / O만큼 빠르지는 않지만 상당히 간결합니다.
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
\Z패턴은 알려줍니다 Scanner구분 기호가 EOF이다.
버퍼링 된 스트림 클래스는 실제로 훨씬 더 성능이 뛰어나므로 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의 주요 용도를 배우려면 이 기사를 권장 합니다 .
지금까지 다른 답변에서 아직 언급되지 않았습니다. 그러나 "최고"가 속도를 의미한다면 새로운 Java I / O (NIO)가 가장 빠른 성능을 제공 할 수 있지만 학습하는 사람에게 항상 가장 쉬운 것은 아닙니다.
http://download.oracle.com/javase/tutorial/essential/io/file.html
Java에서 파일에서 데이터를 읽는 가장 간단한 방법은 File 클래스를 사용하여 파일 을 읽고 Scanner 클래스를 사용하여 파일 내용을 읽는 것입니다.
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();
}
}
}
추신 : java.util. *를 가져 오는 것을 잊지 마십시오. 스캐너가 작동합니다.
Guava 는이를 위해 한 줄짜리를 제공합니다.
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String contents = Files.toString(filePath, Charsets.UTF_8);
이것은 질문에 대한 정확한 대답이 아닐 수도 있습니다. 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입니다.
readAllLines 및 join메서드를 사용하여 전체 파일 내용을 한 줄로 가져올 수 있습니다 .
String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));
기본적으로 ASCII 데이터를 올바르게 읽는 UTF-8 인코딩을 사용합니다.
또한 readAllBytes를 사용할 수 있습니다.
String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);
나는 readAllBytes가 더 빠르고 정확하다고 생각합니다. 왜냐하면 새 줄을 대체하지 않고 \n줄 바꿈이 될 수도 있기 때문 \r\n입니다. 어느 것이 적합한 지 귀하의 필요에 따라 다릅니다.
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 스키마 등에 대해 동일한 작업을 수행 할 수 있습니다 .
new TextOf(new File("a.txt")).asString();
구조의 단순성에 관한 경우 Java 키스를 사용하십시오 .
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을 사용하십시오.
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.
위의 라인 세트는 다음과 같이 단일 라인으로 작성할 수 있습니다.
BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional
문자열 작성기에 추가 (파일이 큰 경우 문자열 작성기를 사용하고 일반 문자열 개체를 사용하는 것이 좋습니다)
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();
}
내가 프로그래밍 한이 코드는 매우 큰 파일의 경우 훨씬 빠릅니다.
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
'developer tip' 카테고리의 다른 글
| 반복하는 동안 목록에서 항목을 제거하는 방법은 무엇입니까? (0) | 2020.09.28 |
|---|---|
| node.js에서 HTTP POST 요청은 어떻게 이루어 집니까? (0) | 2020.09.28 |
| Expression을 사용하는 이유 (0) | 2020.09.28 |
| 전화 번호 확인을위한 포괄적 인 정규식 (0) | 2020.09.28 |
| 명령 줄에서 .bash_profile을 다시로드하는 방법은 무엇입니까? (0) | 2020.09.28 |