CodeGym /జావా బ్లాగ్ /యాదృచ్ఛికంగా /జావా ఫైల్స్, పాత్

స్థాయి

San Francisco

21 July 2023
230 views
0 comments

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

హాయ్! ఈ రోజు మనం ఫైళ్లు మరియు డైరెక్టరీలతో పని చేయడం గురించి మాట్లాడుతాము. ఫైల్ కంటెంట్‌లను ఎలా నిర్వహించాలో మీకు ఇప్పటికే తెలుసు: మేము దీనికి చాలా పాఠాలను అంకితం చేసాము :) ఈ ప్రయోజనాల కోసం ఉపయోగించిన కొన్ని తరగతులను గుర్తుంచుకోవడం మీకు సులభం అని నేను భావిస్తున్నాను. నేటి పాఠంలో, మేము ఫైల్ నిర్వహణ గురించి ప్రత్యేకంగా మాట్లాడుతాము: సృష్టించడం, పేరు మార్చడం మొదలైనవి. జావా 7కి ముందు, అటువంటి అన్ని కార్యకలాపాలు ఫైల్ క్లాస్‌ని ఉపయోగించి నిర్వహించబడ్డాయి . మీరు దాని గురించి ఇక్కడ చదువుకోవచ్చు . కానీ Java 7లో, భాష యొక్క సృష్టికర్తలు మేము ఫైల్‌లు మరియు డైరెక్టరీలతో ఎలా పని చేయాలో మార్చాలని నిర్ణయించుకున్నారు. ఫైల్ క్లాస్‌లో అనేక లోపాలు ఉన్నందున ఇది జరిగింది . ఉదాహరణకు, ఇది కాపీ() పద్ధతిని కలిగి లేదు , ఇది ఫైల్‌ను ఒక స్థానం నుండి మరొక ప్రదేశానికి కాపీ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది (అకారణంగా అవసరమైన సామర్థ్యం). అదనంగా, దిఫైల్ క్లాస్ బూలియన్ విలువలను అందించే చాలా కొన్ని పద్ధతులను కలిగి ఉంది . లోపం ఉన్నప్పుడు, అటువంటి పద్ధతి తప్పుగా తిరిగి వస్తుంది. ఇది మినహాయింపును త్రోసివేయదు, లోపాలను గుర్తించడం మరియు వాటి కారణాలను నిర్ధారించడం చాలా కష్టం. సింగిల్ ఫైల్ క్లాస్ స్థానంలో , 3 తరగతులు కనిపించాయి: మార్గాలు , మార్గం , మరియు ఫైల్స్ . బాగా, ఖచ్చితంగా చెప్పాలంటే, పాత్ అనేది ఇంటర్‌ఫేస్, క్లాస్ కాదు. అవి ఒకదానికొకటి ఎలా భిన్నంగా ఉంటాయి మరియు వాటిలో ప్రతి ఒక్కటి మనకు ఎందుకు అవసరమో తెలుసుకుందాం. సరళమైన వాటితో ప్రారంభిద్దాం: మార్గాలు .

మార్గాలు

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


import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

   public static void main(String[] args) {

       Path testFilePath = Paths.get("C:\\Users\\Username\\Desktop\\testFile.txt");
   }
}

అత్యంత క్లిష్టమైన తరగతి కాదు, సరియైనదా? :) బాగా, మేము ఈ పాత్ రకాన్ని కూడా పొందాము. మార్గం అంటే ఏమిటి మరియు అది ఎందుకు అవసరమో తెలుసుకుందాం :)

మార్గం

