Course जावा कलेक्शन - Lecture: रैंडम एक्सेसफाइल, आदि।

"हाय, अमीगो!"

"हाय, बिलाबो! जीवन कैसा चल रहा है?"

"बहुत बढ़िया। कल, मैंने कुछ परजीवियों से छुटकारा पाने की कोशिश की, लेकिन अभी तक मुझे ज्यादा सफलता नहीं मिली है। और फिर मुझे फिर से कचरे के डिब्बे में रात बितानी पड़ी।"

"तो ... क्या सब कुछ अभी भी बढ़िया है?"

"आप कह सकते हैं कि।"

"अच्छा। तो आज मेरे लिए तुम्हारे पास क्या है?"

"आज मैं आपको RandomAccessFile क्लास के बारे में बताऊंगा ।"

"बात यह है कि, FileInputStream और FileOutputStream फ़ाइलों को स्ट्रीम के रूप में प्रस्तुत करते हैं: आप केवल क्रमिक रूप से उन्हें पढ़ और लिख सकते हैं।"

"यह हमेशा बहुत सुविधाजनक नहीं होता है। कभी-कभी आपको फ़ाइल के बीच में कुछ पंक्तियां लिखने की आवश्यकता होती है, या बहु-मेगाबाइट फ़ाइल के अंत से टेक्स्ट के कुछ पेज पढ़ने की आवश्यकता होती है। यह पढ़ने के लिए बहुत कुशल नहीं होगा इन कार्यों के लिए पूरी फाइल।"

" इस समस्या को हल करने के लिए RandomAccessFile वर्ग बनाया गया था। आप इसे फ़ाइल में कहीं भी लिखने के लिए उपयोग कर सकते हैं, इससे पढ़ सकते हैं, साथ ही एक ही समय में फ़ाइल को पढ़ और लिख सकते हैं।"

"बहुत दिलचस्प!"

"हाँ। यह वास्तव में काफी सुविधाजनक है।"

"लेकिन आप मनमाने स्थान से कैसे पढ़ते हैं?"

"यह सब बहुत सरल है। कल्पना करें कि आपके पास एक टेक्स्ट एडिटर है, जैसे कि नोटपैड, खुला है। इसमें एक कर्सर है। जब आप कुछ टाइप करते हैं, तो कर्सर जहां कहीं भी होता है, वहां टेक्स्ट जुड़ जाता है। फ़ाइल पढ़ना एक जैसा है। पढ़ना शुरू होता है जहाँ भी 'कर्सर' है। पढ़ने/लिखने के दौरान, कर्सर स्वचालित रूप से चलता है।"

"यहां, आपको एक उदाहरण दिखाना बेहतर होगा:"

एक फाइल पढ़ना:

// r - read, the file is opened only for reading.
RandomAccessFile raf = new RandomAccessFile("input.txt", "r");

// Move the «cursor» to the 100th character.
raf.seek(100);

// Read the line starting from the current cursor position until the end of the line.
String text = raf.readLine();

// Close the file.
raf.close();

"इस उदाहरण में, मैं आपका ध्यान दो बातों की ओर आकर्षित करना चाहूंगा:"

"सबसे पहले, RandomAccessFile ऑब्जेक्ट का निर्माण । दूसरा तर्क अक्षर r है। इसका मतलब है कि फ़ाइल पढ़ने के लिए खोली गई है ( r - read )। यदि आप पढ़ने और लिखने के लिए फ़ाइल खोलना चाहते हैं, तो आपको « rw पास करना होगा »कंस्ट्रक्टर को, केवल « आर » के बजाय।"

"दूसरा, तलाश विधि को देखें। आप इस विधि का उपयोग फ़ाइल के चारों ओर कूदने और वर्तमान पढ़ने/लिखने के संचालन के लिए कर्सर की स्थिति बदलने के लिए कर सकते हैं। जब कोई फ़ाइल पहली बार खोली जाती है, तो कर्सर 0 बाइट पर सेट होता है। या, अधिक सटीक रूप से, ज़ीरोथ बाइट से पहले।"

