मैं जावा का उपयोग करके एक बड़ी पाठ फ़ाइल लाइन को कैसे पढ़ सकता हूं?

Question

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

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

Comments

@kamaci एट। अल। इस प्रश्न को डुप्लिकेट के रूप में चिह्नित नहीं किया जाना चाहिए। "क्विकली लास्ट लाइन" एक वैकल्पिक विकल्प नहीं है, और इसका डिबेटेबल है कि क्या "लाइन द्वारा टेक्स्ट-फाइल लाइन पढ़ने का सबसे तेज तरीका" है। कुछ करने का सबसे तेज तरीका जरूरी नहीं कि सामान्य तरीका ही हो। इसके अलावा, नीचे दिए गए जवाबों में कोड शामिल है, सबसे प्रासंगिक विकल्प जो आप सूचीबद्ध करते हैं। यह प्रश्न उपयोगी है। यह वर्तमान में "java read file line by line" के लिए शीर्ष Google खोज परिणाम है। अंत में, स्टैक ओवरफ्लो पर पहुंचने के लिए इसका ऑफ डाल दिया गया और पाया कि हर 2 में से 1 प्रश्न को निपटान के लिए चिह्नित किया गया है।

— पैट्रिक कुलेन

यहां छह संभावित कार्यान्वयन के लिए गति की तुलना है।

— सर्ग एम टेन

घटना हालांकि मैं यह पढ़ते हुए टिप्पणी कर रहा हूं कि एसओ की करीबी नीति बेकार है, इसलिए एसओ इसमें बना रहा। यह हर तरह से अतिरेक से बचना चाहता है, ऐसा संकीर्ण दिमाग वाला डेवलपर परिप्रेक्ष्य है! बस रहने दो! क्रीम ऊपर की ओर उठेगी और श * टी नीचे से बिल्कुल ठीक हो जाएगी। भले ही एक प्रश्न पहले पूछा गया हो (कौन सा सवाल नहीं है?), इसका मतलब यह नहीं है कि एक नया प्रश्न इसे बेहतर वाक्यांश नहीं दे सकता है, बेहतर उत्तर प्राप्त कर सकता है, खोज इंजनों में उच्च रैंक कर सकता है आदि दिलचस्प बात यह है कि यह प्रश्न अब 'संरक्षित' है ....

— स्टिजन डे विट

यह अविश्वसनीय है कि केवल शीर्षक पढ़कर कैसे प्रश्न डुप्लिकेट के रूप में चिह्नित हो जाते हैं।

— ल्यूक

Answer 1

एक सामान्य पैटर्न का उपयोग करना है

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

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

EDIT: एक कम सामान्य पैटर्न का उपयोग करने के लिए जो 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);
}

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

Comments

यह पैटर्न उचित अपवाद हैंडलिंग के साथ कैसा दिखता है? मैंने ध्यान दिया कि br.close () IOException को फेंकता है, जो आश्चर्यचकित करता है - किसी फ़ाइल को पढ़ने के लिए खोले जाने पर क्या हो सकता है, वैसे भी? FileReader के निर्माता एक FileNotFound अपवाद फेंक सकते हैं।

— माइक बी

अगर मेरे पास 200MB की फ़ाइल है और यह 90MB / s पर पढ़ सकता है, तो मुझे उम्मीद है कि यह ~ 3 s लेगा? मेरा मिनट लगता है, पढ़ने के इस "धीमे" तरीके से। मैं एक एसएसडी पर हूं इसलिए पढ़ने की गति एक समस्या नहीं होनी चाहिए?

— Jiew मेंग

@JiewMeng SO मुझे संदेह है कि आप जो कुछ कर रहे हैं वह समय ले रहा है। क्या आप फ़ाइल की लाइनों को पढ़ने की कोशिश कर सकते हैं और कुछ नहीं।

— पीटर लॉरी

for(String line = br.readLine(); line != null; line = br.readLine())Btw क्यों नहीं , जावा 8 में आप वह कर सकते हैं try( Stream<String> lines = Files.lines(...) ){ for( String line : (Iterable<String>) lines::iterator ) { ... } }जो नफरत नहीं करना मुश्किल है।

— अलेक्सांद्र डबिन्सकी

@AleksandrDubinsky मुझे जावा 8 में बंद होने की समस्या यह है कि यह बहुत आसानी से कोड को पढ़ने के लिए और अधिक जटिल बना देता है (साथ ही धीमा होने के कारण) मैं बहुत सारे डेवलपर्स को इसे अति प्रयोग करते हुए देख सकता हूं क्योंकि यह "शांत" है।

