जावा: टेक्स्ट फाइल कैसे पढ़ें

Question 1

मैं एक पाठ फ़ाइल पढ़ना चाहता हूं जिसमें अंतरिक्ष के अलग-अलग मूल्य हैं। मान पूर्णांक हैं। मैं इसे कैसे पढ़ सकता हूं और इसे एक सरणी सूची में डाल सकता हूं?

यहाँ पाठ फ़ाइल की सामग्री का एक उदाहरण है:

1 62 4 55 5 6 77

मैं इसे एक सरणी सूची में रखना चाहता हूं [1, 62, 4, 55, 5, 6, 77]। मैं इसे जावा में कैसे कर सकता हूं?

Question 2

आप Files#readAllLines()टेक्स्ट फ़ाइल की सभी पंक्तियों को एक में प्राप्त करने के लिए उपयोग कर सकते हैं List<String>।

for (String line : Files.readAllLines(Paths.get("/path/to/file.txt"))) {
    // ...
}

ट्यूटोरियल: बेसिक I / O> फाइल I / O> टेक्स्ट फाइल पढ़ना, लिखना और बनाना

आप एक नियमित अभिव्यक्ति के आधार पर भागों में String#split()विभाजित करने के लिए उपयोग कर सकते हैं String।

for (String part : line.split("\\s+")) {
    // ...
}

ट्यूटोरियल: नंबर और स्ट्रिंग्स> स्ट्रिंग्स> स्ट्रिंग में अक्षरों को जोड़ते हुए

आप Integer#valueOf()a Stringको a में कन्वर्ट करने के लिए उपयोग कर सकते हैं Integer।

Integer i = Integer.valueOf(part);

ट्यूटोरियल: नंबर और स्ट्रिंग्स> स्ट्रिंग्स> संख्याओं और स्ट्रिंग्स के बीच परिवर्तित

आप List#add()एक तत्व को एक में जोड़ने के लिए उपयोग कर सकते हैं List।

numbers.add(i);

ट्यूटोरियल: इंटरफेस> सूची इंटरफ़ेस

तो, संक्षेप में (यह मानते हुए कि फ़ाइल में खाली लाइनें नहीं हैं और न ही अनुगामी / अग्रणी व्हाट्सएप)।

List<Integer> numbers = new ArrayList<>();
for (String line : Files.readAllLines(Paths.get("/path/to/file.txt"))) {
    for (String part : line.split("\\s+")) {
        Integer i = Integer.valueOf(part);
        numbers.add(i);
    }
}

यदि आप जावा 8 में पहले से मौजूद हैं, तो आप इसके लिए स्ट्रीम एपीआई का उपयोग भी कर सकते हैं , जिसके साथ शुरू हो रहा है Files#lines()।

List<Integer> numbers = Files.lines(Paths.get("/path/to/test.txt"))
    .map(line -> line.split("\\s+")).flatMap(Arrays::stream)
    .map(Integer::valueOf)
    .collect(Collectors.toList());

ट्यूटोरियल: जावा 8 स्ट्रीम के साथ प्रोसेसिंग डाटा

Question 3

जावा 1.5 ने फाइल और धाराओं से इनपुट को संभालने के लिए स्कैनर वर्ग की शुरुआत की ।

इसका उपयोग किसी फ़ाइल से पूर्णांक प्राप्त करने के लिए किया जाता है और कुछ इस तरह दिखाई देगा:

List<Integer> integers = new ArrayList<Integer>();
Scanner fileScanner = new Scanner(new File("c:\\file.txt"));
while (fileScanner.hasNextInt()){
   integers.add(fileScanner.nextInt());
}

एपीआई की जाँच करें। विभिन्न प्रकार के इनपुट स्रोतों से निपटने के लिए, भिन्न सीमांकक और भिन्न प्रकार के डेटा प्रकारों के लिए कई और विकल्प हैं।

Question 4

यह उदाहरण कोड आपको जावा में फ़ाइल पढ़ने का तरीका दिखाता है।

import java.io.*;

