Java'da düz metin dosyası okuma


933

Java'daki dosyaların verilerini okumak ve yazmak için farklı yollar var gibi görünüyor.

ASCII verilerini bir dosyadan okumak istiyorum. Olası yollar ve farklılıkları nelerdir?


24
Ben de kapanışa "yapıcı değil" diye katılmıyorum. Neyse ki, bu kopya olarak kapatılabilir . İyi yanıtlar, örneğin Bir dosyanın içeriğinden nasıl bir String oluşturulur? , Dize içine bir dosya okumak için en basit yolu nedir? , Dosyaları okumak için en basit sınıflar nelerdir?
Jonik

Döngüsüz: {{{Tarayıcı sc = yeni Tarayıcı (dosya, "UTF-8"); sc.useDelimiter ( "$ ^"); // hiçbir şeyle eşleşen normal ifade String text = sc.next (); ) (sc.close; }}}
Aivar

3
o kadar ilginç ki, tüm dosyayı bir dizeye okumak için
pitonda

2
Bunu yapmanın en basit yolu: mkyong.com/java/…
dellasavia

Yanıtlar:


567

ASCII bir METİN dosyasıdır, bu nedenle Readersokumak için kullanırsınız . Java ayrıca kullanarak bir ikili dosyadan okuma destekler InputStreams. Okunmakta olan dosyalar çok büyükse, okuma performansını artırmak için a'nın BufferedReaderüstünde kullanmak istersiniz FileReader.

Üzerinden gidin bu makalede bir nasıl kullanılacağına ilişkinReader

Ayrıca, Thinking In Java adlı bu harika (henüz ücretsiz) kitabı indirip okumanızı da tavsiye ederim.

Java 7'de :

new String(Files.readAllBytes(...))

(dokümanlar) veya

Files.readAllLines(...)

(Dokümanlar)

Java 8'de :

Files.lines(..).forEach(...)

(Dokümanlar)


14
Bir Reader seçmek, dosyanın içeriğine ne gerek duyduğunuza bağlıdır. Dosya küçükse (ish) ve hepsine ihtiyacınız varsa, sadece bir FileReader kullanmak ve her şeyi okumak (veya en azından yeterince büyük parçalar) okumak daha hızlıdır (bizim tarafımızdan karşılaştırmalı: 1.8-2x). Satır satır satır işliyorsanız, BufferedReader'a gidin.
Vlad

3
"Files.lines (..). ForEach (...)" kullanılırken satır sırası korunur mu? Anladığım kadarıyla, emir bu operasyondan sonra keyfi olacak.
Daniil Shevelev

39
Files.lines(…).forEach(…)satır sırasını korumaz ancak paralel olarak yürütülür, @Dash. Sipariş önemliyse, Files.lines(…).forEachOrdered(…)siparişi korumalı (yine de doğrulamadı) kullanabilirsiniz.
Palec

2
@Palec bu ilginç, ancak Files.lines(...).forEach(...)paralel yürütüldüğünü söylediği dokümanlardan alıntı yapabilir misiniz ? Ben sadece akışı kullanarak açıkça paralel yapmak sadece böyle olduğunu düşündüm Files.lines(...).parallel().forEach(...).
Klitos Kyriacou

3
Orijinal formülasyonum kurşun geçirmez değil, @KlitosKyriacou. Mesele şu ki forEach, herhangi bir düzeni garanti etmiyor ve nedeni kolay paralelleştirme. Sipariş korunacaksa kullanın forEachOrdered.
Palec

687

Küçük bir dosyayı okumak için benim en sevdiğim yolu bir BufferedReader ve bir StringBuilder kullanmaktır. Çok basit ve noktaya (özellikle etkili olmasa da, çoğu durumda yeterince iyi olsa da):

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();
}

Bazıları, Java 7'den sonra kaynaklarla deneme (yani otomatik kapanma) özelliklerini kullanmanız gerektiğini belirtti :

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();
}

Böyle dizeleri okuduğumda, genellikle her satır için bazı dize işleme yapmak istiyorum, bu yüzden sonra bu uygulama için gidin.

Aslında bir dosyayı bir String'e okumak istesem de , her zaman sınıf IOUtils.toString () yöntemiyle Apache Commons IO kullanıyorum . Buradaki kaynağa bir göz atabilirsiniz:

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 ile daha da basit:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}