— पीटर लॉरी

Answer 2

इस ब्लॉग को देखें:

• जावा लाइन द्वारा फाइल लाइन पढ़ें - जावा ट्यूटोरियल

बफर आकार निर्दिष्ट किया जा सकता है, या डिफ़ॉल्ट आकार का उपयोग किया जा सकता है। अधिकांश उद्देश्यों के लिए डिफ़ॉल्ट काफी बड़ा है।

// Open the file
FileInputStream fstream = new FileInputStream("textfile.txt");
BufferedReader br = new BufferedReader(new InputStreamReader(fstream));

String strLine;

//Read File Line By Line
while ((strLine = br.readLine()) != null)   {
  // Print the content on the console
  System.out.println (strLine);
}

//Close the input stream
fstream.close();

Comments

मेरी फ़ाइल 1.5 गिग है और आपके उत्तर का उपयोग करके फ़ाइल को पढ़ना संभव नहीं है!

— अबोजार राजाबी

@AboozarRajabi निश्चित रूप से यह संभव है। यह कोड किसी भी टेक्स्ट फ़ाइल को पढ़ सकता है।

— user207421

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

— user207421

मैं टिप्पणियों को खोदूंगा, आपके पास कोड की 6 पंक्तियों के लिए 100% निरर्थक टिप्पणियों की 4 पंक्तियाँ हैं।

— भैंस

Answer 3

एक बार जावा 8 बाहर हो जाने के बाद (मार्च 2014) आप धाराओं का उपयोग कर पाएंगे:

try (Stream<String> lines = Files.lines(Paths.get(filename), Charset.defaultCharset())) {
  lines.forEachOrdered(line -> process(line));
}

फ़ाइल की सभी पंक्तियों को प्रिंट करना:

try (Stream<String> lines = Files.lines(file, Charset.defaultCharset())) {
  lines.forEachOrdered(System.out::println);
}

Comments

उपयोग करें StandardCharsets.UTF_8, Stream<String>संक्षिप्तता के लिए उपयोग करें , और उपयोग करने से बचें forEach()और खासकर forEachOrdered()जब तक कि कोई कारण न हो।

— अलेक्सांद्र डबिन्सकी

फॉरएच () से क्यों बचें? क्या यह खराब है?

— स्टीवर्टबल

अगर हम forEachOrdered के बजाय हमें छोड़ देते हैं, तो लाइनें ऑर्डर से प्रिंट हो सकती हैं, क्या वे नहीं हैं?

— msayag

@steventrouble इस पर एक नज़र डालें: stackoverflow.com/questions/16635398/… यह बुरा नहीं है यदि आप एक छोटे फ़ंक्शन संदर्भ को पास करते हैं forEach(this::process), लेकिन यह बदसूरत हो जाता है अगर आप कोड के ब्लॉक को लैम्ब्डा के रूप में लिखते हैं forEach()।

— १४:४४ पर अलेक्सांद्र डबलिनस्की '

@msayag, आप सही हैं, आपको forEachOrderedइन-ऑर्डर निष्पादित करने के लिए आवश्यक है। ध्यान रखें कि आप उस स्थिति में धारा को समानांतर करने में सक्षम नहीं होंगे, हालांकि मैंने पाया है कि जब तक फ़ाइल में हजारों लाइनें न हों, तब तक समानांतरकरण चालू नहीं होता है।

— १३:०१ पर अलेक्जेंडर डबलिनस्की Aleksandr

Answer 4

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

यदि आप केवल डिफ़ॉल्ट चारसेट चाहते हैं तो आप InputStream को छोड़ सकते हैं और 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;
    }
}

Comments

क्या एक है ByteArrayInputStreamएक स्ट्रिंग द्वारा खिलाया एक बड़े पाठ फ़ाइल को पढ़ने के साथ क्या करना है शाब्दिक?

— user207421

बिल्कुल बेकार है। हर धारा को बंद करने का शून्य कारण है। यदि आप उनमें से किसी भी स्ट्रीम को बंद कर देते हैं, तो आप स्वचालित रूप से अन्य सभी स्ट्रीम बंद कर देते हैं ...

— Enerccio

Answer 5

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

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

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

Comments

Iterableइस कोड को लागू नहीं करने से निश्चित रूप से उपयोगी हालांकि बदसूरत है। इसे काम करने के लिए एक कास्ट (यानी (Iterable<String>)) की जरूरत है ।

— Stephan

मैं इस विधि के साथ पहली पंक्ति को कैसे छोड़ सकता हूं?

