ஜாவா கோப்புகள், பாதை

வணக்கம்! இன்று நாம் கோப்புகள் மற்றும் கோப்பகங்களுடன் பணிபுரிவது பற்றி பேசுவோம். கோப்பு உள்ளடக்கங்களை எவ்வாறு நிர்வகிப்பது என்பது உங்களுக்கு ஏற்கனவே தெரியும்: இதற்கு நாங்கள் நிறைய பாடங்களை அர்ப்பணித்துள்ளோம் :) இந்த நோக்கங்களுக்காகப் பயன்படுத்தப்படும் சில வகுப்புகளை நினைவில் கொள்வது உங்களுக்கு எளிதாக இருக்கும் என்று நினைக்கிறேன். இன்றைய பாடத்தில், கோப்பு மேலாண்மை பற்றி குறிப்பாக பேசுவோம்: உருவாக்குதல், மறுபெயரிடுதல் போன்றவை. Java 7 க்கு முன், அத்தகைய செயல்பாடுகள் அனைத்தும் கோப்பு வகுப்பைப் பயன்படுத்தி செய்யப்பட்டன . அதைப் பற்றி இங்கே படிக்கலாம் . ஆனால் ஜாவா 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() : "root" கோப்பகத்தை வழங்குகிறது, அதாவது அடைவு மரத்தின் மேல் உள்ள அடைவு;

• 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

• Path normalize() : தற்போதைய பாதையை "சாதாரணமாக்குகிறது", அதிலிருந்து தேவையற்ற கூறுகளை நீக்குகிறது. பிரபலமான இயக்க முறைமைகளில் "" சின்னங்கள் இருப்பதை நீங்கள் அறிந்திருக்கலாம். (தற்போதைய அடைவு) மற்றும் ".." (பெற்றோர் அடைவு) பெரும்பாலும் பாதைகளைக் குறிக்கப் பயன்படுத்தப்படுகின்றன. எடுத்துக்காட்டாக, " ./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

• பாதை relativize() : மின்னோட்டத்திற்கும் கடந்து செல்லும் பாதைக்கும் இடையே உள்ள தொடர்புடைய பாதையை கணக்கிடுகிறது.

  உதாரணத்திற்கு:

  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() , and 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() method) உருவாக்குகிறோம். பின்னர் அதே இடத்தில் ஒரு கோப்புறையை உருவாக்குகிறோம் ( Files.createDirectory() method). அதன் பிறகு, டெஸ்க்டாப்பில் இருந்து கோப்பை ( Files.move() முறை) இந்த புதிய கோப்புறைக்கு நகர்த்துகிறோம் , இறுதியாக கோப்பை நீக்குகிறோம் ( Files.delete() method). கன்சோல் வெளியீடு:

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 இல் தோன்றியது. ஸ்ட்ரீம் ஏபிஐ ஜாவா 8 இல் தோன்றியது. இது ஜாவாவில் செயல்பாட்டு நிரலாக்கத்தின் சில கூறுகளை சேர்க்கிறது. பணக்கார கோப்பு கையாளும் திறன்கள் உட்பட. எங்களிடம் பின்வரும் பணி உள்ளது என்று கற்பனை செய்து பாருங்கள்: "As" என்ற வார்த்தையுடன் தொடங்கும் அனைத்து வரிகளையும் கண்டுபிடித்து, அவற்றை UPPERCASE ஆக மாற்றி, அவற்றை கன்சோலில் காண்பிக்கவும். Filesஜாவா 7 இல் வகுப்பைப் பயன்படுத்தும் தீர்வு எப்படி இருக்கும் ? இந்த மாதிரி ஏதாவது:

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 இன் ஸ்ட்ரீம் 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);
   }
}

நாங்கள் அதே முடிவை அடைந்தோம், ஆனால் மிகவும் குறைவான குறியீட்டுடன்! இன்னும் சொல்லப்போனால், "படிக்கக்கூடிய தன்மையை" இழந்துவிட்டோம் என்று யாரும் சொல்ல முடியாது. ஸ்ட்ரீம் ஏபிஐ பற்றித் தெரியாமல், இந்தக் குறியீடு என்ன செய்கிறது என்பதைப் பற்றி நீங்கள் எளிதாகக் கருத்துத் தெரிவிக்கலாம் என்று நினைக்கிறேன். சுருக்கமாக, ஸ்ட்ரீம் என்பது உறுப்புகளின் வரிசையாகும், அதன் மீது நீங்கள் பல்வேறு செயல்பாடுகளைச் செய்யலாம். முறையிலிருந்து ஸ்ட்ரீம் பொருளைப் பெறுகிறோம் Files.lines(), பின்னர் அதற்கு 3 செயல்பாடுகளைப் பயன்படுத்துகிறோம்:

1. filter()"As" என்று தொடங்கும் கோப்பிலிருந்து அந்த வரிகளை மட்டும் தேர்ந்தெடுக்கும் முறையைப் பயன்படுத்துகிறோம் .

2. முறையைப் பயன்படுத்தி தேர்ந்தெடுக்கப்பட்ட அனைத்து வரிகளிலும் நடந்து map(), அவை ஒவ்வொன்றையும் மேல்புறமாக மாற்றுவோம்.

3. collect()பெறப்பட்ட அனைத்து வரிகளையும் a இல் சேகரிக்க நாங்கள் முறையைப் பயன்படுத்துகிறோம் List.

நாங்கள் அதே வெளியீட்டைப் பெறுகிறோம்:

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

இப்போது நம் ரொட்டி மற்றும் வெண்ணெய்க்கு திரும்புவோம், அதாவது கோப்புகள் :) இன்று நாம் கருத்தில் கொள்ளக்கூடிய கடைசி திறன் ஒரு கோப்பு மரத்தின் வழியாக நடப்பது . நவீன இயக்க முறைமைகளில், கோப்பு அமைப்பு பெரும்பாலும் ஒரு மரத்தைப் போலவே தோன்றுகிறது: அதற்கு ஒரு வேர் உள்ளது மற்றும் கிளைகள் உள்ளன, அவை மற்ற கிளைகளைக் கொண்டிருக்கலாம், முதலியன ரூட் மற்றும் கிளைகள் அடைவுகள். எடுத்துக்காட்டாக, " С:// " கோப்பகம் ரூட்டாக இருக்கலாம். இது இரண்டு கிளைகளை உள்ளடக்கியது: " C://Downloads " மற்றும் " C://Users ". இந்தக் கிளைகள் ஒவ்வொன்றிலும் இரண்டு கிளைகள் உள்ளன: " C://Downloads/Pictures ", " C://Downloads/Video ", " C://Users/JohnSmith ", " C://Users/Pudge2005". மேலும் இந்த கிளைகளில் மற்ற கிளைகள் உள்ளன, அதனால்தான் இதை மரம் என்று அழைக்கிறோம். லினக்ஸில், அமைப்பு ஒத்திருக்கிறது, ஆனால் / அடைவு என்பது ரூட். இப்போது நாம் ரூட் கோப்பகத்தில் தொடங்க வேண்டும் என்று கற்பனை செய்து பாருங்கள். , அதன் அனைத்து கோப்புறைகள் மற்றும் துணை கோப்புறைகள் வழியாக சென்று, சில குறிப்பிட்ட உள்ளடக்கங்களைக் கொண்ட கோப்புகளைக் கண்டறியவும். "இது நமக்குத் தேவையான கோப்பு!" என்ற வரியைக் கொண்ட கோப்புகளைத் தேடுவோம், "testFolder" கோப்புறையை எடுத்துக்கொள்வோம். டெஸ்க்டாப், ரூட் கோப்பகமாக, அதன் உள்ளடக்கங்கள் இங்கே உள்ளன: level1-a மற்றும் level1-b கோப்புறைகளிலும் கோப்புறைகள் உள்ளன: இந்த "இரண்டாம் நிலை கோப்புறைகளில்" கோப்புறைகள் இல்லை, தனிப்பட்ட கோப்புகள் மட்டுமே: நமக்குத் தேவையான உள்ளடக்கங்களைக் கொண்ட 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 முறைகளையும் மேலெழுதவும் மற்றும் நிரலுக்கான உங்கள் சொந்த நோக்கத்தைக் கொண்டு வரவும். எடுத்துக்காட்டாக, அதன் அனைத்து செயல்களையும் பதிவுசெய்யும் ஒரு நிரலை நீங்கள் எழுதலாம்: கோப்பு அல்லது கோப்புறையின் பெயரை உள்ளிடுவதற்கு முன் அல்லது பின் காண்பிக்கவும். இப்பொழுது இத்துடன் நிறைவடைகிறது. விரைவில் சந்திப்போம்! :)