6
Son satıra ulaşılırsa yeni satır eklemeyi durdurmak için küçük bir ayar yaptım (\ n). code while (line! = null) {sb.append (line); line = br.readLine (); // Yalnızca curline son satır DEĞİL olduğunda yeni satır ekleyin .. if (line! = Null) {sb.append ("\ n"); }}code
Ramon Fincken

2
Apache Common IO IOUtils # toString (), Sun / Oracle JRE'lerde bulunan sun.misc.IOUtils # readFully () işlevine benzer.
gb96

3
Performans için her zaman sb.append ("\ n") yerine sb.append ('\ n') öğesini çağırın, StringBuilder
öğesine

2
FileReader FileNotFoundException ve BufferedRead IOException oluşturabilir, böylece onları yakalamanız gerekir.
Kamaci

4
okuyucuları doğrudan kullanmaya ve ayrıca ioutil kullanımına gerek yoktur. java7, tüm dosyayı / tüm satırları okumak için yerleşik yöntemlere sahiptir: Bkz. docs.oracle.com/javase/7/docs/api/java/nio/file/… ve docs.oracle.com/javase/7/docs/api / java / nio / file /…
kritzikratzi

142

En kolay yol, Scannersınıfı Java ve FileReader nesnesinde kullanmaktır. Basit bir örnek:

Scanner in = new Scanner(new FileReader("filename.txt"));

Scanner dizelerde, sayılarda vb. okumak için çeşitli yöntemler vardır ... Bununla ilgili daha fazla bilgiyi Java belgeleri sayfasında bulabilirsiniz.

Örneğin, içeriğin tamamını aşağıdakiler halinde okumak String:

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

Ayrıca, belirli bir kodlamaya ihtiyacınız varsa bunu aşağıdakiler yerine kullanabilirsiniz FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)

28
while (in.hasNext ()) {System.out.println (in.next ()); }
Gene Bo

16
@Hissain Ama kullanımı çok daha kolayBufferedReader
Jesus Ramos

3
Catch
Rahal Kanishka

@JesusRamos Pek değil, neden böyle düşünüyorsun? Bununla ilgili daha kolay olan while ((line = br.readLine()) != null) { sb.append(line); }nedir?
user207421

83

İşte basit bir çözüm:

String content;

content = new String(Files.readAllBytes(Paths.get("sample.txt")));

2
@Nery Jr, zarif ve basit
Mahmoud Saleh

1
En iyi ve en basit.
Dary

57

Harici kütüphaneleri kullanmadan yapmanın başka bir yolu:

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;
}

10
veya "try-with-resources" komutunu kullanın try (FileReader reader = new FileReader (file))
Hernán Eche

3
File.length () 'i fark ettim, bu utf-16 dosyalarıyla ne kadar iyi çalışıyor?
Wayne

5
Bu teknik, read () öğesinin arabelleği doldurduğunu varsayar; karakter sayısının bayt sayısına eşit olması; bayt sayısının hafızaya sığması; ve bayt sayısının bir tamsayıya uyması. -1
user207421

1
@HermesTrismegistus Yanlış olmasının dört sebebini verdim. StefanReich benimle aynı fikirde.
user207421

34

Farklı yolları karşılaştırmak zorunda kaldım. Bulgularım hakkında yorum yapmalıyım, ancak kısaca, en hızlı yol FileInputStream üzerinde düz bir BufferedInputStream kullanmaktır. Çok sayıda dosyanın okunması gerekiyorsa, üç iş parçacığı toplam yürütme süresini kabaca yarıya indirir, ancak daha fazla iş parçacığı eklemek, yirmi iş parçacığının tamamlanması yalnızca bir iş parçacığından üç kat daha uzun sürene kadar performansı aşamalı olarak düşürür.

Varsayım, bir dosyayı okumalı ve içeriği ile anlamlı bir şey yapmalısınız. Buradaki örneklerde, bir günlükten satır okuma ve belirli bir eşiği aşan değerler içeren satırları sayma yer almaktadır. Bu yüzden tek katmanlı Java 8'in Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))bir seçenek olmadığını varsayıyorum .