— क्यू

@qedfor(String line : (Iterable<String>) lines.skip(1)::iterator)

— अलेक्सांद्र

यदि आप वास्तव में Streamसुविधाओं का उपयोग Files.newBufferedReaderकरने का इरादा नहीं कर रहे हैं , तो इसके बजाय Files.linesबार-बार कॉल करने का उपयोग करें readLine()जब तक कि nullनिर्माण का उपयोग करने के बजाय (Iterable<String>) lines::iteratorबहुत सरल प्रतीत न हो ...

— Holger

आप क्यों उपयोग करते हैं :: लाइनों में :: पुनरावृत्त? केवल उपयोग के लिए मुझे पता है :: मेमने समारोह में विधि नाम पैकेज करने के लिए है। के बाद लूप पैरामीटर के लिए: चर होना चाहिए जब आप कुछ लैंबडा विधि का उपयोग करते हुए प्राप्त करते हैं ::

— Trismegistos

Answer 6

आप क्या कर सकते हैं स्कैनर का उपयोग करके पूरे पाठ को स्कैन करें और पंक्ति द्वारा पाठ पंक्ति के माध्यम से जाएं। बेशक आपको निम्नलिखित आयात करना चाहिए:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public static void readText throws FileNotFoundException {
    Scanner scan = new Scanner(new File("samplefilename.txt"));
    while(scan.hasNextLine()){
        String line = scan.nextLine();
        //Here you can manipulate the string the way you want
    }
}

स्कैनर मूल रूप से सभी पाठ को स्कैन करता है। जबकि पूरे पाठ को पार करने के लिए लूप का उपयोग किया जाता है।

.hasNextLine()समारोह एक बूलियन यह सच रिटर्न अगर वहाँ पाठ में अभी भी और अधिक लाइनें हैं है। .nextLine()समारोह आप एक स्ट्रिंग है जिसे आप जिस तरह से आप चाहते हैं का उपयोग कर सकते के रूप में एक पूरी लाइन देता है। System.out.println(line)पाठ मुद्रित करने का प्रयास करें।

साइड नोट: .txt फाइल टाइप टेक्स्ट है।

Comments

चाहिए बजाय इस बात का नहीं विधि घोषणा देखो:'public static void readText फेंकता FileNotFoundException () { 'की तरह:'public static void readText () फेंकता FileNotFoundException {'

— Ketcomp

की तुलना में यह काफी धीमी है BufferedReader.readLine(), और उसने सबसे अच्छा प्रदर्शन करने की विधि पूछी।

— user207421

Answer 7

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 से आयात किया है, तो इसमें ANSI एन्कोडिंग (Cp1252) हो सकती है, इसलिए आपको एन्कोडिंग निर्दिष्ट करना होगा।

Answer 8

मैंने जावा में एक फ़ाइल को पढ़ने के लिए 10 अलग-अलग तरीकों का दस्तावेजीकरण और परीक्षण किया और फिर उन्हें 1KB से 1GB तक की परीक्षण फ़ाइलों में पढ़ाकर एक-दूसरे के खिलाफ चलाया। यहां 1GB परीक्षण फ़ाइल पढ़ने के लिए सबसे तेज़ 3 फ़ाइल पढ़ने के तरीके हैं।

ध्यान दें कि प्रदर्शन परीक्षण चलाते समय मैंने कंसोल को कुछ भी आउटपुट नहीं किया था क्योंकि यह वास्तव में परीक्षण को धीमा कर देगा। मैं सिर्फ कच्चे पढ़ने की गति का परीक्षण करना चाहता था।

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

जावा 7, 8, 9 में परीक्षण किया गया। यह कुल मिलाकर सबसे तेज़ तरीका था। 1GB फ़ाइल पढ़ना केवल 1 सेकंड के नीचे लगातार था।

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-1GB.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.nio.file.Files.lines ()

यह जावा 8 और 9 में सफलतापूर्वक परीक्षण किया गया था लेकिन यह लैम्ब्डा अभिव्यक्ति के लिए समर्थन की कमी के कारण जावा 7 में काम नहीं करेगा। 1GB फ़ाइल में पढ़ने में लगभग 3.5 सेकंड का समय लगता है जो इसे बड़ी फ़ाइलों को पढ़ने के बाद दूसरे स्थान पर रखता है।

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-1GB.txt";
    File file = new File(fileName);

    try (Stream linesStream = Files.lines(file.toPath())) {
      linesStream.forEach(line -> {
        System.out.println(line);
      });
    }
  }
}

3) बफ़रडेडर