/**
 * This example code shows you how to read file in Java
 *
 * IN MY CASE RAILWAY IS MY TEXT FILE WHICH I WANT TO DISPLAY YOU CHANGE WITH YOUR   OWN      
 */

 public class ReadFileExample 
 {
    public static void main(String[] args) 
    {
       System.out.println("Reading File from Java code");
       //Name of the file
       String fileName="RAILWAY.txt";
       try{

          //Create object of FileReader
          FileReader inputFile = new FileReader(fileName);

          //Instantiate the BufferedReader Class
          BufferedReader bufferReader = new BufferedReader(inputFile);

          //Variable to hold the one line data
          String line;

          // Read file line by line and print on the console
          while ((line = bufferReader.readLine()) != null)   {
            System.out.println(line);
          }
          //Close the buffer reader
          bufferReader.close();
       }catch(Exception e){
          System.out.println("Error while reading file line by line:" + e.getMessage());                      
       }

     }
  }

Question 5

इस उदाहरण को देखें, और अपना प्रयास करें:

import java.io.*;

public class ReadFile {

    public static void main(String[] args){
        String string = "";
        String file = "textFile.txt";

        // Reading
        try{
            InputStream ips = new FileInputStream(file);
            InputStreamReader ipsr = new InputStreamReader(ips);
            BufferedReader br = new BufferedReader(ipsr);
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
                string += line + "\n";
            }
            br.close();
        }
        catch (Exception e){
            System.out.println(e.toString());
        }

        // Writing
        try {
            FileWriter fw = new FileWriter (file);
            BufferedWriter bw = new BufferedWriter (fw);
            PrintWriter fileOut = new PrintWriter (bw);
                fileOut.println (string+"\n test of read and write !!");
            fileOut.close();
            System.out.println("the file " + file + " is created!");
        }
        catch (Exception e){
            System.out.println(e.toString());
        }
    }
}

Question 6

बस मज़े के लिए, यहाँ मैं शायद एक वास्तविक परियोजना में क्या करूँगा, जहाँ मैं पहले से ही अपने सभी पसंदीदा पुस्तकालयों का उपयोग कर रहा हूँ (इस मामले में अमरूद , जिसे पहले Google संग्रह के रूप में जाना जाता था )।

String text = Files.toString(new File("textfile.txt"), Charsets.UTF_8);
List<Integer> list = Lists.newArrayList();
for (String s : text.split("\\s")) {
    list.add(Integer.valueOf(s));
}

लाभ: ज्यादा नहीं स्वयं के कोड (जैसे के साथ इसके विपरीत बनाए रखने के लिए इस )। संपादित करें : हालांकि यह ध्यान देने योग्य है कि इस मामले में tschaible के स्कैनर समाधान का कोई और कोड नहीं है!

दोष: आप स्पष्ट रूप से सिर्फ इसके लिए नई लाइब्रेरी निर्भरता नहीं जोड़ना चाहते हैं। ^{(तब फिर से, आप अपनी परियोजनाओं में अमरूद का उपयोग नहीं करने के लिए मूर्ख होंगे। ;-)}

Question 7

इस तरह की सरल / सामान्य चीजों के लिए Apache Commons (IO और Lang) का उपयोग करें ।

आयात:

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.ArrayUtils;

कोड:

String contents = FileUtils.readFileToString(new File("path/to/your/file.txt"));
String[] array = ArrayUtils.toArray(contents.split(" "));

किया हुआ।

Question 8

NIO.2 के साथ फ़ाइलों को पढ़ने के लिए जावा 7 का उपयोग करना

इन पैकेजों को आयात करें:

import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

यह एक फ़ाइल पढ़ने की प्रक्रिया है:

Path file = Paths.get("C:\\Java\\file.txt");