మార్గం , మరియు పెద్దది, ఫైల్ క్లాస్ యొక్క పునఃరూపకల్పన చేయబడిన అనలాగ్ . ఫైల్ కంటే పని చేయడం చాలా సులభం . మొదట , అనేక యుటిలిటీ (స్టాటిక్) పద్ధతులు తీసివేయబడ్డాయి మరియు ఫైల్స్ తరగతికి తరలించబడ్డాయి. రెండవది , పాత్ ఇంటర్‌ఫేస్ పద్ధతుల రిటర్న్ విలువలపై ఆర్డర్ విధించబడింది . ఫైల్ క్లాస్‌లో , పద్ధతులు స్ట్రింగ్ , లేదా బూలియన్ లేదా ఫైల్‌ని అందించాయి . దాన్ని గుర్తించడం అంత సులభం కాదు. ఉదాహరణకు, ప్రస్తుత ఫైల్ యొక్క పేరెంట్ పాత్‌ను సూచించే స్ట్రింగ్‌ను అందించిన getParent() పద్ధతి ఉంది. కానీ అక్కడ కూడా ఉందిgetParentFile() పద్ధతి, ఇది ఫైల్ ఆబ్జెక్ట్ రూపంలో అదే విషయాన్ని తిరిగి ఇచ్చింది! ఇది స్పష్టంగా అనవసరమైనది. దీని ప్రకారం, పాత్ ఇంటర్‌ఫేస్‌లో, getParent() పద్ధతి మరియు ఫైల్‌లతో పని చేసే ఇతర పద్ధతులు కేవలం పాత్ ఆబ్జెక్ట్‌ను తిరిగి అందిస్తాయి. ఎంపికల కుప్ప లేదు - ప్రతిదీ సులభం మరియు సులభం. మార్గంలో ఉన్న కొన్ని ఉపయోగకరమైన పద్ధతులు ఏమిటి ? వాటిలో కొన్ని మరియు అవి ఎలా పని చేస్తాయో ఉదాహరణలు ఇక్కడ ఉన్నాయి:

getFileName() : మార్గం నుండి ఫైల్ పేరును అందిస్తుంది;
getParent() : ప్రస్తుత మార్గం యొక్క "పేరెంట్" డైరెక్టరీని అందిస్తుంది (ఇతర మాటలలో, డైరెక్టరీ ట్రీలో వెంటనే పైన ఉన్న డైరెక్టరీ);
getRoot() : "రూట్" డైరెక్టరీని అందిస్తుంది, అనగా డైరెక్టరీ ట్రీ ఎగువన ఉన్న డైరెక్టరీ;
startsWith() , endsWith() : పాత్ పాస్ పాత్‌తో మొదలవుతుందా/ముగుతుందా అని తనిఖీ చేయండి:
```
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

   public static void main(String[] args) {

       Path testFilePath = Paths.get("C:\\Users\\Username\\Desktop\\testFile.txt");

       Path fileName = testFilePath.getFileName();
       System.out.println(fileName);

       Path parent = testFilePath.getParent();
       System.out.println(parent);

       Path root = testFilePath.getRoot();
       System.out.println(root);

       boolean endWithTxt = testFilePath.endsWith("Desktop\\testFile.txt");
       System.out.println(endWithTxt);

       boolean startsWithLalala = testFilePath.startsWith("lalalala");
       System.out.println(startsWithLalala);
   }
}
```
కన్సోల్ అవుట్‌పుట్:
```
testFile.txt
C:\Users\Username\Desktop
C:\
true
false
```
endsWith() పద్ధతి ఎలా పనిచేస్తుందనే దానిపై శ్రద్ధ వహించండి . ఇది ప్రస్తుత మార్గం పాస్ పాత్‌తో ముగుస్తుందో లేదో తనిఖీ చేస్తుంది . ప్రత్యేకంగా, అది పాత్‌లో ఉందా , పాస్ చేసిన స్ట్రింగ్‌లో కాదు .

