"ఓ, రిషీ! హాయ్!"
"హాయ్, అమిగో! ఎలా ఉంది జీవితం?"
"అద్భుతం. బిలాబో నాకు ఫైల్ గురించి మరియు దానితో ఎలా పని చేయాలో కొన్ని ఆసక్తికరమైన విషయాలు చెబుతూనే ఉన్నారు."
"ఇది జరిగినప్పుడు, నేను ఈ అంశంపై ఏదైనా జోడించాలని అనుకుంటున్నాను."
"నిజమేనా? అప్పుడు నేను అన్ని చెవులు."
"సరే, వినండి. జావా నిరంతరం అభివృద్ధి చెందుతోంది. దీని డెవలపర్‌లు విభిన్న పనులను మరింత సమర్థవంతంగా చేయడానికి నిరంతరం కొత్త మార్గాలను వెతుకుతూనే ఉన్నారు. జావా 7లో, వారు ఫైల్ క్లాస్‌కి ప్రత్యామ్నాయాన్ని జోడించారు."
"ప్రత్యామ్నాయా?"
"అవును. వారు ఫైల్ క్లాస్‌ని ప్రాతిపదికగా తీసుకున్నారు , కొన్ని కొత్త అంశాలను జోడించారు, పద్ధతులను పేరు మార్చారు, ఆపై దానిని రెండుగా విభజించారు. కాబట్టి ఇప్పుడు రెండు కొత్త క్లాస్‌లు ఉన్నాయి: పాత్ మరియు ఫైల్స్ . పాత్ నిజానికి ఫైల్ యొక్క కొత్త అనలాగ్. క్లాస్, మరియు ఫైల్ అనేది యుటిలిటీ క్లాస్ (అరేలు మరియు కలెక్షన్స్ క్లాస్‌లకు సారూప్యంగా ఉంటుంది). ఫైల్ క్లాస్ యొక్క అన్ని స్టాటిక్ మెథడ్స్ అక్కడికి వెళ్తాయి. ఈ విధంగా చేయడం OOP పరంగా 'మరింత సరైనది'."
"సరే, ఇది OOP పరంగా అయితే, సరే. కాబట్టి ఏమి మార్చబడింది?"
"మొదట, వారు స్ట్రింగ్ మరియు ఫైల్ ఆబ్జెక్ట్‌లను తిరిగి ఇచ్చే పద్ధతులను పునరుత్పత్తి చేయకూడదని నిర్ణయించుకున్నారు . పాత్ క్లాస్‌లో, అన్ని పద్ధతులు మార్గాన్ని తిరిగి ఇస్తాయి .
"రెండవది, వారు చాలా స్టాటిక్ యుటిలిటీ పద్ధతులను ఫైల్స్ క్లాస్‌కి తరలించారు."
"మూడవది, సాపేక్ష మార్గాలతో పనిచేయడం మరింత సౌకర్యవంతంగా మారింది."
"పద్ధతుల జాబితా ఇక్కడ ఉంది:"
| పాత్ క్లాస్ యొక్క పద్ధతులు | వివరణ |
|---|---|
boolean isAbsolute() |
మార్గం సంపూర్ణంగా ఉంటే నిజం తిరిగి వస్తుంది. |
Path getRoot() |
ప్రస్తుత పాత్ యొక్క రూట్‌ను అందిస్తుంది, అంటే టాప్‌మోస్ట్ డైరెక్టరీ. |
Path getFileName() |
ప్రస్తుత మార్గం నుండి ఫైల్ పేరును అందిస్తుంది. |
Path getParent() |
ప్రస్తుత మార్గం నుండి డైరెక్టరీని అందిస్తుంది. |
boolean startsWith(Path other) |
ప్రస్తుత మార్గం పాస్ పాత్‌తో ప్రారంభమవుతుందో లేదో తనిఖీ చేస్తుంది. |
boolean endsWith(Path other) |
పాస్ పాత్‌తో ప్రస్తుత మార్గం ముగుస్తుందో లేదో తనిఖీ చేస్తుంది. |
Path normalize() |
ప్రస్తుత మార్గాన్ని సాధారణీకరిస్తుంది. ఉదాహరణకు, «c:/dir/dir2/../a.txt»ని «c:/dir/a.txt»గా మారుస్తుంది |
Path relativize(Path other) |
రెండు మార్గాల సాపేక్ష మార్గాన్ని గణిస్తుంది, అనగా «మార్గాల మధ్య వ్యత్యాసం» |
Path resolve(String other) |
ప్రస్తుత మరియు సంబంధిత మార్గాలను ఉపయోగించి సంపూర్ణ మార్గాన్ని పరిష్కరిస్తుంది. |
URI toUri() |
ప్రస్తుత పాత్/ఫైల్ అయితే URIని అందిస్తుంది. |
Path toAbsolutePath() |
అది సాపేక్షంగా ఉంటే, మార్గాన్ని సంపూర్ణ మార్గంగా మారుస్తుంది. |
File toFile() |
ప్రస్తుత పాత్ ఆబ్జెక్ట్‌కు అనుగుణంగా ఉండే ఫైల్ ఆబ్జెక్ట్‌ను అందిస్తుంది. |
"మరియు ప్రస్తుత మార్గం-అది ఏమిటి?"
"ఇది పాత్ వస్తువు యొక్క కన్స్ట్రక్టర్‌కు పంపబడిన మార్గం, దీని పద్ధతులు పిలువబడుతున్నాయి."
"సరే. కాబట్టి ఫైల్స్ క్లాస్‌లో ఏ పద్ధతులు ఉన్నాయి?"
"మీరు ఎక్కడికైనా వెళ్ళడానికి తొందరపడుతున్నారా? నేను మీకు ఇప్పుడే చెబుతాను. ఇక్కడ చాలా ముఖ్యమైన పద్ధతులు ఉన్నాయి:"
| ఫైల్స్ క్లాస్ యొక్క పద్ధతులు | వివరణ |
|---|---|
Path createFile(…) |
డిస్క్‌లో ఫైల్‌ను సృష్టిస్తుంది. |
Path createDirectory(…) |
డైరెక్టరీని సృష్టిస్తుంది. |
Path createDirectories(…) |
డైరెక్టరీని మరియు దాని అన్ని సబ్ డైరెక్టరీలను సృష్టిస్తుంది. |
Path createTempFile(…) |
తాత్కాలిక ఫైల్‌ను సృష్టిస్తుంది. |
Path createTempDirectory(…) |
తాత్కాలిక డైరెక్టరీని సృష్టిస్తుంది. |
void delete(Path path) |
ఫైల్‌ను తొలగిస్తుంది. |
Path copy(Path source, Path target,…) |
ఫైల్‌ను కాపీ చేస్తుంది. |
Path move(Path source, Path target,…) |
ఫైల్‌ను తరలిస్తుంది. |
boolean isSameFile(Path, Path) |
రెండు ఫైళ్లను సరిపోల్చండి. |
boolean isDirectory(Path) |
మార్గం డైరెక్టరీనా? |
boolean isRegularFile(Path) |
మార్గం ఫైల్‌గా ఉందా? |
long size(Path) |
ఫైల్ పరిమాణాన్ని అందిస్తుంది. |
boolean exists(Path) |
అదే పేరుతో ఒక వస్తువు ఉందా? |
boolean notExists(Path) |
అదే పేరుతో ఒక వస్తువు ఉనికిలో లేదా? |
long copy(InputStream, OutputStream) |
ఇన్‌పుట్ స్ట్రీమ్ నుండి అవుట్‌పుట్ స్ట్రీమ్‌కు బైట్‌లను కాపీ చేస్తుంది. |
long copy(Path, OutputStream) |
పాత్ నుండి అవుట్‌పుట్ స్ట్రీమ్‌కు అన్ని బైట్‌లను కాపీ చేస్తుంది. |
long copy(InputStream, Path) |
ఇన్‌పుట్ స్ట్రీమ్ నుండి పాత్‌కు అన్ని బైట్‌లను కాపీ చేస్తుంది. |
byte[] read(InputStream, int initialSize) |
ఇన్‌పుట్ స్ట్రీమ్ నుండి బైట్‌ల శ్రేణిని చదువుతుంది. |
byte[] readAllBytes(Path path) |
ఇన్‌పుట్ స్ట్రీమ్ నుండి అన్ని బైట్‌లను చదువుతుంది. |
List<String> readAllLines(Path path,..) |
టెక్స్ట్ ఫైల్‌ను చదివి, స్ట్రింగ్‌ల జాబితాను అందిస్తుంది. |
Path write(Path path, byte[] bytes,…) |
ఫైల్‌కి బైట్‌ల శ్రేణిని వ్రాస్తుంది. |
"ఎంత ఆసక్తికరంగా ఉంది! చాలా మంచి ఫంక్షన్‌లు మరియు అన్నీ ఒకే స్థలంలో ఉన్నాయి."
"సరే చూడండి. మీరు ఇంటర్నెట్ నుండి ఫైల్‌ను డౌన్‌లోడ్ చేసి, ఆపై దాన్ని ఎవరికైనా పంపాలనుకుంటున్నారని అనుకుందాం. దీన్ని చేయడానికి, డిస్క్‌లో తాత్కాలిక ఫైల్‌ను సృష్టించడం మరియు రీడ్ డేటాను దానికి సేవ్ చేయడం చాలా సౌకర్యంగా ఉంటుంది."
"ఇంటర్నెట్ నుండి ఫైల్ డౌన్‌లోడ్ చేయడం కష్టంగా ఉందా?"
"ఇది చాలా సులభం. ఈ ఉదాహరణ చూడండి:"
URL url = new URL("https://www.google.com.ua/images/srpr/logo11w.png");
InputStream inputStream = url.openStream();
Path tempFile = Files.createTempFile("temp-",".tmp");
Files.copy(inputStream, tempFile);"మరి అంతేనా?"
"అవును, మీరు ఏమి చూడాలని అనుకున్నారు? 4 లైన్లు మాత్రమే ఉన్నాయి."
" పంక్తి 1. చిత్ర ఫైల్ యొక్క URL పంపబడిన URL ఆబ్జెక్ట్‌ను సృష్టిస్తుంది.
" పంక్తి 2. url ఆబ్జెక్ట్‌పై ఫైల్ (ఇన్‌పుట్ స్ట్రీమ్) చదవడానికి స్ట్రీమ్ తెరవబడుతుంది.
" పంక్తి 3. తాత్కాలిక ఫైల్‌ని సృష్టించడానికి పద్ధతి createTempFileఉపయోగించబడుతుంది.
" లైన్ 4. Files.copy పద్ధతి నుండి డేటాను కాపీ చేస్తుంది . inputStream అంతే tempFile."
"చాతుర్యం!"
"అద్భుతం. మీకు నచ్చినందుకు నేను సంతోషిస్తున్నాను. మిగిలిన పద్ధతులను మీరే గుర్తించగలరని నేను భావిస్తున్నాను. వాటి గురించి మీకు అనేక పనులు ఇవ్వమని నేను డియెగోని అడుగుతాను."
"అయితే, ఈ మెటీరియల్‌కి సంబంధించి ఇక్కడ మంచి లింక్ ఉంది"