जावा 7, 8, 9 में काम करने के लिए परीक्षण किया गया। 1GB परीक्षण फ़ाइल में पढ़ने के लिए लगभग 4.5 सेकंड लगते हैं।

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-1GB.txt";
    FileReader fileReader = new FileReader(fileName);

    try (BufferedReader bufferedReader = new BufferedReader(fileReader)) {
      String line;
      while((line = bufferedReader.readLine()) != null) {
        System.out.println(line);
      }
    }
  }

आप यहां सभी 10 फ़ाइल पढ़ने के तरीकों के लिए पूरी रैंकिंग पा सकते हैं ।

Comments

आपका मार्गदर्शक अद्भुत है :)

— फैसल जुलैदन

आप System.out.print/println()यहाँ ज्यादातर समय कर रहे हैं; आप यह भी मान रहे हैं कि फ़ाइल आपके पहले दो मामलों में मेमोरी में फिट हो जाएगी।

— user207421

काफी उचित। शायद मैं अपने जवाब में उन धारणाओं को और स्पष्ट कर सकता था।

— गोमिशा

Answer 9

जावा 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);
}

Comments

जागरूक रहें! यदि किसी फ़ील्ड में अल्पविराम होता है और यह उद्धरणों से घिरा होता है, तो लाइन का उपयोग करके इस तरह से ठीक से पार्स नहीं होगा। इस विभाजन को नजरअंदाज कर दिया जाएगा और सिर्फ आंतरिक अल्पविराम का उपयोग करके क्षेत्र को विखंडू में अलग किया जाएगा। एचटीएच, मार्सेलो।

— Marcelo Finki

CSV: कॉमा सेपरेटेड वैल्यूज़ फ़ाइल, इस प्रकार आप कॉमा का उपयोग सीएसवी फ़ील्ड में नहीं कर सकते, जब तक कि आपका मतलब किसी अन्य फ़ील्ड को जोड़ने का न हो। तो, जावा में कॉमा टोकन के लिए विभाजन का उपयोग करें जब एक सीएसवी फ़ाइल को पार्स करना पूरी तरह से ठीक और सही है

— डिएगो डुआर्टे

डिएगो, यह सही नहीं है। एकमात्र CSV मानक (RFC 4180) विशेष रूप से कहता है "लाइन विराम (CRLF), दोहरे उद्धरण और अल्पविराम वाले फ़ील्ड को दोहरे उद्धरणों में संलग्न किया जाना चाहिए।"

— सर्ग.नेचादेव

StandardCharsets.UTF_8चेक किए गए अपवाद से बचने के लिए उपयोग करेंCharset.forName("UTF-8")

— हांग्जो डबिन्स्की

आपकी टिप्पणी के लिए धन्यवाद "डिएगो डुआर्टे"; मुझे कहना होगा कि मैं "serg.nechaev" उत्तरों से सहमत हूं। मैं सीएसवी फाइलों में एम्बेडेड कॉमा को 'हर समय' देखता हूं। लोगों को उम्मीद है कि यह स्वीकार किया जाएगा। पूरे सम्मान के साथ। "serg.nechaev" के लिए एक बड़ा धन्यवाद। IMHO आप सही हैं। सबको खुश करो।

— मार्सेलो फिंकी

Answer 10

जावा 8 में, उपयोग करने का एक विकल्प भी है Files.lines()। यदि आपका इनपुट स्रोत एक फ़ाइल नहीं है, लेकिन एक Readerया अधिक की तरह कुछ अमूर्त है InputStream, तो आप एस विधि के माध्यम से लाइनों को स्ट्रीम कर सकते हैं ।BufferedReaderlines()

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

try (BufferedReader reader = new BufferedReader(...)) {
  reader.lines().forEach(line -> processLine(line));
}

processLine()द्वारा पढ़ी गई प्रत्येक इनपुट लाइन के लिए कॉल करेगा BufferedReader।

Answer 11

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

Answer 12

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

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

Comments

@ टिम 'बॉम्ब हॉररली' एक शब्द नहीं है जिसे मैं सीएस में पहचानता हूं। वास्तव में आप का अर्थ क्या है?

— user207421

नीचे उतरो, बहुत धीरे-धीरे निष्पादित करें, सबसे अधिक संभावना दुर्घटना। मुझे शायद इस साइट पर मुहावरों से बचना चाहिए;)

— टिम

@ यह ऐसा क्यों करेगा?

— xehpuk

उपयोग करना Scannerठीक है, लेकिन इस उत्तर में इसे ठीक से उपयोग करने के लिए पूर्ण कोड शामिल नहीं है।