"क्या मैं सही ढंग से समझ पाया? हम फ़ाइल खोलते हैं, और कर्सर बहुत शुरुआत में है — स्थिति 0 पर। फिर हम सीक कहते हैं और कर्सर को 100वें बाइट पर ले जाते हैं। और जब हम रीडलाइन कहते हैं , तो यह सौवें बाइट से पढ़ना शुरू करता है । सही?"

"हाँ। लेकिन मैं आपका ध्यान इस तथ्य की ओर आकर्षित करना चाहता हूं कि सीक विधि आपको फ़ाइल के चारों ओर मनमाने ढंग से कूदने की अनुमति देती है। उदाहरण के लिए:"

एक फाइल पढ़ना:

// r - read, the file is opened only for reading.
RandomAccessFile raf = new RandomAccessFile("input.txt", "r");

// The "cursor" is at the 0th character.
String text1 = raf.readLine();

// Move the "cursor" to the 100th character.
raf.seek(100);
String text2 = raf.readLine();

// Move the "cursor" to the 0th character.
raf.seek(0);
String text3 = raf.readLine();

// Close the file
raf.close();

"इस उदाहरण में, हम पहले 0वीं बाइट से शुरू होने वाली एक लाइन पढ़ते हैं। फिर हम सौवें बाइट पर जाते हैं और वहां एक लाइन पढ़ते हैं। फिर हम 0वीं बाइट पर फिर से कूदते हैं और एक लाइन पढ़ते हैं। इसका मतलब है कि टेक्स्ट 1 और टेक्स्ट 3 समान हैं। तार।"

"आह। इससे चीजें स्पष्ट हो जाती हैं।"

"बढ़िया। तो यहाँ एक और उदाहरण है:"

एक फाइल पढ़ना:

// rw - read/write, the file is opened for reading and writing.
RandomAccessFile raf = new RandomAccessFile("seek.txt", "rw");

// Write to the file, starting from the 0th byte.
raf.writeBytes("It is a string");

// Move the "cursor" to the 8th character.
raf.seek(8);

// Write "surprise!" to the file.
raf.writeBytes("surprise!");

// Close the file.
raf.close();

"यहां हम कंस्ट्रक्टर को « rw » ( रीड/राइट ) पास करके पढ़ने और लिखने के लिए फाइल खोलते हैं ।

"फिर हम फ़ाइल में « यह एक स्ट्रिंग है » लिखते हैं।

"फिर हम कर्सर को 8वें बाइट पर ले जाते हैं (जो शब्द 'स्ट्रिंग' की शुरुआत होता है)"

"फिर हम लिखते हैं « आश्चर्य !»"

"नतीजतन, फ़ाइल में शामिल है « यह एक आश्चर्य है !»"

"तो, बाइट फ़ाइल के बीच में नहीं डाले जाते हैं, बल्कि वे वहां मौजूद लोगों को प्रतिस्थापित करते हैं?"

"हां।"

"क्या होगा यदि हम कर्सर को फ़ाइल के अंत में ले जाएँ?"

"फिर बाइट्स को अंत तक लिखा जाएगा, और फ़ाइल बड़ी हो जाएगी। तो यह लगभग टेक्स्ट एडिटर में टेक्स्ट लिखने जैसा होगा।"

"हम्म। मुझे लगता है कि मैं सबकुछ समझता हूं। क्या आप रैंडमएक्सेसफाइल क्लास के तरीकों की पूरी सूची प्रदान कर सकते हैं ?"

"यकीनन तुम यहाँ चलो:"

