[java] Java로 일반 텍스트 파일 읽기

Java로 파일의 데이터를 읽고 쓰는 다른 방법이있는 것 같습니다.

파일에서 ASCII 데이터를 읽고 싶습니다. 가능한 방법과 차이점은 무엇입니까?

답변

ASCII는 텍스트 파일이므로 Readers읽을 때 사용 합니다. Java는 또한를 사용하여 이진 파일에서 읽기를 지원합니다 InputStreams. 읽고있는 파일이 너무 큰 경우 BufferedReader에는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(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();
}

이와 같은 문자열을 읽을 때 일반적으로 줄마다 문자열 처리를 원 하므로이 구현으로 이동합니다.

실제로 파일을 문자열로 읽으려면 항상 Apache Commons IO를 사용합니다. IOUtils.toString () 클래스와 함께 사용하십시오. 여기서 소스를 살펴볼 수 있습니다.

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을 사용하는 것입니다. 많은 파일을 읽어야하는 경우 세 개의 스레드는 총 실행 시간을 대략 절반으로 줄이지 만 더 많은 스레드를 추가하면 하나의 스레드보다 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 드라이브가 SSD에서 약 15 % 더 빠를 때의 예상보다 작은 차이를 발견했습니다. 파일이 조각화되지 않은 HDD에서 생성되고 순차적으로 읽혀지기 때문에 회전 드라이브가 거의 SSD처럼 작동 할 수 있습니다.

nioAsyncParse 구현의 성능이 저하되어 놀랐습니다. 내가 잘못된 방식으로 무언가를 구현했거나 NIO를 사용하는 멀티 스레드 구현 및 완료 핸들러는 java.io API를 사용한 단일 스레드 구현과 동일하거나 더 나쁜 성능을 수행합니다. 또한 CompletionHandler를 사용한 비동기 구문 분석은 코드 줄이 훨씬 길고 이전 스트림의 직선 구현보다 올바르게 구현하기가 까다로워집니다.

이제 6 개의 구현 다음에 모두 포함 된 클래스와 파일 수, 파일 크기 및 동시성 정도를 재생할 수있는 매개 변수화 가능한 main () 메소드가 포함됩니다. 파일의 크기에 20에서 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());
    }
}

답변

답변

답변

답변

답변

답변

답변

사용 BufferedReader

사용 Scanner

사용 FileReader

Scanner클래스를 사용하여 루프없이 전체 파일을 읽습니다.

사용 `BufferedReader`

사용 `Scanner`

사용 `FileReader`

`Scanner`클래스를 사용하여 루프없이 전체 파일을 읽습니다.