Java 1.8, Windows 7 ve hem SSD hem de HDD sürücülerini test ettim.

Altı farklı uygulama yazdım:

rawParse : BufferedInputStream öğesini bir FileInputStream üzerinde kullanın ve ardından bayt bayt bayt okuyarak satırları kesin. Bu, diğer tek iş parçacıklı yaklaşımlardan daha iyi performans gösterdi, ancak ASCII olmayan dosyalar için çok rahatsız edici olabilir.

lineReaderParse : Bir FileReader üzerinde BufferedReader kullanın, satır satır okuyun, String.split () öğesini çağırarak satırları bölün. Bu, rawParse'den yaklaşık% 20 daha yavaştır.

lineReaderParseParallel : Bu, lineReaderParse ile aynıdır, ancak birkaç iş parçacığı kullanır. Bu, tüm durumlarda genel olarak en hızlı seçenektir.

nioFilesParse : java.nio.files.Files.lines () öğesini kullanın

nioAsyncParse : Bir tamamlayıcı işleyici ve bir iş parçacığı havuzuyla AsynchronousFileChannel kullanın.

nioMemoryMappedParse : Bellek eşlemeli bir dosya kullanın. Bu, diğer uygulamalardan en az üç kat daha fazla yürütme süresi sağlayan gerçekten kötü bir fikirdir.

Bunlar, dört çekirdekli i7 ve SSD sürücüsünde her biri 4 MB olan 204 dosyayı okumak için ortalama sürelerdir. Disk önbelleğe alınmasını önlemek için dosyalar anında oluşturulur.

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

Bir SSD veya bir HDD sürücüsünde çalışan SSD ile yaklaşık% 15 daha hızlı olma arasında beklenenden daha küçük bir fark buldum. Bunun nedeni, dosyaların parçalanmamış bir HDD'de üretilmeleri ve sıralı olarak okunmaları olabilir, bu nedenle dönen sürücü neredeyse bir SSD gibi çalışabilir.

NioAsyncParse uygulamasının düşük performansı beni şaşırttı. Ya yanlış bir şey uyguladım ya da NIO kullanarak çok iş parçacıklı uygulama ve bir tamamlama işleyicisi java.io API ile tek iş parçacıklı bir uygulama aynı (veya daha kötü) gerçekleştirir. Ayrıca, bir CompletionHandler ile eşzamansız ayrıştırma kod satırlarında çok daha uzundur ve doğru şekilde uygulanması eski akışlarda düz bir uygulamadan daha zordur.

Şimdi altı uygulamayı, hepsini içeren bir sınıf ve dosya sayısı, dosya boyutu ve eşzamanlılık derecesi ile oynatmaya izin veren parametrelenebilir bir main () yöntemi izledi. Dosyaların boyutunun artı eksi% 20 olduğunu unutmayın. Bu, tüm dosyaların tam olarak aynı boyutta olması nedeniyle herhangi bir etkiyi önlemek içindir.

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) {
        }
};

TÜM DAVALARIN TAM ÇALIŞABİLİR UYGULAMASI

https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java


24

İşte üç çalışma ve test edilmiş yöntem:

kullanma 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);
        }
    }
}

kullanma 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());
        }
    }
}

kullanma 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);
        }
    }
}

ScannerSınıfı kullanarak tüm dosyayı döngü olmadan okuma

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());
    }
}

1
Projenin içinde klasörler varsa yol nasıl verilir?
17'de Kavipriya

2
Ne olmuş java.nio.file.Files? Biz şimdi sadece kullanabilir readAllLines, readAllBytesve lines.
Claude Martin

21

İçindeki yöntemler org.apache.commons.io.FileUtilsde çok kullanışlı olabilir, örneğin:

/**
 * 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)

Veya Guava'yı (daha modern, aktif olarak tutulan bir kütüphane) tercih ederseniz , Files sınıfında benzer yardımcı programlara sahiptir . Bu cevapta basit örnekler .
Jonik

1
ya da tüm satırları almak için yerleşik yöntemi kullanabilirsiniz: docs.oracle.com/javase/7/docs/api/java/nio/file/…
kritzikratzi

Apache ortaklarındaki bağlantı ölü gibi görünüyor.
Şubat

17

Metinle ne yapmak istiyorsunuz? Dosya belleğe sığacak kadar küçük mü? İhtiyaçlarınız için dosyayı işlemenin en basit yolunu bulmaya çalışacağım. FileUtils kütüphanesi bunun için çok uygundur.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);


@PeterLawrey muhtemelen anlamına gelir org.apache.commons.io.FileUtils. Google bağlantısı, en yaygın anlam değiştikçe içeriği zaman içinde değiştirebilir, ancak bu, sorgusuyla eşleşir ve doğru görünür.
Palec

2
Ne yazık ki, günümüzde hayır readLines(String)ve readLines(File)lehine itiraz var readLines(File, Charset). Kodlama bir dize olarak da sağlanabilir.
Palec


12

Java'da bir dosyayı okumak için 15 yolu belgeledim ve daha sonra çeşitli dosya boyutlarında hız için test ettim - 1 KB'den 1 GB'a kadar ve işte bunu yapmanın en iyi üç yolu:

  1. java.nio.file.Files.readAllBytes()

    Java 7, 8 ve 9'da çalıştığı test edilmiştir.

    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);
        }
      }
    }
  2. java.io.BufferedReader.readLine()

    Java 7, 8, 9'da çalıştığı test edilmiştir.

    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);
          }
        }
      }
    }
  3. java.nio.file.Files.lines()

    Bu, Java 8 ve 9'da çalıştığı test edildi, ancak lambda ifade gereksinimi nedeniyle Java 7'de çalışmaz.

    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);
          });
        }
      }
    }

9

Aşağıda bunu Java 8 yolunda yapmanın bir astarı var. text.txtDosyanın Eclipse'in proje dizininin kökünde olduğunu varsayarsak .

Files.lines(Paths.get("text.txt")).collect(Collectors.toList());

7

BufferedReader'ı kullanma:

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();
}

7

Bu, FileReader yerine File ( Dosya İçeriği) ve dosyanın içeriğine adım atma tekrarı dışında, Jesus Ramos'un cevabı ile tamamen aynıdır .

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

... atar FileNotFoundException


3
FileReader ile FileReader: FileReader ile dosya mevcut olmalı ve işletim sistemi izinleri erişime izin vermelidir. Dosya ile bu izinleri test etmek veya dosyanın bir dizin olup olmadığını kontrol etmek mümkündür. Dosyanın yararlı işlevleri vardır: isFile (), isDirectory (), listFiles (), canExecute (), canRead (), canWrite (), exist (), mkdir (), delete (). File.createTempFile (), sistem varsayılan geçici dizinine yazar. Bu yöntem FileOutputStream nesnelerini vb. Açmak için kullanılabilecek bir dosya nesnesi döndürür. Kaynak
ThisClark

7

Arabelleğe alınan akış sınıfları uygulamada çok daha performanslıdır, öyle ki NIO.2 API'sı, kısmen uygulamanızda her zaman tamponlu akışları kullanmaya teşvik etmek için bu akış sınıflarını özel olarak döndüren yöntemler içerir.

İşte bir örnek:

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...
}

Bu kodu değiştirebilirsiniz

BufferedReader reader = Files.newBufferedReader(path);

ile

BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));

Java NIO ve IO'nun ana kullanımlarını öğrenmek için bu makaleyi öneririm .


6

Muhtemelen tamponlu I / O kadar hızlı değil, ama oldukça kısa:

    String content;
    try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
        content = scanner.next();
    }

\ZDesen söyler Scannersınırlayıcı EOF olduğunu.


1
Çok ilgili, zaten var olan bir cevap Jesus Ramos tarafından veriliyor.
Palec

1
Doğru, olmalı: if(scanner.hasNext()) content = scanner.next();
David Soroko

1
Bu, Android 4.4'te benim için başarısız oluyor. Sadece 1024 bayt okunur. YMMV.
Roger Keays


3

Java'da bir dosyadan veri okumanın en basit yolu , dosyayı okumak için File sınıfını ve dosyanın içeriğini okumak için Scanner sınıfını kullanmaktır.

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();
        }
    }
}

Not: java.util dosyasını içe aktarmayı unutmayın. *; Tarayıcı'nın çalışması için.


2

Guava bunun için bir astar sağlar:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

String contents = Files.toString(filePath, Charsets.UTF_8);

2

Bu sorunun tam cevabı olmayabilir. Bu, Java kodunuzda dosyanızın yolunu açıkça belirtmediğiniz ve bunun yerine komut satırı argümanı olarak okuduğunuz bir dosyayı okumanın başka bir yoludur.

Aşağıdaki kodla,

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);
        }
    }
}

sadece devam et ve şununla çalıştır:

java InputReader < input.txt

Bu, içeriğini okur ve input.txtkonsolunuza yazdırır.

Ayrıca System.out.println()komut satırından belirli bir dosyaya aşağıdaki şekilde yazabilirsiniz:

java InputReader < input.txt > output.txt

Bu okuma input.txtve yazma output.txt.


2

joinTüm dosya içeriğini tek bir satıra almak için readAllLines ve yöntemini kullanabilirsiniz:

String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));

ASCII verilerini doğru okuyan varsayılan olarak UTF-8 kodlamasını kullanır.

Ayrıca readAllBytes kullanabilirsiniz:

String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);

Bence readAllBytes daha hızlı ve daha kesin, çünkü yeni satırın yerini almıyor \nve yeni satır da olabilir \r\n. Hangisinin uygun olduğu ihtiyaçlarınıza bağlıdır.


1

JSF tabanlı Maven web uygulamaları için, Resourcesistediğiniz herhangi bir dosyada okumak için ClassLoader ve klasörü kullanın:

  1. Okumak istediğiniz herhangi bir dosyayı Kaynaklar klasörüne koyun.
  2. Apache Commons IO bağımlılığını POM'nize koyun:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
  3. Okumak için aşağıdaki kodu kullanın (örneğin aşağıdaki .json dosyasında okuyor):

    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;

Metin dosyaları, .properties dosyaları, XSD şemaları vb. İçin de aynısını yapabilirsiniz .


Bunu 'istediğiniz herhangi bir dosyada' kullanamazsınız. Yalnızca JAR veya WAR dosyasına paketlenmiş kaynaklar için kullanabilirsiniz.
user207421


0

Yapının sadeliği ile ilgili ise Java öpücüğünü kullanın :

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}

0
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 kullanın.


0
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();
}

0

En sezgisel yöntem Java 11'de tanıtıldı 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'nin bu lüksü onlarca yıl önce var! ☺


-3

Programladığım bu kod çok büyük dosyalar için çok daha hızlı:

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;
}

10
Bir StringBuilder yerine basit dize birleştirme kullanırsanız, çok daha hızlı, şüpheliyim ...
PhiLho 28:13

6
Ana hız kazancının 1MB (1024 * 1024) bloklar halinde okunmasından kaynaklandığını düşünüyorum. Ancak aynı şeyi BufferedReader yapıcısına ikinci argüman olarak 1024 * 1024 ileterek yapabilirsiniz.
gb96

3
bunun hiç test edildiğine inanmıyorum. +=bu şekilde kullanılması size doğrusal karmaşıklık gerektiren bir görev için karesel (!) karmaşıklık verir. bu birkaç mb üzerindeki dosyalar için taramaya başlayacaktır. bunun üstesinden gelmek için ya metin bloklarını <string> listesinde tutmalı ya da yukarıda belirtilen stringbuilder'ı kullanmalısın.
kritzikratzi

5
Ne daha hızlı? Kesinlikle bir StringBuffer eklemek daha hızlı değildir . -1
user207421

1
@ gb96 Tampon boyutları hakkında aynı şeyi düşündüm, ancak bu sorudaki ayrıntılı deney benzer bir bağlamda şaşırtıcı sonuçlar verdi: 16KB'lik bir tampon sürekli ve belirgin şekilde daha hızlıydı.
chiastic-security

-3
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.

Yukarıdaki satır kümesi 1 tek satıra şöyle yazılabilir:

BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional

Dize oluşturucuya ekleme (Dosya çok büyükse, dize oluşturucunun kullanılması önerilir, normal String nesnesini kullanın)

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();
    }
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.