ఈ రెండు కాల్‌ల ఫలితాలను సరిపోల్చండి:
```
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

   public static void main(String[] args) {

       Path testFilePath = Paths.get("C:\\Users\\Username\\Desktop\\testFile.txt");

       System.out.println(testFilePath.endsWith("estFile.txt"));
       System.out.println(testFilePath.endsWith("Desktop\\testFile.txt"));
   }
}
```
కన్సోల్ అవుట్‌పుట్:
```
false
true
```
EndsWith () పద్ధతిని కేవలం అక్షరాల సమితి మాత్రమే కాకుండా నిజమైన మార్గాన్ని తప్పక పాస్ చేయాలి: లేకుంటే, ప్రస్తుత మార్గం నిజంగా ఆ అక్షరాల శ్రేణితో ముగిసినప్పటికీ ("estFile.txt మాదిరిగానే) ఫలితం ఎల్లప్పుడూ తప్పుగా ఉంటుంది. "పై ఉదాహరణలో).

అదనంగా, మార్గం సంపూర్ణ (పూర్తి) మరియు సంబంధిత మార్గాలతో పనిని సులభతరం చేసే పద్ధతుల సమూహాన్ని కలిగి ఉంది .

ఈ పద్ధతులను చూద్దాం:

ప్రస్తుత మార్గం సంపూర్ణమైనట్లయితే boolean isAbsolute() నిజమని చూపుతుంది:


import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

   public static void main(String[] args) {

       Path testFilePath = Paths.get("C:\\Users\\Username\\Desktop\\testFile.txt");

       System.out.println(testFilePath.isAbsolute());
   }
}

కన్సోల్ అవుట్‌పుట్:


true

మార్గం సాధారణీకరణ() : ప్రస్తుత మార్గాన్ని "సాధారణీకరించడం", దాని నుండి అనవసరమైన అంశాలను తొలగిస్తుంది. జనాదరణ పొందిన ఆపరేటింగ్ సిస్టమ్‌లలో చిహ్నాలు "." అని మీకు తెలిసి ఉండవచ్చు. (ప్రస్తుత డైరెక్టరీ) మరియు ".." (పేరెంట్ డైరెక్టరీ) తరచుగా మార్గాలను సూచించడానికి ఉపయోగిస్తారు. ఉదాహరణకు, " ./Pictures/dog.jpg " అంటే ప్రస్తుత డైరెక్టరీలో "పిక్చర్స్" ఫోల్డర్ ఉంది, దానిలో "dog.jpg" ఫైల్ ఉంటుంది.

ఇక్కడ చూడండి. ఒక మార్గం ""ని ఉపయోగిస్తే లేదా ".." మీ ప్రోగ్రామ్‌లో కనిపిస్తుంది, సాధారణీకరణ() పద్ధతి వాటిని తీసివేస్తుంది మరియు వాటిని కలిగి లేని మార్గాన్ని ఉత్పత్తి చేస్తుంది:
```
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

   public static void main(String[] args) {

      
       Path path5 = Paths.get("C:\\Users\\Java\\.\\examples");
      
       System.out.println(path5.normalize());
      
       Path path6 = Paths.get("C:\\Users\\Java\\..\\examples");
       System.out.println(path6.normalize());
   }
}
```
కన్సోల్ అవుట్‌పుట్:
```
C:\Users\Java\examples
C:\Users\examples
```

పాత్ రిలేటివైజ్() : కరెంట్ మరియు పాస్ పాత్ మధ్య సాపేక్ష మార్గాన్ని గణిస్తుంది.

ఉదాహరణకి:


import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

   public static void main(String[] args) {

       Path testFilePath1 = Paths.get("C:\\Users\\Users\\Users\\Users");
       Path testFilePath2 = Paths.get("C:\\Users\\Users\\Users\\Users\\Username\\Desktop\\testFile.txt");

       System.out.println(testFilePath1.relativize(testFilePath2));
   }
}

కన్సోల్ అవుట్‌పుట్:


Username\Desktop\testFile.txt

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

ఫైళ్లు

