एक निर्देशिका से सभी फ़ाइलों को जावा के साथ पुनरावर्ती सूची दें

Question 1

मेरे पास यह फ़ंक्शन है जो एक निर्देशिका में सभी फ़ाइलों के नाम को पुनरावर्ती रूप से प्रिंट करता है। समस्या यह है कि मेरा कोड बहुत धीमा है क्योंकि इसमें हर पुनरावृत्ति के साथ एक दूरस्थ नेटवर्क डिवाइस का उपयोग करना है।

मेरी योजना पहले निर्देशिका से सभी फ़ाइलों को पुनरावर्ती रूप से लोड करने की है और उसके बाद सभी फ़ाइलों के माध्यम से जाने के लिए regex के साथ उन सभी फ़ाइलों को फ़िल्टर करना है जो मुझे नहीं चाहिए। क्या किसी के पास बेहतर सुझाव है?

public static printFnames(String sDir){
  File[] faFiles = new File(sDir).listFiles();
  for(File file: faFiles){
    if(file.getName().matches("^(.*?)")){
      System.out.println(file.getAbsolutePath());
    }
    if(file.isDirectory()){
      printFnames(file.getAbsolutePath());
    }
  }
}

यह सिर्फ एक परीक्षण है बाद में मैं इस तरह कोड का उपयोग नहीं करने जा रहा हूं, इसके बजाय मैं हर फ़ाइल का पथ और संशोधन तिथि जोड़ने जा रहा हूं जो कि एक उन्नत रेगेक्स से सरणी में मेल खाता है।

Question 2

मान लें कि यह वास्तविक उत्पादन कोड है जिसे आप लिख रहे हैं, तो मैं इस तरह के समाधान का उपयोग करने का सुझाव देता हूं जो पहले से ही हल हो गया है - Apache Commons IO , विशेष रूप से FileUtils.listFiles()। यह नेस्टेड डायरेक्ट्रीज़, फिल्टर (नाम, संशोधन समय, आदि के आधार पर) को संभालता है।

उदाहरण के लिए, अपने regex के लिए:

Collection files = FileUtils.listFiles(
  dir, 
  new RegexFileFilter("^(.*?)"), 
  DirectoryFileFilter.DIRECTORY
);

यह रीगेक्स से मिलान करने वाली फ़ाइलों की पुन: खोज करेगा ^(.*?), परिणाम को एक संग्रह के रूप में लौटाएगा।

यह ध्यान देने योग्य है कि यह आपके स्वयं के कोड को रोल करने की तुलना में तेज़ नहीं होगा, यह एक ही काम कर रहा है - जावा में एक फाइल सिस्टम को फंसाना सिर्फ धीमा है। अंतर यह है कि, अपाचे कॉमन्स संस्करण में कोई बग नहीं होगा।

Question 3

जावा 8 में, यह एक 1-लाइनर के माध्यम Files.find()से एक मनमाने ढंग से बड़ी गहराई (जैसे 999) और BasicFileAttributesके साथ हैisRegularFile()

public static printFnames(String sDir) {
    Files.find(Paths.get(sDir), 999, (p, bfa) -> bfa.isRegularFile()).forEach(System.out::println);
}

अधिक फ़िल्टरिंग जोड़ने के लिए, लैम्ब्डा को बढ़ाएं, उदाहरण के लिए पिछले 24 घंटों में संशोधित सभी jpg फाइलें:

(p, bfa) -> bfa.isRegularFile()
  && p.getFileName().toString().matches(".*\\.jpg")
  && bfa.lastModifiedTime().toMillis() > System.currentMillis() - 86400000

Question 4

किसी दिए गए रूट से सभी फ़ाइलों को प्राप्त करने के लिए यह एक बहुत ही सरल पुनरावर्ती विधि है।

यह जावा 7 एनआईओ पथ वर्ग का उपयोग करता है।

private List<String> getFileNames(List<String> fileNames, Path dir) {
    try(DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
        for (Path path : stream) {
            if(path.toFile().isDirectory()) {
                getFileNames(fileNames, path);
            } else {
                fileNames.add(path.toAbsolutePath().toString());
                System.out.println(path.getFileName());
            }
        }
    } catch(IOException e) {
        e.printStackTrace();
    }
    return fileNames;
}

Question 5

