java - जावा का उपयोग करके लाइन द्वारा बड़ी टेक्स्ट फ़ाइल लाइन को कैसे पढ़ा जाए?




performance file-io (14)

मुझे जावा का उपयोग करके लाइन द्वारा लगभग 5-6 जीबी लाइन की एक बड़ी टेक्स्ट फ़ाइल पढ़ने की जरूरत है।

मैं इसे जल्दी कैसे कर सकता हूं?


जावा-9:

try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
        stream.forEach(System.out::println);
}

FileReader आपको एन्कोडिंग निर्दिष्ट करने नहीं देगा, अगर आपको इसे निर्दिष्ट करने की आवश्यकता है तो इसके बजाय InputStreamReader उपयोग करें:

try {
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "Cp1252"));         

    String line;
    while ((line = br.readLine()) != null) {
        // process the line.
    }
    br.close();

} catch (IOException e) {
    e.printStackTrace();
}

यदि आपने Windows से यह फ़ाइल आयात की है, तो इसमें एएनएसआई एन्कोडिंग (सीपी 1252) हो सकती है, इसलिए आपको एन्कोडिंग निर्दिष्ट करना होगा।


आप इस कोड का उपयोग कर सकते हैं:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadTextFile {

    public static void main(String[] args) throws IOException {

        try {

            File f = new File("src/com/data.txt");

            BufferedReader b = new BufferedReader(new FileReader(f));

            String readLine = "";

            System.out.println("Reading file using Buffered Reader");

            while ((readLine = b.readLine()) != null) {
                System.out.println(readLine);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

आप इसे अधिक सटीक करने के लिए धाराओं का उपयोग कर सकते हैं:

Files.lines(Paths.get("input.txt")).forEach(s -> stringBuffer.append(s);

आप स्कैनर कक्षा का उपयोग कर सकते हैं

Scanner sc=new Scanner(file);
sc.nextLine();

आपको class BufferedReader में readLine() विधि का उपयोग करने की आवश्यकता है। उस वर्ग से एक नई वस्तु बनाएं और इस विधि को उसके ऊपर संचालित करें और इसे एक स्ट्रिंग में सहेजें।

बफररडर जैवडोक


इसे प्राप्त करने का स्पष्ट तरीका,

उदाहरण के लिए:

यदि आपके पास अपनी वर्तमान निर्देशिका पर dataFile.txt

import java.io.*;
import java.util.Scanner;
import java.io.FileNotFoundException;

public class readByLine
{
    public readByLine() throws FileNotFoundException
    {
        Scanner linReader = new Scanner(new File("dataFile.txt"));

        while (linReader.hasNext())
        {
            String line = linReader.nextLine();
            System.out.println(line);
        }
        linReader.close();

    }

    public static void main(String args[])  throws FileNotFoundException
    {
        new readByLine();
    }
}

नीचे जैसा उत्पादन,


उपयोग करने के लिए एक आम पैटर्न है

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
    String line;
    while ((line = br.readLine()) != null) {
       // process the line.
    }
}

यदि आप मानते हैं कि कोई वर्ण एन्कोडिंग नहीं है तो आप डेटा को तेज़ी से पढ़ सकते हैं। उदाहरण के लिए ASCII-7 लेकिन इससे कोई फर्क नहीं पड़ता है। यह अत्यधिक संभावना है कि डेटा के साथ आप जो भी करेंगे, वह अधिक समय लेगा।

संपादित करें: उपयोग करने के लिए एक कम आम पैटर्न जो line लीकिंग के दायरे से बचाता है।

try(BufferedReader br = new BufferedReader(new FileReader(file))) {
    for(String line; (line = br.readLine()) != null; ) {
        // process the line.
    }
    // line is not visible here.
}

अद्यतन: जावा 8 में आप कर सकते हैं

try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
        stream.forEach(System.out::println);
}

नोट: आपको स्ट्रीम को एक कोशिश-संसाधन-संसाधन ब्लॉक में रखना होगा ताकि यह सुनिश्चित किया जा सके कि # क्लोज़ विधि पर कॉल किया गया है, अन्यथा अंतर्निहित फ़ाइल हैंडल कभी भी बंद नहीं होता है जब तक कि जीसी इसे बाद में नहीं करता है।


जावा 7 में:

String folderPath = "C:/folderOfMyFile";
Path path = Paths.get(folderPath, "myFileName.csv"); //or any text file eg.: txt, bat, etc
Charset charset = Charset.forName("UTF-8");

try (BufferedReader reader = Files.newBufferedReader(path , charset)) {
  while ((line = reader.readLine()) != null ) {
    //separate all csv fields into string array
    String[] lineVariables = line.split(","); 
  }
} catch (IOException e) {
    System.err.println(e);
}

जावा 8 के साथ फ़ाइल पढ़ने के लिए

  package com.java.java8;

    import java.nio.file.Files;
    import java.nio.file.Paths;
    import java.util.stream.Stream;

    /**
     * The Class ReadLargeFile.
     *
     * @author Ankit Sood Apr 20, 2017
     */
    public class ReadLargeFile {

        /**
         * The main method.
         *
         * @param args
         *            the arguments
         */
        public static void main(String[] args) {
        try {
            Stream<String> stream = Files.lines(Paths.get("C:\\Users\\System\\Desktop\\demoData.txt"));
            stream.forEach(System.out::println);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
    }

जावा 8 में, आप कर सकते हैं:

try (Stream<String> lines = Files.lines (file, StandardCharsets.UTF_8))
{
    for (String line : (Iterable<String>) lines::iterator)
    {
        ;
    }
}

कुछ नोट्स: Files.lines (अधिकांश धाराओं के विपरीत) द्वारा लौटाई गई स्ट्रीम को बंद करने की आवश्यकता है। यहां उल्लिखित कारणों से मैं forEach() लिए उपयोग करने से forEach() हूं। अजीब कोड (Iterable<String>) lines::iterator एक स्ट्रीम को एक इटरटेबल पर रखता है।


मैं आमतौर पर पढ़ने के दिन सीधे पढ़ता हूं:

void readResource(InputStream source) throws IOException {
    BufferedReader stream = null;
    try {
        stream = new BufferedReader(new InputStreamReader(source));
        while (true) {
            String line = stream.readLine();
            if(line == null) {
                break;
            }
            //process line
            System.out.println(line)
        }
    } finally {
        closeQuiet(stream);
    }
}

static void closeQuiet(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (IOException ignore) {
        }
    }
}

यहां प्री-जावा 7 के लिए पूर्ण त्रुटि हैंडलिंग और समर्थन वर्णसेट विनिर्देश वाला एक नमूना है। जावा 7 के साथ आप कोशिश-के-संसाधन सिंटैक्स का उपयोग कर सकते हैं, जो कोड क्लीनर बनाता है।

यदि आप केवल डिफ़ॉल्ट वर्णमाला चाहते हैं तो आप इनपुटस्ट्रीम को छोड़ सकते हैं और FileReader का उपयोग कर सकते हैं।

InputStream ins = null; // raw byte-stream
Reader r = null; // cooked reader
BufferedReader br = null; // buffered for readLine()
try {
    String s;
    ins = new FileInputStream("textfile.txt");
    r = new InputStreamReader(ins, "UTF-8"); // leave charset out for default
    br = new BufferedReader(r);
    while ((s = br.readLine()) != null) {
        System.out.println(s);
    }
}
catch (Exception e)
{
    System.err.println(e.getMessage()); // handle exception
}
finally {
    if (br != null) { try { br.close(); } catch(Throwable t) { /* ensure close happens */ } }
    if (r != null) { try { r.close(); } catch(Throwable t) { /* ensure close happens */ } }
    if (ins != null) { try { ins.close(); } catch(Throwable t) { /* ensure close happens */ } }
}

पूर्ण त्रुटि प्रबंधन के साथ ग्रोवी संस्करण यहां दिया गया है:

File f = new File("textfile.txt");
f.withReader("UTF-8") { br ->
    br.eachLine { line ->
        println line;
    }
}

BufferedReader br;
FileInputStream fin;
try {
    fin = new FileInputStream(fileName);
    br = new BufferedReader(new InputStreamReader(fin));

    /*Path pathToFile = Paths.get(fileName);
    br = Files.newBufferedReader(pathToFile,StandardCharsets.US_ASCII);*/

    String line = br.readLine();
    while (line != null) {
        String[] attributes = line.split(",");
        Movie movie = createMovie(attributes);
        movies.add(movie);
        line = br.readLine();
    }
    fin.close();
    br.close();
} catch (FileNotFoundException e) {
    System.out.println("Your Message");
} catch (IOException e) {
    System.out.println("Your Message");
}

इससे मेरा काम बनता है। उम्मीद है कि यह आपकी भी मदद करेगा।





garbage-collection