ఫైల్స్ అనేది ఫైల్ క్లాస్ నుండి తీసిన స్టాటిక్ పద్ధతులను కలిగి ఉండే యుటిలిటీ క్లాస్. ఫైల్‌లు శ్రేణులు లేదా సేకరణలతో పోల్చవచ్చు. తేడా ఏమిటంటే ఇది ఫైల్‌లతో పనిచేస్తుంది, శ్రేణులు లేదా సేకరణలతో కాదు :) ఇది ఫైల్‌లు మరియు డైరెక్టరీలను నిర్వహించడంపై దృష్టి పెడుతుంది. ఫైల్స్ క్లాస్ యొక్క స్టాటిక్ పద్ధతులను ఉపయోగించి, మేము ఫైల్‌లు మరియు డైరెక్టరీలను సృష్టించవచ్చు, తొలగించవచ్చు మరియు తరలించవచ్చు. ఈ కార్యకలాపాలు createFile() (డైరెక్టరీల కోసం, createDirectory() ), move() , మరియు delete() పద్ధతులనుఉపయోగించి నిర్వహించబడతాయివాటిని ఎలా ఉపయోగించాలో ఇక్కడ ఉంది:


import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

public class Main {

   public static void main(String[] args) throws IOException {

       // Create a file
       Path testFile1 = Files.createFile(Paths.get("C:\\Users\\Username\\Desktop\\testFile111.txt"));
       System.out.println("Was the file created successfully?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testFile111.txt")));

       // Create a directory
       Path testDirectory = Files.createDirectory(Paths.get("C:\\Users\\Username\\Desktop\\testDirectory"));
       System.out.println("Was the directory created successfully?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testDirectory")));

       // Move the file from the desktop to the testDirectory directory. When you move a folder, you need to indicate its name in the folder!
       testFile1 = Files.move(testFile1, Paths.get("C:\\Users\\Username\\Desktop\\testDirectory\\testFile111.txt"), REPLACE_EXISTING);

       System.out.println("Did our file remain on the desktop?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testFile111.txt")));

       System.out.println("Has our file been moved to testDirectory?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testDirectory\\testFile111.txt")));

       // Delete a file
       Files.delete(testFile1);
       System.out.println("Does the file still exist?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testDirectory\\testFile111.txt")));
   }
}

ఇక్కడ మనం ముందుగా డెస్క్‌టాప్‌లో ఫైల్‌ను ( Files.createFile() పద్ధతి) క్రియేట్ చేస్తాము. అప్పుడు మేము అదే ప్రదేశంలో ఫోల్డర్‌ను సృష్టిస్తాము ( Files.createDirectory() పద్ధతి). ఆ తరువాత, మేము ఫైల్ ( Files.move () పద్ధతి) ను డెస్క్‌టాప్ నుండి ఈ కొత్త ఫోల్డర్‌కి తరలించి, చివరకు ఫైల్‌ను తొలగిస్తాము ( Files.delete() పద్ధతి). కన్సోల్ అవుట్‌పుట్:


Was the file created successfully? 
true 
Was the directory created successfully? 
true
Did our file remain on the desktop? 
false 
Has our file been moved to testDirectory? 
true 
Does the file still exist? 
false

గమనిక:ఇంటర్ఫేస్ యొక్క పద్ధతుల వలె Path, తరగతి యొక్క అనేక పద్ధతులు వస్తువును Filesతిరిగి అందిస్తాయిPath . తరగతి యొక్క చాలా పద్ధతులు వస్తువులను ఇన్‌పుట్‌లుగా Filesకూడా తీసుకుంటాయి . Pathఇక్కడ Paths.get()పద్ధతి మీ నమ్మకమైన సహాయకుడిగా ఉంటుంది - దీన్ని బాగా ఉపయోగించుకోండి. ఇంకా ఏమి ఆసక్తికరంగా ఉంది Files? పాత Fileతరగతికి నిజంగా లోపించినది ఒక copy()పద్ధతి! మేము ఈ పాఠం ప్రారంభంలో దాని గురించి మాట్లాడాము. ఇప్పుడు అది కలిసే సమయం!


import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