if(Files.exists(file) && Files.isReadable(file)) {

    try {
        // File reader
        BufferedReader reader = Files.newBufferedReader(file, Charset.defaultCharset());

        String line;
        // read each line
        while((line = reader.readLine()) != null) {
            System.out.println(line);
            // tokenize each number
            StringTokenizer tokenizer = new StringTokenizer(line, " ");
            while (tokenizer.hasMoreElements()) {
                // parse each integer in file
                int element = Integer.parseInt(tokenizer.nextToken());
            }
        }
        reader.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

किसी फ़ाइल की सभी पंक्तियों को एक साथ पढ़ने के लिए:

Path file = Paths.get("C:\\Java\\file.txt");
List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);

Question 9

अब तक दिए गए सभी उत्तरों में लाइन द्वारा फाइल लाइन को पढ़ना, लाइन को एक के रूप में लेना Stringऔर फिर प्रोसेसिंग करना शामिल है String।

कोई सवाल नहीं है कि यह समझने का सबसे आसान तरीका है, और अगर फ़ाइल काफी कम है (कहो, तो दसियों हज़ार लाइनें), यह दक्षता के मामले में भी स्वीकार्य होगा। लेकिन अगर फ़ाइल लंबी है , तो इसे दो कारणों से करने के लिए एक बहुत ही अक्षम तरीका है:

प्रत्येक चरित्र दो बार संसाधित होता है, एक बार निर्माण में String, और एक बार प्रसंस्करण में।
यदि फ़ाइल में बहुत सारी लाइनें हैं, तो कचरा संग्रहकर्ता आपका मित्र नहीं होगा। आप Stringप्रत्येक पंक्ति के लिए एक नया निर्माण कर रहे हैं , और फिर अगली पंक्ति में जाने पर इसे फेंक देते हैं। कचरा संग्रहकर्ता को अंततः इन सभी Stringवस्तुओं का निपटान करना होगा जो आप और अधिक नहीं चाहते हैं। तुम्हारे जाने के बाद किसी की सफाई हुई।

यदि आप गति के बारे में परवाह करते हैं, तो आप डेटा के एक ब्लॉक को पढ़ने और फिर लाइन द्वारा लाइन के बजाय बाइट द्वारा इसे संसाधित करने से बहुत बेहतर हैं। हर बार जब आप एक नंबर के अंत में आते हैं, तो आप इसे Listबिल्डिंग में जोड़ते हैं।

यह कुछ इस तरह से सामने आएगा:

private List<Integer> readIntegers(File file) throws IOException {
    List<Integer> result = new ArrayList<>();
    RandomAccessFile raf = new RandomAccessFile(file, "r");
    byte buf[] = new byte[16 * 1024];
    final FileChannel ch = raf.getChannel();
    int fileLength = (int) ch.size();
    final MappedByteBuffer mb = ch.map(FileChannel.MapMode.READ_ONLY, 0,
            fileLength);
    int acc = 0;
    while (mb.hasRemaining()) {
        int len = Math.min(mb.remaining(), buf.length);
        mb.get(buf, 0, len);
        for (int i = 0; i < len; i++)
            if ((buf[i] >= 48) && (buf[i] <= 57))
                acc = acc * 10 + buf[i] - 48;
            else {
                result.add(acc);
                acc = 0;
            }
    }
    ch.close();
    raf.close();
    return result;
}

उपरोक्त कोड मानता है कि यह ASCII है (हालांकि इसे अन्य एन्कोडिंग के लिए आसानी से ट्विक किया जा सकता है), और यह कि कुछ भी जो एक अंक नहीं है (विशेष रूप से, एक स्थान या एक नई रेखा) अंकों के बीच एक सीमा का प्रतिनिधित्व करता है। यह भी मानता है कि फ़ाइल एक गैर-अंक के साथ समाप्त होती है (व्यवहार में, कि अंतिम पंक्ति एक नई रेखा के साथ समाप्त होती है), हालांकि, फिर से, उस मामले से निपटने के लिए इसे घुमाया जा सकता है जहां यह नहीं होता है।

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

Question 10

फ़ाइल पढ़ें और फिर जो कुछ भी आप चाहते हैं java8 Files.lines (पाथसेगेट ("c: //lines.txt"))। कलेक्ट करें। (संग्राहक.toList ());