— अलेक्सांद्र डबिन्सकी

@ यह कोड न तो 'बम भयावह' होगा और न ही 'दलदल से नीचे' होगा और न ही 'बहुत धीरे-धीरे चलेगा' और न ही 'सबसे संभावित दुर्घटना' होगा। तथ्य के रूप में लिखित रूप में यह केवल एक पंक्ति को पढ़ेगा, लगभग तुरंत। आप मेगाबाइट प्रति सेकंड इस तरह से पढ़ सकते हैं, हालांकि BufferedReader.readLine()निश्चित रूप से उपवास के रूप में कई बार है। अगर आपको लगता है तो कृपया अपने कारण प्रदान करें।

— user207421

Answer 13

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

बफ़रदर जवदॉक

Comments

बफ़ररेडएपीआई की तरह लगता है टूट गया है

— संदीप

Answer 14

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

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

यदि आपके पास 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();
    }
}

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

Comments

यह क्यों साफ है? और यहां पाठ की तस्वीरें पोस्ट न करें। पाठ पोस्ट करें।

— user207421

आपने एक तस्वीर पोस्ट की। यह पाठ की एक तस्वीर है। आप इस पृष्ठ पर सीधे पाठ को काट और चिपका सकते थे। कार्यक्रम पोस्ट करने के बारे में किसी ने कुछ नहीं कहा। पाठ की तस्वीरें पोस्ट करना आपके समय की बर्बादी है, जिसकी मुझे कोई परवाह नहीं है, और ओयूर बैंडविड्थ, जो मैं करता हूं।

— user207421

Answer 15

जावा 9:

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

Comments

मुझे लगता है कि आपके पास हैSystem.getProperty("os.name").equals("Linux")

— स्प्रिंगलैरर

तार के साथ तुलना मत करो ==!

— जोनासकज - मोनिका

यह विहित जावा 8 उदाहरण है, जैसा कि पहले से ही दूसरों द्वारा पोस्ट किया गया है। आप यह क्यों दावा करते हैं कि यह "जावा -9" है?

— होल्गर

@ होल मेमोरी में उन फाइलों को मैप किया जाता है जिनका वह उल्लेख करना भूल गए हों?

— यूजीन

इसे लाइन द्वारा संसाधित करने के लिए आप कोशिश कर सकते हैं (स्ट्रीम <string> stream = files.lines (Paths.get (inputFile))) {stream.forEach ((लाइन) -> {System.out.println (line);}; ); }

— thanos.a

Answer 16

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

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

Answer 17

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

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

Comments

मैं सहमत हूं कि यह वास्तव में ठीक है। Aguess, लोग अजीब StringBuffer पसंद के कारण इसे नापसंद करते हैं (StringBuilder को आमतौर पर पसंद किया जाता है, भले ही यह चर के लिए एक बुरा नाम हो सकता है)। यह भी क्योंकि यह पहले से ही ऊपर उल्लेखित है।

— एंड्री रूबसोव

Answer 18

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

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

Answer 19

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

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

    }

}

Comments

एक स्पष्टीकरण क्रम में होगा।

— पीटर मोर्टेंसन

Answer 20

Org.apache.commons.io पैकेज का उपयोग करके , इसने अधिक प्रदर्शन दिया, विशेषकर विरासत कोड में जो जावा 6 और नीचे का उपयोग करता है।

जावा 7 में कम अपवादों और अधिक उपयोगी विधियों के साथ बेहतर एपीआई है:

LineIterator lineIterator = null;
try {
    lineIterator = FileUtils.lineIterator(new File("/home/username/m.log"), "windows-1256"); // The second parameter is optionnal
    while (lineIterator.hasNext()) {
        String currentLine = lineIterator.next();
        // Some operation
    }
}
finally {
    LineIterator.closeQuietly(lineIterator);
}

Maven

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

Answer 21

आप Apache Commons IO का भी उपयोग कर सकते हैं :

File file = new File("/home/user/file.txt");
try {
    List<String> lines = FileUtils.readLines(file);
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

Comments

FileUtils.readLines(file)एक पदावनत विधि है। इसके अतिरिक्त, विधि आह्वान करती है IOUtils.readLines, जो एक बफ़रड्रेडर और एरेलेलिस्ट का उपयोग करती है । यह एक लाइन-बाय-लाइन विधि नहीं है, और निश्चित रूप से ऐसा नहीं है जो कई जीबी पढ़ने के लिए व्यावहारिक होगा।

— vallismortis