public class Main {

   public static void main(String[] args) throws IOException {

       // Create a file
       Path testFile1 = Files.createFile(Paths.get("C:\\Users\\Username\\Desktop\\testFile111.txt"));
       System.out.println("Was the file created successfully?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testFile111.txt")));

       // Create a directory
       Path testDirectory2 = Files.createDirectory(Paths.get("C:\\Users\\Username\\Desktop\\testDirectory2"));
       System.out.println("Was the directory created successfully?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testDirectory2")));

       // Copy the file from the desktop to the testDirectory2 directory.
       testFile1 = Files.copy(testFile1, Paths.get("C:\\Users\\Username\\Desktop\\testDirectory2\\testFile111.txt"), REPLACE_EXISTING);

       System.out.println("Did our file remain on the desktop?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testFile111.txt")));

       System.out.println("Was our file copied to testDirectory?");
       System.out.println(Files.exists(Paths.get("C:\\Users\\Username\\Desktop\\testDirectory2\\testFile111.txt")));
   }
}

కన్సోల్ అవుట్‌పుట్:


Was the file created successfully? 
true 
Was the directory created successfully? 
true 
Did our file remain on the desktop? 
true 
Was our file copied to testDirectory? 
true

ఫైల్‌లను ప్రోగ్రామాటిక్‌గా ఎలా కాపీ చేయాలో ఇప్పుడు మీకు తెలుసు! :) వాస్తవానికి, Filesక్లాస్ ఫైల్‌ను నిర్వహించడమే కాకుండా, దాని కంటెంట్‌లతో పని చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇది write()ఫైల్‌కు డేటాను వ్రాయడానికి మరియు డేటాను చదవడానికి మొత్తం 3 పద్ధతులను కలిగి ఉంది: read(), readAllBytes(), మరియు readAllLines() మేము చివరిదానిపై వివరంగా నివసిస్తాము. అది ఎందుకు? ఎందుకంటే ఇది చాలా ఆసక్తికరమైన రిటర్న్ రకాన్ని కలిగి ఉంది: List<String>! అంటే, ఇది ఫైల్‌లోని అన్ని లైన్‌ల జాబితాను మాకు అందిస్తుంది. forవాస్తవానికి, ఇది ఫైల్ విషయాలతో పని చేయడం చాలా సౌకర్యవంతంగా ఉంటుంది, ఎందుకంటే మొత్తం ఫైల్, లైన్ ద్వారా లైన్, ఉదాహరణకు, ఒక సాధారణ లూప్ ఉపయోగించి కన్సోల్‌లో ప్రదర్శించబడుతుంది:


import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

import static java.nio.charset.StandardCharsets.UTF_8;

public class Main {

   public static void main(String[] args) throws IOException {

       List<String> lines = Files.readAllLines(Paths.get("C:\\Users\\Username\\Desktop\\pushkin.txt"), UTF_8);

       for (String s: lines) {
           System.out.println(s);
       }
   }
}

కన్సోల్ అవుట్‌పుట్:


I still recall the wondrous moment: 
When you appeared before my sight, 
As though a brief and fleeting omen, 
Pure phantom in enchanting light.

సూపర్ అనుకూలమైనది! :) ఈ సామర్థ్యం జావా 7లో కనిపించింది. స్ట్రీమ్ API జావా 8లో కనిపించింది. ఇది జావాకు ఫంక్షనల్ ప్రోగ్రామింగ్‌లోని కొన్ని అంశాలను జోడిస్తుంది. రిచ్ ఫైల్ హ్యాండ్లింగ్ సామర్థ్యాలతో సహా. మనకు ఈ క్రింది పని ఉందని ఊహించండి: "అలా" అనే పదంతో ప్రారంభమయ్యే అన్ని పంక్తులను కనుగొని, వాటిని UPPERCASEకి మార్చండి మరియు వాటిని కన్సోల్‌లో ప్రదర్శించండి. జావా 7లో క్లాస్‌ని ఉపయోగించే పరిష్కారం ఎలా ఉంటుంది Files? ఇలాంటిది ఏదైనా:


import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

import static java.nio.charset.StandardCharsets.UTF_8;

public class Main {

   public static void main(String[] args) throws IOException {

       List<String> lines = Files.readAllLines(Paths.get("C:\\Users\\Username\\Desktop\\pushkin.txt"), UTF_8);

       List<String> result = new ArrayList<>();

       for (String s: lines) {
           if (s.startsWith("As")) {
               String upper = s.toUpperCase();
               result.add(upper);
           }
       }

       for (String s: result) {
           System.out.println(s);
       }
   }
}

కన్సోల్ అవుట్‌పుట్:


AS THOUGH A BRIEF AND FLEETING OMEN, 
PURE PHANTOM IN ENCHANTING LIGHT.

లక్ష్యం పూర్తయింది, కానీ ఇంత సులభమైన పని కోసం మా కోడ్ కొద్దిగా... వెర్బోస్‌గా మారిందని మీరు అనుకోలేదా? Java 8 యొక్క Stream APIని ఉపయోగించి, పరిష్కారం చాలా సొగసైనదిగా కనిపిస్తుంది:


import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

   public static void main(String[] args) throws IOException {

       Stream<String> stream = Files.lines(Paths.get("C:\\Users\\Username\\Desktop\\pushkin.txt"));

       List<String> result  = stream
               .filter(line -> line.startsWith("As"))
               .map(String::toUpperCase)
               .collect(Collectors.toList());
       result.forEach(System.out::println);
   }
}

మేము అదే ఫలితాన్ని సాధించాము, కానీ చాలా తక్కువ కోడ్‌తో! పైగా, మనం "చదువుకునే సౌలభ్యం" కోల్పోయామని ఎవరూ చెప్పలేరు. Stream API గురించి తెలియకపోయినా, ఈ కోడ్ ఏమి చేస్తుందో మీరు సులభంగా వ్యాఖ్యానించవచ్చని నేను భావిస్తున్నాను. సంక్షిప్తంగా, స్ట్రీమ్ అనేది మూలకాల శ్రేణి, దానిపై మీరు వివిధ కార్యకలాపాలను చేయవచ్చు. మేము పద్ధతి నుండి స్ట్రీమ్ ఆబ్జెక్ట్‌ను పొందుతాము Files.lines(), ఆపై దానికి 3 ఫంక్షన్‌లను వర్తింపజేస్తాము:

filter()ఫైల్ నుండి "As"తో ప్రారంభమయ్యే పంక్తులను మాత్రమే ఎంచుకోవడానికి మేము పద్ధతిని ఉపయోగిస్తాము .
మేము పద్ధతిని ఉపయోగించి ఎంచుకున్న అన్ని లైన్ల ద్వారా నడుస్తాము map()మరియు వాటిలో ప్రతి ఒక్కటి UPPERCASEకి మారుస్తాము.
collect()అందుకున్న పంక్తులన్నింటినీ a లోకి సేకరించడానికి మేము పద్ధతిని ఉపయోగిస్తాము List.

మేము అదే అవుట్‌పుట్‌ని పొందుతాము:


AS THOUGH A BRIEF AND FLEETING OMEN, 
PURE PHANTOM IN ENCHANTING LIGHT.

