రాండమ్ యాక్సెస్ ఫైల్ మొదలైనవి.

"హాయ్, అమిగో!"

"హాయ్, బిలాబో! ఎలా ఉంది జీవితం?"

"గ్రేట్. నిన్న, నేను కొన్ని పరాన్నజీవులను వదిలించుకోవడానికి ప్రయత్నించాను, కానీ ఇప్పటివరకు నేను పెద్దగా విజయం సాధించలేదు. ఆపై నేను మళ్ళీ చెత్త కుండీలో రాత్రి గడపవలసి వచ్చింది."

"సో... అంతా ఇంకా గొప్పగా ఉందా?"

"మీరు అలా చెప్పగలరు."

"బాగుంది. ఐతే ఈరోజు నీ దగ్గర నాకేం ఉంది?"

"ఈ రోజు నేను మీకు 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 - రీడ్ ). మీరు చదవడానికి మరియు వ్రాయడానికి ఫైల్‌ను తెరవాలనుకుంటే, మీరు తప్పనిసరిగా పాస్ చేయాలి « rw » కన్స్ట్రక్టర్‌కి, కేవలం « r »కి బదులుగా."

"రెండవది, సీక్ పద్ధతిని చూడండి. మీరు ఫైల్ చుట్టూ దూకడానికి మరియు ప్రస్తుత రీడ్/రైట్ ఆపరేషన్ కోసం కర్సర్ స్థానాన్ని మార్చడానికి ఈ పద్ధతిని ఉపయోగించవచ్చు. ఫైల్ మొదట తెరిచినప్పుడు, కర్సర్ 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వ బైట్‌కి తరలిస్తాము (ఇది 'స్ట్రింగ్' అనే పదం యొక్క ప్రారంభం అవుతుంది)"

"అప్పుడు మేము " ఆశ్చర్యం !" అని వ్రాస్తాము."

"ఫలితంగా, ఫైల్‌లో « ఇది ఆశ్చర్యంగా ఉంది !»"

"కాబట్టి, ఫైల్ మధ్యలో బైట్‌లు చొప్పించబడవు, బదులుగా అవి అక్కడ ఉన్న వాటిని భర్తీ చేస్తాయి?"

"అవును."

"మేము కర్సర్‌ను ఫైల్ చివరకి తరలించినట్లయితే?"

"అప్పుడు బైట్‌లు చివరి వరకు వ్రాయబడతాయి మరియు ఫైల్ పెద్దదిగా ఉంటుంది. కనుక ఇది దాదాపు టెక్స్ట్ ఎడిటర్‌లో వచనాన్ని వ్రాసినట్లుగా ఉంటుంది."

"హ్మ్. నేను ప్రతిదీ అర్థం చేసుకున్నాను. మీరు RandomAccessFile క్లాస్ పద్ధతుల పూర్తి జాబితాను అందించగలరా ?"

"ఖచ్చితంగా! ఇదిగో మీకు కావలసినది:"

"హ్మ్. కాబట్టి, ఇక్కడ కొత్తది ఏమీ లేదు. సీక్()/getFilePointer() మరియు length()/setLength() మెథడ్ పెయిర్స్ తప్ప."

"అవును, ఏమిగో. అంతా ఒకటే. కానీ అది అనుకూలమైనది కాదా?"

"ఇది సౌకర్యవంతంగా ఉంది. బిలాబో, ఆసక్తికరమైన పాఠం కోసం మరియు మీరు నాకు ఇచ్చిన ఉదాహరణలకు ధన్యవాదాలు."

"సహాయం చేయడం ఆనందంగా ఉంది, అమిగో, నా స్నేహితుడు!"