जावा 7 के साथ निर्देशिका ट्री के माध्यम से चलने का एक तेज़ तरीका Pathsऔर Filesकार्यक्षमता के साथ पेश किया गया था । वे बहुत तेज़ हैं फिर "पुराना" Fileतरीका।

यह एक नियमित अभिव्यक्ति के साथ थ्रू चलने और पथ नामों की जांच करने वाला कोड होगा:

public final void test() throws IOException, InterruptedException {
    final Path rootDir = Paths.get("path to your directory where the walk starts");

    // Walk thru mainDir directory
    Files.walkFileTree(rootDir, new FileVisitor<Path>() {
        // First (minor) speed up. Compile regular expression pattern only one time.
        private Pattern pattern = Pattern.compile("^(.*?)");

        @Override
        public FileVisitResult preVisitDirectory(Path path,
                BasicFileAttributes atts) throws IOException {

            boolean matches = pattern.matcher(path.toString()).matches();

            // TODO: Put here your business logic when matches equals true/false

            return (matches)? FileVisitResult.CONTINUE:FileVisitResult.SKIP_SUBTREE;
        }

        @Override
        public FileVisitResult visitFile(Path path, BasicFileAttributes mainAtts)
                throws IOException {

            boolean matches = pattern.matcher(path.toString()).matches();

            // TODO: Put here your business logic when matches equals true/false

            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path path,
                IOException exc) throws IOException {
            // TODO Auto-generated method stub
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(Path path, IOException exc)
                throws IOException {
            exc.printStackTrace();

            // If the root directory has failed it makes no sense to continue
            return path.equals(rootDir)? FileVisitResult.TERMINATE:FileVisitResult.CONTINUE;
        }
    });
}

Question 6

जावा 7 एनआईओ का उपयोग करके निर्देशिका की सामग्री प्राप्त करने का तेज़ तरीका:

import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.FileSystems;
import java.nio.file.Path;

...

Path dir = FileSystems.getDefault().getPath( filePath );
DirectoryStream<Path> stream = Files.newDirectoryStream( dir );
for (Path path : stream) {
   System.out.println( path.getFileName() );
}
stream.close();

Question 7

फाइलसिस्टम फ़ोल्डर सामग्री पढ़ने के लिए जावा का इंटरफ़ेस बहुत अच्छा नहीं है (जैसा कि आपने खोजा है)। जेडडीके 7 इस तरह की चीज़ के लिए पूरी तरह से नए इंटरफ़ेस के साथ इसे ठीक करता है, जिससे इन प्रकार के संचालन के लिए मूल स्तर का प्रदर्शन होना चाहिए।

मुख्य मुद्दा यह है कि जावा हर एक फाइल के लिए एक देशी सिस्टम कॉल करता है। कम विलंबता इंटरफ़ेस पर, यह सौदे का इतना बड़ा नहीं है - लेकिन यहां तक कि मध्यम विलंबता वाले नेटवर्क पर, यह वास्तव में जोड़ता है। यदि आप अपने एल्गोरिथ्म को ऊपर प्रोफाइल करते हैं, तो आप पाएंगे कि समय का बहुत अधिक हिस्सा pesky में खर्च किया गया है ।Directory () कॉल - ऐसा इसलिए है क्योंकि आप isDirectory () में हर एक कॉल के लिए एक गोल यात्रा कर रहे हैं। अधिकांश आधुनिक OS इस प्रकार की जानकारी प्रदान कर सकते हैं जब फ़ाइलों / फ़ोल्डरों की सूची को मूल रूप से अनुरोध किया गया था (जैसा कि इसके गुणों के लिए प्रत्येक व्यक्तिगत फ़ाइल पथ को क्वेरी करने का विरोध किया गया है)।

यदि आप JDK7 के लिए इंतजार नहीं कर सकते हैं, तो इस विलंबता को संबोधित करने के लिए एक रणनीति बहु-थ्रेडेड जाने और अपनी पुनरावृत्ति करने के लिए अधिकतम # थ्रेड के साथ एक एक्सेकॉर्स सर्विस का उपयोग करना है। यह बहुत अच्छा नहीं है (आपको अपने आउटपुट डेटा स्ट्रक्चर्स को लॉक करना होगा), लेकिन यह सिंगल थ्रेडेड करने की तुलना में बहुत तेज़ होगा।

इस तरह की चीज़ों के बारे में आपकी सभी चर्चाओं में, मैं अत्यधिक अनुशंसा करता हूं कि आप सबसे अच्छे से तुलना कर सकते हैं जो आप देशी कोड (या एक कमांड लाइन स्क्रिप्ट का उपयोग करके कर सकते हैं जो लगभग एक ही बात करता है)। यह कहते हुए कि एक नेटवर्क संरचना को पार करने में एक घंटा लगता है, वास्तव में इसका इतना मतलब नहीं है। हमें यह बताते हुए कि आप इसे 7 सेकंड में देशी कर सकते हैं, लेकिन जावा में एक घंटे का समय लगता है, लोगों का ध्यान आकर्षित होगा।

Question 8

यह ठीक काम करेगा ... और इसके पुनरावर्ती

File root = new File("ROOT PATH");
for ( File file : root.listFiles())
{
    getFilesRecursive(file);
}


private static void getFilesRecursive(File pFile)
{
    for(File files : pFile.listFiles())
    {
        if(files.isDirectory())
        {
            getFilesRecursive(files);
        }
        else
        {
            // do your thing 
            // you can either save in HashMap and use it as
            // per your requirement
        }
    }
}

Question 9

मैं व्यक्तिगत रूप से FileUtils के इस संस्करण को पसंद करता हूं। यहाँ एक उदाहरण है जो सभी mp3s या flacs को एक निर्देशिका या इसके किसी भी उपनिर्देशिका में पाता है:

String[] types = {"mp3", "flac"};
Collection<File> files2 = FileUtils.listFiles(/path/to/your/dir, types , true);

Question 10

यह ठीक काम करेगा

public void displayAll(File path){      
    if(path.isFile()){
        System.out.println(path.getName());
    }else{
        System.out.println(path.getName());         
        File files[] = path.listFiles();
        for(File dirOrFile: files){
            displayAll(dirOrFile);
        }
    }
}

Question 11

यह फ़ंक्शन संभवतः अपनी निर्देशिका और उसके उपनिर्देशिकाओं से सभी फ़ाइल नाम और उसके पथ को सूचीबद्ध करेगा।

public void listFile(String pathname) {
    File f = new File(pathname);
    File[] listfiles = f.listFiles();
    for (int i = 0; i < listfiles.length; i++) {
        if (listfiles[i].isDirectory()) {
            File[] internalFile = listfiles[i].listFiles();
            for (int j = 0; j < internalFile.length; j++) {
                System.out.println(internalFile[j]);
                if (internalFile[j].isDirectory()) {
                    String name = internalFile[j].getAbsolutePath();
                    listFile(name);
                }

            }
        } else {
            System.out.println(listfiles[i]);
        }

    }

}

Question 12

जावा 8

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

        Path start = Paths.get("C:\\data\\");
        try (Stream<Path> stream = Files.walk(start, Integer.MAX_VALUE)) {
            List<String> collect = stream
                .map(String::valueOf)
                .sorted()
                .collect(Collectors.toList());

            collect.forEach(System.out::println);
        }


    }