ఇప్పుడు మన బ్రెడ్ మరియు వెన్నకి తిరిగి వెళ్దాం, అంటే ఫైల్స్ :) ఈరోజు మనం పరిగణించే చివరి సామర్థ్యం ఫైల్ ట్రీ గుండా నడవడం . ఆధునిక ఆపరేటింగ్ సిస్టమ్‌లలో, ఫైల్ నిర్మాణం చాలా తరచుగా చెట్టులా కనిపిస్తుంది: దీనికి రూట్ ఉంది మరియు శాఖలు ఉన్నాయి, ఇతర శాఖలను కలిగి ఉంటాయి, మొదలైనవి రూట్ మరియు శాఖలు డైరెక్టరీలు. ఉదాహరణకు, డైరెక్టరీ " С:// " రూట్ కావచ్చు. ఇందులో రెండు శాఖలు ఉన్నాయి: " C://డౌన్‌లోడ్‌లు " మరియు " C://యూజర్లు ". ఈ శాఖలలో ప్రతిదానికి రెండు శాఖలు ఉన్నాయి: " C://Downloads/Pictures ", " C://Downloads/Video ", " C://Users/JohnSmith ", " C://Users/Pudge2005". మరియు ఈ శాఖలు ఇతర శాఖలు మొదలైనవి కలిగి ఉంటాయి మరియు అందుకే మేము దీనిని చెట్టు అని పిలుస్తాము. Linuxలో, నిర్మాణం సారూప్యంగా ఉంటుంది, కానీ / డైరెక్టరీ అనేది ఫైల్స్, పాత్ - 2

రూట్. ఇప్పుడు మనం రూట్ డైరెక్టరీ వద్ద ప్రారంభించాల్సిన అవసరం ఉందని ఊహించండి. , దాని అన్ని ఫోల్డర్‌లు మరియు సబ్‌ఫోల్డర్‌ల ద్వారా నడవండి మరియు నిర్దిష్ట కంటెంట్ ఉన్న ఫైల్‌లను కనుగొనండి. "ఇది మనకు అవసరమైన ఫైల్!" మేము "testFolder" ఫోల్డర్‌ని తీసుకుంటాము, అది ఆన్‌లో ఉంటుంది డెస్క్‌టాప్, రూట్ డైరెక్టరీగా ఇక్కడ దాని కంటెంట్‌లు ఉన్నాయి: ఫైల్స్, పాత్ - 3

level1-a మరియు level1-b ఫోల్డర్‌లు కూడా ఫోల్డర్‌లను కలిగి ఉంటాయి: ఫైల్స్, పాత్ - 4

ఈ "రెండవ స్థాయి ఫోల్డర్‌లలో" ఫోల్డర్‌లు లేవు, వ్యక్తిగత ఫైల్‌లు మాత్రమే: ఫైల్స్, పాత్ - 6

మనకు అవసరమైన కంటెంట్‌లతో కూడిన 3 ఫైల్‌లకు ఉద్దేశపూర్వకంగా వివరణాత్మక పేర్లు ఇవ్వబడ్డాయి: FileWeNeed1.txt, FileWeNeed2.txt, FileWeNeed3.txt. జావాను ఉపయోగించి మనం కనుగొనవలసిన ఫైల్‌లు ఇవి. మేము దీన్ని ఎలా చేస్తాము? ఫైల్ ట్రీని దాటడానికి చాలా శక్తివంతమైన పద్ధతి మా సహాయానికి వస్తుంది: Files.walkFileTree (). ఇక్కడ మనం ఏమి చేయాలి. మొదట, మనకు ఒక అవసరం FileVisitor. FileVisitorఅనేది ఒక ప్రత్యేక ఇంటర్‌ఫేస్, దీనిలో ఫైల్ ట్రీని దాటే పద్ధతులు వివరించబడ్డాయి. ప్రత్యేకించి, ఫైల్‌లోని కంటెంట్‌లను చదవడానికి మరియు మనకు అవసరమైన వచనాన్ని కలిగి ఉందో లేదో తనిఖీ చేయడానికి మేము లాజిక్‌ను ఇక్కడ ఉంచుతాము. మా FileVisitorలుక్ ఎలా ఉంది:


import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.List;

public class MyFileVisitor extends SimpleFileVisitor<Path> {

   @Override
   public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {

       List<String> lines = Files.readAllLines(file);
       for (String s: lines) {
           if (s.contains("This is the file we need")) {
               System.out.println("We found a file we need!");
               System.out.println(file.toAbsolutePath());
               break;
           }
       }

       return FileVisitResult.CONTINUE;
   }
}

