జావాలోని ఫైల్‌లతో పని చేస్తోంది

1. Filesతరగతి

ఫైళ్ళతో పని చేయడానికి, ఒక వివేక యుటిలిటీ క్లాస్ ఉంది — java.nio.file.Files. ఇందులో ప్రతి సందర్భానికి సంబంధించిన పద్ధతులు ఉంటాయి. ఈ తరగతి యొక్క అన్ని పద్ధతులు స్థిరంగా ఉంటాయి మరియు పాత్ ఆబ్జెక్ట్‌పై పనిచేస్తాయి. చాలా పద్ధతులు ఉన్నాయి, కాబట్టి మేము చాలా ముఖ్యమైన వాటిని మాత్రమే పరిశీలిస్తాము:

Path createFile(Path path)

Path createDirectory(Path path)

Path createDirectories(Path path)

Path createTempFile(prefix, suffix)

Path createTempDirectory(prefix)

void delete(Path path)

Path copy(Path src, Path dest)

Path move(Path src, Path dest)

boolean isDirectory(Path path)

boolean isRegularFile(Path path)

boolean exists(Path path)

long size(Path path)

byte[] readAllBytes(Path path)

String readString(Path path)

List<String> readAllLines(Path path)

Path write(Path path, byte[])

Path writeString(Path path, String str)

DirectoryStream<Path> newDirectoryStream(Path dir)

2. ఫైళ్లు మరియు డైరెక్టరీలను సృష్టించడం

ఫైల్‌లు మరియు డైరెక్టరీలను సృష్టించడం చాలా సులభం. కొన్ని ఉదాహరణలతో మనల్ని మనం ఒప్పించుకుందాం:

Files.createFile(Path.of("c:\\readme.txt"));

Files.createDirectory(Path.of("c:\\test"));

Files.createDirectories(Path.of("c:\\test\\1\\2\\3"));

3. కాపీ చేయడం, తరలించడం మరియు తొలగించడం

ఫైల్‌లను కాపీ చేయడం, తరలించడం మరియు తొలగించడం చాలా సులభం. ఇది డైరెక్టరీలకు కూడా వర్తిస్తుంది, కానీ అవి ఖాళీగా ఉండాలి.

Path path1 = Path.of("c:\\readme.txt");
Path path2 = Path.of("c:\\readme-copy.txt");
Files.copy(path1, path2);

Path path1 = Path.of("c:\\readme.txt");
Path path2 = Path.of("d:\\readme-new.txt");
Files.move(path1, path2);

Path path = Path.of("d:\\readme-new.txt");
Files.delete(path);

4. ఫైల్ రకం మరియు ఉనికిని తనిఖీ చేస్తోంది

మీరు వేరొకరు అందించిన మార్గాన్ని కలిగి ఉన్నప్పుడు, అది ఫైల్ లేదా డైరెక్టరీ అని మీరు తెలుసుకోవాలి. మరియు సాధారణంగా, అటువంటి ఫైల్/డైరెక్టరీ ఉందా లేదా?

దీనికి ప్రత్యేక పద్ధతులు కూడా ఉన్నాయి. మీరు ఫైల్ పొడవును కూడా సులభంగా కనుగొనవచ్చు:

Files.isRegularFile(Path.of("c:\\readme.txt"));

true

Files.isDirectory(Path.of("c:\\test"));

true

 Files.exists(Path.of("c:\\test\\1\\2\\3"));

false

Files.size(Path.of("c:\\readme.txt"));

10112

5. ఫైల్ విషయాలతో పని చేయడం

చివరగా, ఫైల్ యొక్క కంటెంట్‌లను చదవడం లేదా వ్రాయడం సులభం చేసే మొత్తం శ్రేణి పద్ధతులు ఉన్నాయి. ఉదాహరణ:

Path path = Path.of("c:\\readme.txt");
List<String> list = Files.readAllLines(path);

for (String str : list)
   System.out.println(str);

6. డైరెక్టరీ యొక్క కంటెంట్‌లను పొందడం

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

newDirectoryStream()మేము ఒక ప్రత్యేక వస్తువును తిరిగి ఇచ్చే పద్ధతి గురించి మాట్లాడుతున్నాము DirectoryStream<Path>. ఇది ఇచ్చిన డైరెక్టరీ యొక్క అన్ని ఫైల్‌లు మరియు సబ్ డైరెక్టరీలను పొందడానికి మీరు ఉపయోగించగల ఇటరేటర్(!)ని కలిగి ఉంది.

ఇది ధ్వనించే దానికంటే సులభం.

Path path = Path.of("c:\\windows");

try (DirectoryStream<Path> files = Files.newDirectoryStream(path)) {
   for (Path path : files)
      System.out.println(path);
}

వస్తువుకు DirectoryStream<Path>రెండు లక్షణాలు ఉన్నాయి. ముందుగా, ఇది ఫైల్ పాత్‌లను తిరిగి ఇచ్చే ఇటరేటర్‌ని కలిగి ఉంది మరియు మనం ఈ వస్తువును లూప్‌లో ఉపయోగించవచ్చు for-each.

మరియు రెండవది, ఈ ఆబ్జెక్ట్ ఒక డేటా స్ట్రీమ్, కాబట్టి ఇది పద్ధతిని ఉపయోగించి స్పష్టంగా మూసివేయబడాలి close()లేదా try-with-resourcesబ్లాక్ లోపల వినియోగాన్ని ప్రకటించాలి.

7. Files.newInputStreamపద్ధతి

జావా 5తో ప్రారంభించి, FileInputStreamమరియు FileOutputStreamతరగతులు నిలిపివేయబడ్డాయి. వారి ప్రతికూలతలలో ఒకటి ఏమిటంటే, ఈ తరగతుల వస్తువులు సృష్టించబడినప్పుడు, ఫైల్‌లు వెంటనే డిస్క్‌లో సృష్టించబడతాయి. మరియు ఫైల్ సృష్టికి సంబంధించిన అన్ని మినహాయింపులు సంభావ్యంగా విసిరివేయబడతాయి.

తరువాత ఇది ఉత్తమ నిర్ణయం కాదని గుర్తించబడింది. java.nio.Filesదీని ప్రకారం, ఫైల్ ఆబ్జెక్ట్‌లను రూపొందించడానికి యుటిలిటీ క్లాస్ యొక్క పద్ధతులను ఉపయోగించమని సిఫార్సు చేయబడింది .

ఫైల్‌లను రూపొందించడానికి పాత విధానం మరియు కొత్త విధానం మధ్య పోలిక ఇక్కడ ఉంది:

String src = "c:\\projects\\log.txt";
InputStream input = new FileInputStream(src);

String src = "c:\\projects\\log.txt";
InputStream input = Files.newInputStream( Path.of(src) );

మరియు దీని కోసం ఇదే విధమైన ప్రత్యామ్నాయం ఉంది FileOutputStream:

String src = "c:\\projects\\log.txt";
OutputStream  output = new FileOutputStream( src );

String src = "c:\\projects\\log.txt";
OutputStream  output = Files.newOutputStream( Path.of( src ) );