Question 13

ऐसा लगता है कि यह फाइल सिस्टम तक बेवकूफ़ पहुंच है और एक बार में सब कुछ प्राप्त करने के बजाय हर उपनिर्देशिका के लिए सामग्री प्राप्त करें।

आपकी भावना गलत है। कि फाइलसिस्टम कैसे काम करता है। कोई तेज़ तरीका नहीं है (जब आपको बार-बार या अलग-अलग पैटर्न के लिए ऐसा करना हो, तो आप सभी फ़ाइल पथों को मेमोरी में कैश कर सकते हैं, लेकिन फिर आपको कैश अमान्यता से निपटना होगा अर्थात जब फाइलें जोड़ी जाती हैं / हटा दी जाती हैं / नाम बदल दिया जाता है) ऐप चलता है)।

Question 14

बस आप जानते हैं कि अप्रत्यक्ष () काफी धीमी विधि है। मुझे अपने फ़ाइल ब्राउज़र में यह काफी धीमा लग रहा है। मैं इसे मूल कोड के साथ बदलने के लिए एक पुस्तकालय की तलाश में हूँ।

Question 15

लाखों फ़ोल्डरों और फ़ाइलों से निपटने में मैंने जो अधिक कुशल तरीका पाया, वह यह है कि किसी फाइल में डॉस कमांड के जरिए डायरेक्टरी लिस्टिंग को कैप्चर किया जाए और उसे पार्स किया जाए। एक बार जब आपके पास डेटा पार्स हो जाता है तो आप विश्लेषण कर सकते हैं और आँकड़ों की गणना कर सकते हैं।

