RandomAccessFile, முதலியன

"ஹாய், அமிகோ!"

"ஹாய், பிலாபோ! எப்படி இருக்கிறது வாழ்க்கை?"

"அருமை. நேற்று, நான் சில ஒட்டுண்ணிகளை அகற்ற முயற்சித்தேன், ஆனால் இதுவரை என்னால் வெற்றிபெறவில்லை. பின்னர் நான் மீண்டும் குப்பைத் தொட்டியில் இரவைக் கழிக்க வேண்டியிருந்தது."

"அப்போ... எல்லாம் இன்னும் பெரியதா?"

"நீங்கள் அப்படிச் சொல்லலாம்."

"நல்லது. இன்று என்னிடம் என்ன வைத்திருக்கிறாய்?"

"இன்று நான் உங்களுக்கு 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வது பைட்டுக்குத் தாவி ஒரு வரியைப் படித்தோம். அதாவது text1 மற்றும் text3 ஒரே மாதிரியாக இருக்கும். சரங்கள்."

"ஆ. அது விஷயங்களை தெளிவாக்குகிறது."

"அருமை. இதோ இன்னொரு உதாரணம்:"

// 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வது பைட்டுக்கு நகர்த்துகிறோம் (இது 'ஸ்ட்ரிங்' என்ற வார்த்தையின் தொடக்கமாக இருக்கும்)"

"பின்னர் நாங்கள் எழுதுகிறோம் " ஆச்சரியம் !"

"இதன் விளைவாக, கோப்பு " இது ஒரு ஆச்சரியம் !"

"எனவே, பைட்டுகள் கோப்பின் நடுவில் செருகப்படவில்லை, மாறாக அவை இருந்தவற்றை மாற்றியமைக்கப்படுமா?"

"ஆமாம்."

"கோப்பின் கடைசி பகுதிக்கு கர்சரை நகர்த்தினால் என்ன செய்வது?"

"பின்னர் பைட்டுகள் இறுதிவரை எழுதப்படும், மேலும் கோப்பு பெரிதாகிவிடும். எனவே இது டெக்ஸ்ட் எடிட்டரில் உரையை எழுதுவது போல் இருக்கும்."

"ஹ்ம்ம். நான் எல்லாவற்றையும் புரிந்துகொண்டேன் என்று நினைக்கிறேன். RandomAccessFile வகுப்பின் முறைகளின் முழுமையான பட்டியலை உங்களால் வழங்க முடியுமா?"

"நிச்சயமா. இதோ போ:"

"ம்ம். எனவே, இங்கு புதிதாக எதுவும் இல்லை. சீக்()/getFilePointer() மற்றும் length()/setLength() முறை ஜோடிகளைத் தவிர."

"ஆமாம், அமிகோ. எல்லாமே ஒரே மாதிரிதான். ஆனால் அது வசதியாக இல்லையா?"

"இது வசதியானது. பிலாபோ, ஒரு சுவாரஸ்யமான பாடத்திற்கும், நீங்கள் எனக்குக் கொடுத்த எடுத்துக்காட்டுகளுக்கும் நன்றி."

"உதவி செய்வதில் மகிழ்ச்சி, அமிகோ, என் நண்பரே!"