ఫైల్, ఫైల్స్, పాత్

"హాయ్, అమిగో. చాలా కాలం, చూడలేదు."

"హాయ్, బిలాబో. ఏం మాట్లాడబోతున్నారు?"

"ఈ రోజు నేను మీకు ఫైల్‌లతో పని చేయడం గురించి చెప్పబోతున్నాను.  Javaలో మీరు హార్డ్ డ్రైవ్‌లో ఫైల్‌లను నిర్వహించడానికి ఉపయోగించే ఒక ప్రత్యేక తరగతి (ఫైల్) ఉంది. ఫైల్ కంటెంట్‌లను నిర్వహించడానికి, ఇతర తరగతులు ఉన్నాయి: FileInputStream, FileOutputStream, మొదలైనవి. "

"ఆసక్తికరంగా ఉంది. అయితే మీరు 'ఫైళ్లను నిర్వహించండి' అని చెప్పినప్పుడు, మీ ఉద్దేశ్యం ఏమిటి?"

"నేను ఇప్పుడు వివరించబోయేది అదే. ఫైల్‌లను సృష్టించవచ్చు, తొలగించవచ్చు, పేరు మార్చవచ్చు మరియు మరెన్నో చేయవచ్చు. మీరు ఫైల్‌లోని కంటెంట్‌లతో పనిచేసే (చదవడానికి, వ్రాయడానికి, మార్చడానికి) ఆచరణాత్మకంగా ప్రతి తరగతికి ఫైల్ ఆబ్జెక్ట్‌ను పంపవచ్చు. . ఉదాహరణకి:"

FileInputStream input = new FileInputStream("c:/path/a.txt");

File file = new File("c:/path/a.txt");
FileInputStream input = new FileInputStream(file);

"కానీ రెండవ ఎంపిక చాలా పొడవుగా ఉంది. మనకు ఈ ఫైల్ ఆబ్జెక్ట్‌లు ఎందుకు అవసరమో నాకు ఇప్పటికీ అర్థం కాలేదు."

"ఈ నిర్దిష్ట ఉదాహరణ కోసం, మీరు చెప్పింది నిజమే. "ఇది మీరు దీన్ని ఎలా చేయాలి అనేదానికి ఉదాహరణ కాదు, బదులుగా మీరు దీన్ని ఎలా చేయగలరు.
కానీ మీరు నిర్దిష్ట డైరెక్టరీలో ఉన్న అన్ని ఫైళ్ళ జాబితాను ప్రదర్శించాల్సిన అవసరం ఉందని ఊహించండి. ఫైల్ ఆబ్జెక్ట్‌లను ఉపయోగించి దీన్ని ఎలా చేయాలో ఇక్కడ ఉంది:"

File folder = new File("c:/path/");
for (File file : folder.listFiles())
{
 System.out.println(file.getName());
}

" listFiles() అనేది «c:/path/» ద్వారా సూచించబడిన ఫోల్డర్‌లోని ఫైల్‌ల జాబితాను తిరిగి ఇచ్చే పద్ధతి?"

"అవును. కానీ ప్రోగ్రామర్లు సాధారణంగా 'డైరెక్టరీ' అని చెబుతారు. 'ఫోల్డర్' అనే పదం సాపేక్షంగా ఇటీవల వాడుకలోకి వచ్చింది, కానీ సూత్రప్రాయంగా, రెండు పదాలు సరైనవి మరియు మీరు ఏది ఇష్టపడితే అది చెప్పవచ్చు."

"సరే. మరియు getName () ఏమి చేస్తుంది ? ఫైల్ పేరును తిరిగి ఇవ్వండి? పేరులో ఖచ్చితంగా ఏమి చేర్చబడింది? మార్గంతో సహా పూర్తి పేరు లేదా ఫైల్ పేరు మాత్రమేనా?"

"ఫైల్ పేరు మాత్రమే. పూర్తి మార్గం కోసం, file.getAbsolutePath() ఉంది."

"కాబట్టి ఫైల్ క్లాస్‌లో ఏ ఇతర పద్ధతులు ఉన్నాయి?"

"ఇది చూడండి:"

"ఓహ్! చాలా చిన్న జాబితా కాదు, అవునా? మరియు మీరు దీనితో చాలా ఎక్కువ చేయగలరని అనిపిస్తుంది: ఫైల్‌లను సృష్టించండి మరియు తొలగించండి, వాటి పేరు మార్చండి,..."

"కాబట్టి ప్రస్తుత ఫైల్ డైరెక్టరీని పొందడానికి, నేను getParent()కి కాల్ చేయాలా?"

"అవును, కానీ అది స్ట్రింగ్‌ను అందిస్తుంది - ఫైల్ మార్గం - ఫైల్ ఆబ్జెక్ట్ కాదు. వాస్తవానికి, ఫైల్ క్లాస్ దాదాపు అన్ని పద్ధతులను నకిలీ చేస్తుంది: ఒక సంస్కరణ స్ట్రింగ్‌ను అందిస్తుంది, మరొకటి ― ఫైల్ ఆబ్జెక్ట్‌ను అందిస్తుంది. దాన్ని తనిఖీ చేయండి:"

File file = new File("c:/path/a.txt");
String directory = file.getParent();

File file = new File("c:/path/a.txt");
File directory = file.getParentFile();

మీకు ఫైల్ మార్గంతో స్ట్రింగ్ ఉంటే మరియు మీకు ఫైల్ ఆబ్జెక్ట్ అవసరమైతే, కన్స్ట్రక్టర్‌ని ఉపయోగించండి. పరిస్థితి తారుమారైతే (మీకు ఫైల్ ఆబ్జెక్ట్ ఉంది కానీ మీకు స్ట్రింగ్ అవసరం), అప్పుడు getAbsolutePath ()ని ఉపయోగించండి. ఉదాహరణకి:"

String path = "c:/a.txt";
File file = new File(path);

File file = new File("c:/a.txt");
String path = file.getAbsolutePath();

"దొరికింది."

"అద్భుతం. మీ కోసం ఇక్కడ ఒక చిన్న పని ఉంది: ప్రస్తుత ఫైల్ వలె ఒకే డైరెక్టరీలో ఉన్న అన్ని ఫైల్‌ల పేర్లను చూపండి."

"ఏదీ అంత సులభం కాదు. ఇక్కడ చూడండి:"

//Some file
File originalFile = new File("c:/path/dir2/a.txt");

//An object representing the directory
File folder = originalFile.getParentFile();

//Print the file list on screen
for (File file : folder.listFiles())
{
 System.out.println(file.getName());
}

"హ్మ్. కరెక్ట్."

"కానీ ఫైల్ మరియు డైరెక్టరీ రెండింటికీ ఒకే తరగతి ― ఫైల్ - ఉపయోగించబడటం కొంచెం గందరగోళంగా ఉంది. అది నాకు చాలా లాజికల్‌గా అనిపించదు."

"చారిత్రక కారణాల వల్ల ఇది ఆ విధంగా పనిచేసింది. ఒక డైరెక్టరీ డిస్క్‌లో ఒక ప్రత్యేక 'ఖాళీ' ఫైల్‌గా ఉండేది. అయితే, ఇప్పుడు చాలా మారిపోయింది, కానీ ప్రతిదీ కాదు. ఈ రోజు నా దగ్గర ఉన్నది అంతే."

"ఆసక్తికరమైన పాఠానికి ధన్యవాదాలు, బిలాబో."