तरीका	विवरण
`int read()`	एक बाइट पढ़ता है और उसे वापस कर देता है
`int read(byte b[], int off, int len)`	बाइट्स की एक सरणी पढ़ता है
`int read(byte b[])`	बाइट्स की एक सरणी पढ़ता है
`void readFully(byte b[])`	बाइट्स की एक सरणी पढ़ता है, और सरणी को भरने के लिए उनमें से पर्याप्त नहीं होने पर नए बाइट्स जोड़े जाने की प्रतीक्षा करता है
`int skipBytes(int n)`	एन बाइट्स छोड़ें। दूसरे शब्दों में, यह कर्सर को n बाइट्स आगे ले जाता है।
`void write(int b)`	कर्सर के स्थान पर एक बाइट लिखता है
`void write(byte b[])`	कर्सर के स्थान पर बाइट्स की एक सरणी लिखता है
`void write(byte b[], int off, int len)`	कर्सर के स्थान पर बाइट्स की एक सरणी लिखता है
`long getFilePointer()`	कर्सर द्वारा इंगित बाइट की संख्या लौटाता है। यह 0 से लेकर फ़ाइल की लंबाई तक हो सकता है
`void seek(long pos)`	पढ़ने/लिखने के लिए प्रयुक्त «कर्सर» को निर्दिष्ट स्थान पर ले जाता है
`long length()`	फ़ाइल की लंबाई लौटाता है
`void setLength(long newLength)`	एक नई फ़ाइल लंबाई सेट करता है। यदि फ़ाइल बड़ी थी, तो वह छोटी हो जाती है; यदि यह छोटा था, तो यह फ़ाइल का विस्तार करता है और नए स्थान को शून्य से भर देता है
`void close()`	फाइल बंद कर देता है
`boolean readBoolean()`	फ़ाइल में कर्सर की वर्तमान स्थिति से बूलियन पढ़ता है
`byte readByte()`	फ़ाइल में कर्सर की वर्तमान स्थिति से एक बाइट पढ़ता है
`char readChar()`	फ़ाइल में कर्सर की वर्तमान स्थिति से चार्ट पढ़ता है
`int readInt()`	फ़ाइल में कर्सर की वर्तमान स्थिति से int पढ़ता है
`long readLong()`	फ़ाइल में कर्सर की वर्तमान स्थिति से लंबा पढ़ता है
`float readFloat()`	फ़ाइल में कर्सर की वर्तमान स्थिति से फ़्लोट पढ़ता है
`double readDouble()`	फ़ाइल में कर्सर की वर्तमान स्थिति से दोहरा पढ़ता है
`String readLine()`	फ़ाइल से एक पंक्ति पढ़ता है और इसे वापस करता है
`void writeBoolean(boolean v)`	फ़ाइल में एक बूलियन लिखता है (कर्सर की स्थिति से शुरू)
`void writeByte(int v) t`	फ़ाइल में एक बाइट लिखता है (कर्सर की स्थिति से शुरू)
`void writeChar(int v)`	फ़ाइल में एक चार लिखता है (कर्सर की स्थिति से शुरू)
`void writeInt(int v)`	फ़ाइल में एक इंट लिखता है (कर्सर की स्थिति से शुरू)
`void writeLong(long v)`	फ़ाइल के लिए एक लंबा लिखता है (कर्सर की स्थिति से शुरू)
`void writeFloat(float v)`	फ़ाइल में एक फ्लोट लिखता है (कर्सर की स्थिति से शुरू)
`void writeDouble(double v)`	फ़ाइल में दोहरा लिखता है (कर्सर की स्थिति से शुरू)
`void writeBytes(String s)`	फ़ाइल में एक स्ट्रिंग लिखता है (कर्सर की स्थिति से शुरू)
`void writeChars(String s)`	फ़ाइल में एक स्ट्रिंग लिखता है (कर्सर की स्थिति से शुरू)

"हम्म। तो, यहां कुछ भी नया नहीं है। शायद तलाश ()/getFilePointer() और लंबाई()/setLength() विधि जोड़े को छोड़कर।"

"हाँ, अमीगो। सब कुछ उसी के बारे में है। लेकिन क्या यह सुविधाजनक नहीं है?"

"यह सुविधाजनक है। बिलाबो, एक दिलचस्प पाठ के लिए और आपने मुझे जो उदाहरण दिए हैं, उसके लिए धन्यवाद।"

"मदद करके खुशी हुई, अमीगो, मेरे दोस्त!"