Question 16

import java.io.*;

public class MultiFolderReading {

public void checkNoOfFiles (String filename) throws IOException {

    File dir=new File(filename);
    File files[]=dir.listFiles();//files array stores the list of files

 for(int i=0;i<files.length;i++)
    {
        if(files[i].isFile()) //check whether files[i] is file or directory
        {
            System.out.println("File::"+files[i].getName());
            System.out.println();

        }
        else if(files[i].isDirectory())
        {
            System.out.println("Directory::"+files[i].getName());
            System.out.println();
            checkNoOfFiles(files[i].getAbsolutePath());
        }
    }
}

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

    MultiFolderReading mf=new MultiFolderReading();
    String str="E:\\file"; 
    mf.checkNoOfFiles(str);
   }
}

Question 17

अमरूद में आपको एक संग्रह के लिए इंतजार नहीं करना पड़ता है, लेकिन वास्तव में फ़ाइलों पर पुनरावृति कर सकते हैं। IDoSomethingWithThisFileनीचे दिए गए फ़ंक्शन के हस्ताक्षर में एक इंटरफ़ेस की कल्पना करना आसान है :

public static void collectFilesInDir(File dir) {
    TreeTraverser<File> traverser = Files.fileTreeTraverser();
    FluentIterable<File> filesInPostOrder = traverser.preOrderTraversal(dir);
    for (File f: filesInPostOrder)
        System.out.printf("File: %s\n", f.getPath());
}

ट्रीट्रावर्स आपको विभिन्न ट्रैवर्सल शैलियों के बीच की अनुमति देता है।

Question 18

public class GetFilesRecursive {
    public static List <String> getFilesRecursively(File dir){
        List <String> ls = new ArrayList<String>();
        for (File fObj : dir.listFiles()) {
            if(fObj.isDirectory()) {
                ls.add(String.valueOf(fObj));
                ls.addAll(getFilesRecursively(fObj));               
            } else {
                ls.add(String.valueOf(fObj));       
            }
        }

        return ls;
    }
    public static List <String> getListOfFiles(String fullPathDir) {
        List <String> ls = new ArrayList<String> ();
        File f = new File(fullPathDir);
        if (f.exists()) {
            if(f.isDirectory()) {
                ls.add(String.valueOf(f));
                ls.addAll(getFilesRecursively(f));
            }
        } else {
            ls.add(fullPathDir);
        }
        return ls;
    }

    public static void main(String[] args) {
        List <String> ls = getListOfFiles("/Users/srinivasab/Documents");
        for (String file:ls) {
            System.out.println(file);
        }
        System.out.println(ls.size());
    }
}

Question 19

एक और अनुकूलित कोड

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class GetFilesRecursive {
    public static List <String> getFilesRecursively(File dir){
        List <String> ls = new ArrayList<String>();
        if (dir.isDirectory())
            for (File fObj : dir.listFiles()) {
                if(fObj.isDirectory()) {
                    ls.add(String.valueOf(fObj));
                    ls.addAll(getFilesRecursively(fObj));               
                } else {
                    ls.add(String.valueOf(fObj));       
                }
            }
        else
            ls.add(String.valueOf(dir));

        return ls;
    }

    public static void main(String[] args) {
        List <String> ls = getFilesRecursively(new File("/Users/srinivasab/Documents"));
        for (String file:ls) {
            System.out.println(file);
        }
        System.out.println(ls.size());
    }
}

Question 20

जावा 8 का उपयोग करके फाइलों और निर्देशिकाओं को सूचीबद्ध करने का एक और उदाहरण filter

public static void main(String[] args) {

System.out.println("Files!!");
        try {
            Files.walk(Paths.get("."))
                    .filter(Files::isRegularFile)
                    .filter(c ->
                            c.getFileName().toString().substring(c.getFileName().toString().length()-4).contains(".jpg")
                            ||
                            c.getFileName().toString().substring(c.getFileName().toString().length()-5).contains(".jpeg")
                    )
                    .forEach(System.out::println);

        } catch (IOException e) {
        System.out.println("No jpeg or jpg files");
        }

        System.out.println("\nDirectories!!\n");
        try {
            Files.walk(Paths.get("."))
                    .filter(Files::isDirectory)
                    .forEach(System.out::println);

        } catch (IOException e) {
            System.out.println("No Jpeg files");
        }
}