ఈ సందర్భంలో, మా తరగతి వారసత్వంగా SimpleFileVisitor. ఇది అమలు చేసే తరగతి FileVisitor, దీనిలో మనం కేవలం ఒక పద్ధతిని భర్తీ చేయాలి: visitFile(). ప్రతి డైరెక్టరీలోని ప్రతి ఫైల్‌తో ఏమి చేయాలో ఇక్కడ మేము నిర్వచించాము. ఫైల్ నిర్మాణాన్ని దాటడానికి మీకు మరింత సంక్లిష్టమైన తర్కం అవసరమైతే, మీరు మీ స్వంత అమలును వ్రాయాలి FileVisitor. మీరు ఆ తరగతిలో మరో 3 పద్ధతులను అమలు చేయాలి:

preVisitDirectory(): ఫోల్డర్‌లోకి ప్రవేశించే ముందు అమలు చేయడానికి తర్కం;
visitFileFailed(): ఫైల్‌ను సందర్శించడం సాధ్యం కానట్లయితే అమలు చేయడానికి తర్కం (యాక్సెస్ లేదు, లేదా ఇతర కారణాల వల్ల);
postVisitDirectory(): ఫోల్డర్‌ను నమోదు చేసిన తర్వాత అమలు చేయాల్సిన తర్కం.

మాకు అలాంటి లాజిక్ ఏదీ అమలు చేయాల్సిన అవసరం లేదు, కాబట్టి మేము SimpleFileVisitor. పద్ధతిలోని తర్కం visitFile()చాలా సులభం: ఫైల్‌లోని అన్ని పంక్తులను చదవండి, అవి మనకు అవసరమైన కంటెంట్‌ను కలిగి ఉన్నాయో లేదో తనిఖీ చేయండి మరియు అలా అయితే, కన్సోల్‌లో సంపూర్ణ మార్గాన్ని ముద్రించండి. మీకు ఇబ్బంది కలిగించే ఏకైక లైన్ ఇది:


return FileVisitResult.CONTINUE;

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


return FileVisitResult.TERMINATE;

సరే, మన కోడ్‌ని రన్ చేద్దాం మరియు అది పనిచేస్తుందో లేదో చూద్దాం.


import java.io.IOException;
import java.nio.file.*;

public class Main {

   public static void main(String[] args) throws IOException {

       Files.walkFileTree(Paths.get("C:\\Users\\Username\\Desktop\\testFolder"), new MyFileVisitor());
   }
}

కన్సోల్ అవుట్‌పుట్:


We found a file we need! 
C:\Users\Username\Desktop\testFolder\FileWeNeed1.txt 
We found a file we need! 
C:\Users\Username\Desktop\testFolder\level1-a\level2-a-a\FileWeNeed2.txt 
We found a file we need! 
C:\Users\Username\Desktop\testFolder\level1-b\level2-b-b\FileWeNeed3.txt

అద్భుతమైన! అది పనిచేసింది! :) మీరు ఈ చిన్న సవాలును కూడా అంగీకరించవచ్చు: SimpleFileVisitorసాధారణంతో భర్తీ చేయండి FileVisitor, మొత్తం 4 పద్ధతులను భర్తీ చేయండి మరియు ప్రోగ్రామ్ కోసం మీ స్వంత ప్రయోజనంతో ముందుకు రండి. ఉదాహరణకు, మీరు దాని అన్ని చర్యలను లాగ్ చేసే ప్రోగ్రామ్‌ను వ్రాయవచ్చు: ఫైల్ లేదా ఫోల్డర్ పేరును నమోదు చేయడానికి ముందు లేదా తర్వాత వాటిని ప్రదర్శించండి. ఇప్పటికి ఇంతే. త్వరలో కలుద్దాం! :)

వ్యాఖ్యలు

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION