जावा में फ़ाइलों की पुन: सूची दें

Question

मैं जावा की एक निर्देशिका के तहत सभी फ़ाइलों की पुनरावृत्ति कैसे करूं? क्या ढांचा कोई उपयोगिता प्रदान करता है?

मैंने बहुत सारे हैकी कार्यान्वयन देखे। लेकिन फ्रेमवर्क या एनआईओ में से कोई भी नहीं

Comments

मैंने अभी-अभी परीक्षण के परिणाम पूरे किए हैं जो कई उत्तरों के लिए प्रदर्शन परीक्षण प्रदान करते हैं। अप्रत्याशित रूप से सभी NIO आधारित उत्तर सर्वश्रेष्ठ प्रदर्शन करते हैं। कॉमन्स-आईओ उत्तर स्पष्ट रूप से सबसे खराब प्रदर्शन है जो दो बार रन लंबाई है।

— ब्रेट रायन

Java8: Files.walk?

— बेन्ज

Answer 1

जावा 8 एक पेड़ में सभी फाइलों को प्रोसेस करने के लिए एक अच्छी स्ट्रीम प्रदान करता है।

Files.walk(Paths.get(path))
        .filter(Files::isRegularFile)
        .forEach(System.out::println);

यह फ़ाइलों को ट्रैवर्स करने का एक प्राकृतिक तरीका प्रदान करता है। चूंकि यह एक स्ट्रीम है आप परिणाम पर सभी अच्छे स्ट्रीम ऑपरेशन कर सकते हैं जैसे कि सीमा, समूहन, मैपिंग, जल्दी बाहर निकलना आदि।

अद्यतन : मैं इंगित कर सकता हूँ कि वहाँ भी files.find है जो एक BiPredicate लेता है जो फ़ाइल विशेषताओं की जांच करने की आवश्यकता होने पर अधिक कुशल हो सकता है।

Files.find(Paths.get(path),
           Integer.MAX_VALUE,
           (filePath, fileAttr) -> fileAttr.isRegularFile())
        .forEach(System.out::println);

ध्यान दें कि जबकि JavaDoc यह बताता है कि यह विधि Files.walk की तुलना में अधिक कुशल हो सकती है, यह प्रभावी रूप से समान है, यदि आप अपने फ़िल्टर के भीतर फ़ाइल विशेषताओं को भी प्राप्त कर रहे हैं तो प्रदर्शन में अंतर देखा जा सकता है। अंत में, अगर आपको Files.find का उपयोग करने के लिए फ़िल्टर करने की आवश्यकता है , अन्यथा Files.walk का उपयोग करें , क्योंकि ज्यादातर ओवरलोड हैं और यह अधिक सुविधाजनक है।

TESTS : जैसा कि मैंने अनुरोध किया है कि मैंने कई उत्तरों की तुलना की है। की जाँच करें Github परियोजना जो परिणाम और एक परीक्षण का मामला शामिल है ।

Comments

उन उदाहरणों में से एक जो शुरुआती लोगों के लिए भी कार्यात्मक प्रोग्रामिंग का जादू दिखा सकते हैं।

— जॉनी

इस के प्रदर्शन की तुलना प्री-जावा 8 विधियों से कैसे की जाती है? मेरी वर्तमान निर्देशिका ट्रैवर्सल बहुत धीमी है और मैं कुछ ऐसा ढूंढ रहा हूं जो इसे गति देगा।

— श्रीधर सरनोबत

मैं कुछ परीक्षण लिख रहा हूं जिनमें दिए गए उत्तरों में अधिकांश वेरिएंट हैं। अब तक, ऐसा लगता है कि Files.walkसमानांतर धारा के साथ उपयोग करना सबसे अच्छा है, इसके बाद बारीकी से Files.walkFileTreeजो केवल मामूली धीमा है। कॉमन्स-आईओ का उपयोग करते हुए स्वीकृत उत्तर मेरे परीक्षणों द्वारा 4 गुना धीमा होने का सबसे धीमा है।

— ब्रेट रयान

@BrettRyan, मैंने आपके समाधान की कोशिश की, लेकिन मुझे एक अपवाद मिला Exception in thread "main" java.io.UncheckedIOException: java.nio.file.AccessDeniedException। मैं इसे कैसे ठीक कर सकता हूं

— कचना ५'१५ को

मुझे इससे फ़ाइलों की वास्तविक सूची कैसे मिलेगी?

— 15 से 15

Answer 2

FileUtils है iterateFilesऔर listFilesतरीकों। उन्हें एक कोशिश दे। ( कॉमन्स-आईओ से )

संपादित करें: आप विभिन्न तरीकों के बेंचमार्क के लिए यहां देख सकते हैं । ऐसा लगता है कि कॉमन्स-आईओ एप्रोच धीमा है, इसलिए यहां से कुछ तेज लें (यदि यह मायने रखता है)

Comments

FYI करें / TLDR: यदि आप केवल बिना किसी फ़िल्टरिंग के सभी फ़ाइलों को पुनरावर्ती रूप से सूचीबद्ध करना चाहते हैं, तो FileUtils.listFiles(dir, TrueFileFilter.INSTANCE, TrueFileFilter.INSTANCE), dirफ़ाइल ऑब्जेक्ट कहाँ है जो आधार निर्देशिका को इंगित करता है।

— andronikus

आप उपयोग करने पर विचार करना चाह सकते हैं listFilesAndDirs(), क्योंकि listFiles()खाली फ़ोल्डर वापस नहीं आता है।

— श्नाइटर

@ माइकफाइल फाइलयूटिल्स कोड को देखते हुए, मुझे लगता है कि यह हो सकता है FileUtils.listFiles(dir, true, true)। का उपयोग कर FileUtils.listFiles(dir, null, true)एक अपवाद को फेंक देंगे, जबकि FileUtils.listFiles(dir, true, null)उपनिर्देशिकाओं को देखे बिना सभी फाइलों को सूचीबद्ध करेगा।

— समुद्रमंथन

JDK के मूल पुस्तकालय के बारे में कैसे? मैं इस आसान को लागू कर सकता हूं, लेकिन मैं बस अन्य स्थानों से C & P

— बनूंगा

मैं कुछ परीक्षण एक साथ कर रहा हूं, लेकिन अभी तक यह JDK8 या JDK8 विकल्पों का उपयोग करने की तुलना में 4 गुना धीमा प्रदर्शन कर रहा है। इस दृष्टिकोण के साथ साइमलिंक भी समस्याग्रस्त साबित होते हैं, विशेष रूप से जहां वे पेड़ में निर्देशिकाओं को अधिक से अधिक लिंक करते हैं, इस कारण से यह कभी वापस नहीं आता है, इसे फ़िल्टर को संभालने से बचा जा सकता है, लेकिन दुर्भाग्य से सहानुभूति खुद भी नहीं मिलती है एक पंक्ति।

— ब्रेट रयान

Answer 3

// दौड़ने को तैयार

import java.io.File;

public class Filewalker {

    public void walk( String path ) {

        File root = new File( path );
        File[] list = root.listFiles();

        if (list == null) return;

        for ( File f : list ) {
            if ( f.isDirectory() ) {
                walk( f.getAbsolutePath() );
                System.out.println( "Dir:" + f.getAbsoluteFile() );
            }
            else {
                System.out.println( "File:" + f.getAbsoluteFile() );
            }
        }
    }

    public static void main(String[] args) {
        Filewalker fw = new Filewalker();
        fw.walk("c:\\" );
    }

}

Comments

बस इस बात से सावधान रहें कि प्रतीकात्मक लिंक के लिए जो पथ पदानुक्रम में उच्चतर पथ को इंगित करता है, यह विधि कभी समाप्त नहीं होगी। एक सिम्लिंक के साथ एक पथ पर विचार करें जो इंगित करता है -> .।

— ब्रेट रयान

यह केवल अनिवार्य रूप से Files.walkFileTree का एक बुरा कार्यान्वयन है। मुझे लगता है कि लोग खुद को रोल करने की कोशिश करने के बजाय FIles.walkFileTree को देखते हैं ... यह सटीक समस्या @BrettRyan ने बताया है।

— टायलर निकोल्स

आयात java.io.File को शामिल करने के लिए धन्यवाद; तो कई उदाहरणों में नाम स्थान सामान या यहां तक ​​कि डेटाटाइप सामान शामिल करना भूल जाते हैं, उदाहरण के लिए खोज की यात्रा पर एक प्रारंभिक बिंदु। यहाँ यह उदाहरण रेडी-टू-रन है। धन्यवाद।

— बैरीपिकर

पथ अलग-अलग हो सकता है जहां फ़ाइलवॉकर फ़ाइल है। का प्रयोग करें "/", "./"या "../"रूट निर्देशिका, वर्तमान कार्यशील निर्देशिका, और मूल निर्देशिका, क्रमशः के लिए

— मूसा Kirathe

Answer 4

जावा 7 होगा है Files.walkFileTree :

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

इस प्रश्न पर अब संपूर्ण ओरेकल ट्यूटोरियल है ।

Comments

और यह चलने के अंत को सूचित नहीं करता है।

— फरीद

Answer 5

किसी बाहरी पुस्तकालयों की जरूरत नहीं।
एक संग्रह लौटाता है ताकि आप कॉल के बाद इसके साथ जो चाहें कर सकें।

public static Collection<File> listFileTree(File dir) {
    Set<File> fileTree = new HashSet<File>();
    if(dir==null||dir.listFiles()==null){
        return fileTree;
    }
    for (File entry : dir.listFiles()) {
        if (entry.isFile()) fileTree.add(entry);
        else fileTree.addAll(listFileTree(entry));
    }
    return fileTree;
}

Comments

सरल और साफ

— लियो

Answer 6

मैं कुछ इस तरह के साथ जाना होगा:

public void list(File file) {
    System.out.println(file.getName());
    File[] children = file.listFiles();
    for (File child : children) {
        list(child);
    }
}

System.out.println फ़ाइल के साथ कुछ करने के लिए इंगित करने के लिए बस वहाँ है। फ़ाइलों और निर्देशिकाओं के बीच अंतर करने की आवश्यकता नहीं है, क्योंकि एक सामान्य फ़ाइल में बस शून्य बच्चे होंगे।

Comments

के प्रलेखन से listFiles(): "यदि यह सार पथ नाम निर्देशिका को निरूपित नहीं करता है, तो यह विधि वापस आती है null।"

— hfs

बेहतर संस्करण सार्वजनिक स्थैतिक संग्रह <फ़ाइल> सूचीफ्रीट्री (फाइल डायर) {अगर (अशक्त == dir ||? Dir.isDirectory ()) {रिटर्न कलेक्शंस। खाली / (); } अंतिम सेट <फ़ाइल> फ़ाइलट्री = नया हैशसेट <फ़ाइल> (); के लिए (फ़ाइल प्रविष्टि: dir.listFiles ()) {if (entry.isFile ()) {fileTree.add (प्रविष्टि); } और {fileTree.addAll (listFileTree (प्रविष्टि)); }} रिटर्न फाइलट्री; }

— बेन

मेरे लिए यह सबसे संक्षिप्त उत्तर है जो पुनरावर्ती है।

— विली

Answer 7

मैं इस तरह के सरल यात्रा के लिए पुनरावृत्ति पर एक कतार का उपयोग करना पसंद करता हूं:

List<File> allFiles = new ArrayList<File>();
Queue<File> dirs = new LinkedList<File>();
dirs.add(new File("/start/dir/"));
while (!dirs.isEmpty()) {
  for (File f : dirs.poll().listFiles()) {
    if (f.isDirectory()) {
      dirs.add(f);
    } else if (f.isFile()) {
      allFiles.add(f);
    }
  }
}

Comments

लेकिन आपका एल्गोरिथ्म इंडेंटेड आउटपुट के साथ प्रिंट नहीं कर सकता है। डायरियां और फाइलें गड़बड़ हैं। कोई भी समाधान?

— वी

Answer 8

बस सरल पुनरावृत्ति का उपयोग करके इसे स्वयं लिखें:

public List<File> addFiles(List<File> files, File dir)
{
    if (files == null)
        files = new LinkedList<File>();

    if (!dir.isDirectory())
    {
        files.add(dir);
        return files;
    }

    for (File file : dir.listFiles())
        addFiles(files, file);
    return files;
}

Comments

कृप्या! कॉल करने वाले को फ़ाइलों की सूची को इनिशियलाइज़ करने दें, ताकि उसे हर बार अपनी शून्यता की जाँच न करनी पड़े। यदि आप दूसरी (सार्वजनिक) विधि बनाना चाहते हैं जो सूची बनाता है, तो इस आंतरिक विधि को कॉल करता है और पूरी सूची लौटाता है।

— हेलियोस

जो कुछ। एक अशक्त जाँच बहुत महंगी नहीं है, सुविधा + व्यक्तिगत प्राथमिकता एक तरफ मुझे लगता है कि वह इस बात को प्राप्त करेगा।

— पैंसेंटन

क्या आप थोड़ा और अधिक स्पष्ट रूप से समझा सकते हैं?

— uday

Answer 9

मुझे लगता है कि यह काम करना चाहिए:

File dir = new File(dirname);
String[] files = dir.list();

इस तरह आपके पास फाइलें और डायरियां हैं। अब पुनरावर्तन का उपयोग करें और डायर ( Fileकक्षा में isDirectory()विधि) के लिए भी ऐसा ही करें ।

Answer 10

जावा 7 के साथ आप निम्न वर्ग का उपयोग कर सकते हैं:

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

public class MyFileIterator extends SimpleFileVisitor<Path>
{
    public MyFileIterator(String path) throws Exception
    {
        Files.walkFileTree(Paths.get(path), this);
    }

    @Override
    public FileVisitResult visitFile(Path file,
            BasicFileAttributes attributes) throws IOException
    {
        System.out.println("File: " + file);
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult preVisitDirectory(Path dir,
            BasicFileAttributes attributes) throws IOException
    {
        System.out.println("Dir: " + dir);
        return FileVisitResult.CONTINUE;
    }
}

Answer 11

जावा 8 में, हम अब फाइल उपयोगिता का उपयोग करके फाइल ट्री चल सकते हैं। बहुत आसान।

Files.walk(root.toPath())
      .filter(path -> !Files.isDirectory(path))
      .forEach(path -> System.out.println(path));

Answer 12

यह कोड चलाने के लिए तैयार है

public static void main(String... args) {
    File[] files = new File("D:/").listFiles();
    if (files != null) 
       getFiles(files);
}

public static void getFiles(File[] files) {
    for (File file : files) {
        if (file.isDirectory()) {
            getFiles(file.listFiles());
        } else {
            System.out.println("File: " + file);
        }
    }
}

Answer 13

पुनरावर्ती ट्रावेल के अलावा एक विज़िटर आधारित दृष्टिकोण का भी उपयोग कर सकता है।

नीचे कोड ट्रैवर्सल के लिए विज़िटर आधारित दृष्टिकोण का उपयोग करता है। यह उम्मीद की जाती है कि प्रोग्राम का इनपुट ट्रैवर्स के लिए रूट डायरेक्टरी है।

public interface Visitor {
    void visit(DirElement d);
    void visit(FileElement f);
}

public abstract class Element {
    protected File rootPath;
    abstract void accept(Visitor v);

    @Override
    public String toString() {
        return rootPath.getAbsolutePath();
    }
}

public class FileElement extends Element {
    FileElement(final String path) {
        rootPath = new File(path);
    }

    @Override
    void accept(final Visitor v) {
        v.visit(this);
    }
}

public class DirElement extends Element implements Iterable<Element> {
    private final List<Element> elemList;
    DirElement(final String path) {
        elemList = new ArrayList<Element>();
        rootPath = new File(path);
        for (File f : rootPath.listFiles()) {
            if (f.isDirectory()) {
                elemList.add(new DirElement(f.getAbsolutePath()));
            } else if (f.isFile()) {
                elemList.add(new FileElement(f.getAbsolutePath()));
            }
        }
    }

    @Override
    void accept(final Visitor v) {
        v.visit(this);
    }

    public Iterator<Element> iterator() {
        return elemList.iterator();
    }
}

public class ElementWalker {
    private final String rootDir;
    ElementWalker(final String dir) {
        rootDir = dir;
    }

    private void traverse() {
        Element d = new DirElement(rootDir);
        d.accept(new Walker());
    }

    public static void main(final String[] args) {
        ElementWalker t = new ElementWalker("C:\\temp");
        t.traverse();
    }

    private class Walker implements Visitor {
        public void visit(final DirElement d) {
            System.out.println(d);
            for(Element e:d) {
                e.accept(this);
            }
        }

        public void visit(final FileElement f) {
            System.out.println(f);
        }
    }
}

Answer 14

आप विशिष्ट फ़ोल्डर या निर्देशिका की फ़ाइलों की सूची प्राप्त करने के लिए नीचे दिए गए कोड का उपयोग कर सकते हैं।

public static void main(String args[]) {

        recusiveList("D:");

    }

    public static void recursiveList(String path) {

        File f = new File(path);
        File[] fl = f.listFiles();
        for (int i = 0; i < fl.length; i++) {
            if (fl[i].isDirectory() && !fl[i].isHidden()) {
                System.out.println(fl[i].getAbsolutePath());
                recusiveList(fl[i].getAbsolutePath());
            } else {
                System.out.println(fl[i].getName());
            }
        }
    }

Answer 15

स्वीकार किए जाते हैं जवाब लेकिन यह टूट जाती है जब आप लैम्ब्डा के अंदर आईओ करना चाहते हैं, बहुत अच्छा है।

यदि आपकी कार्रवाई IOException की घोषणा करती है तो आप यहां क्या कर सकते हैं।

आप फ़िल्टर्ड स्ट्रीम को Iterableए के रूप में मान सकते हैं , और फिर एक नियमित रूप से प्रत्येक लूप में अपनी कार्रवाई कर सकते हैं। इस तरह, आपको एक लैम्ब्डा के अंदर अपवादों को संभालने की आवश्यकता नहीं है।

try (Stream<Path> pathStream = Files.walk(Paths.get(path))
        .filter(Files::isRegularFile)) {

    for (Path file : (Iterable<Path>) pathStream::iterator) {
        // something that throws IOException
        Files.copy(file, System.out);
    }
}

उस चाल को यहां देखें: https://stackoverflow.com/a/32668807/1207791

Answer 16

एकल सूची के साथ गैर-पुनरावर्ती बीएफएस (विशेष उदाहरण * .eml फाइलें खोज रहा है):

    final FileFilter filter = new FileFilter() {
        @Override
        public boolean accept(File file) {
            return file.isDirectory() || file.getName().endsWith(".eml");
        }
    };

    // BFS recursive search
    List<File> queue = new LinkedList<File>();
    queue.addAll(Arrays.asList(dir.listFiles(filter)));

    for (ListIterator<File> itr = queue.listIterator(); itr.hasNext();) {
        File file = itr.next();
        if (file.isDirectory()) {
            itr.remove();
            for (File f: file.listFiles(filter)) itr.add(f);
        }
    }

Answer 17

मेरा संस्करण (निश्चित रूप से मैं जावा 8 ;-) में निर्मित में इस्तेमाल कर सकता था):

public static List<File> findFilesIn(File rootDir, Predicate<File> predicate) {
        ArrayList<File> collected = new ArrayList<>();
        walk(rootDir, predicate, collected);
        return collected;
    }

    private static void walk(File dir, Predicate<File> filterFunction, List<File> collected) {
        Stream.of(listOnlyWhenDirectory(dir))
                .forEach(file -> walk(file, filterFunction, addAndReturn(collected, file, filterFunction)));
    }

    private static File[] listOnlyWhenDirectory(File dir) {
        return dir.isDirectory() ? dir.listFiles() : new File[]{};
    }

    private static List<File> addAndReturn(List<File> files, File toAdd, Predicate<File> filterFunction) {
        if (filterFunction.test(toAdd)) {
            files.add(toAdd);
        }
        return files;
    }

Answer 18

यहाँ एक सरल लेकिन पूरी तरह से काम कर रहे समाधान का उपयोग कर रहा है recursion:

public static List<Path> listFiles(String rootDirectory)
{
    List<Path> files = new ArrayList<>();
    listFiles(rootDirectory, files);

    return files;
}

private static void listFiles(String path, List<Path> collectedFiles)
{
    File root = new File(path);
    File[] files = root.listFiles();

    if (files == null)
    {
        return;
    }

    for (File file : files)
    {
        if (file.isDirectory())
        {
            listFiles(file.getAbsolutePath(), collectedFiles);
        } else
        {
            collectedFiles.add(file.toPath());
        }
    }
}

Answer 19

    private void fillFilesRecursively(File file, List<File> resultFiles) {
        if (file.isFile()) {
            resultFiles.add(file);
        } else {
            for (File child : file.listFiles()) {
                fillFilesRecursively(child, resultFiles);
            }
        }
    }

Answer 20

मैं इसे सभी फ़ाइलों / फ़ाइल नामों की पुनरावृत्ति के लिए प्रिंट करने के लिए आया था।

private static void printAllFiles(String filePath,File folder) {
    if(filePath==null) {
        return;
    }
    File[] files = folder.listFiles();
    for(File element : files) {
        if(element.isDirectory()) {
            printAllFiles(filePath,element);
        } else {
            System.out.println(" FileName "+ element.getName());
        }
    }
}

Answer 21

उदाहरण आउटपुट * .csv निर्देशिका में फ़ाइलें पुनरावर्ती खोज उपनिर्देशिका का उपयोग करके files.find () java.nio से:

String path = "C:/Daten/ibiss/ferret/";
    logger.debug("Path:" + path);
    try (Stream<Path> fileList = Files.find(Paths.get(path), Integer.MAX_VALUE,
            (filePath, fileAttr) -> fileAttr.isRegularFile() && filePath.toString().endsWith("csv"))) {
        List<String> someThingNew = fileList.sorted().map(String::valueOf).collect(Collectors.toList());
        for (String t : someThingNew) {
            t.toString();
            logger.debug("Filename:" + t);
        }

    }

इस उदाहरण को पोस्ट करते हुए, क्योंकि मुझे यह समझने में परेशानी हुई कि ब्रायन द्वारा दिए गए # 1 उदाहरण में फाइलनाम पैरामीटर कैसे पास किया जाए, स्ट्रीम-रिजल्ट पर फॉर्च का उपयोग करके -

उम्मीद है की यह मदद करेगा।

Answer 22

कोटलिन के पास FileTreeWalkइस उद्देश्य के लिए है। उदाहरण के लिए:

dataDir.walkTopDown().filter { !it.isDirectory }.joinToString("\n") {
   "${it.toRelativeString(dataDir)}: ${it.length()}"
}

किसी दिए गए रूट के तहत सभी गैर-निर्देशिका फ़ाइलों की एक पाठ सूची का उत्पादन करेगा, रूट और लंबाई के सापेक्ष पथ के साथ प्रति पंक्ति एक फ़ाइल।

Answer 23

एक और तरीका है अगर आप किसी को पहले से ही जावा 8 चलना प्रदान करते हैं।

यह आपको सभी फाइलें पुनरावर्ती प्रदान करेगा

  private Stream<File> files(File file) {
    return file.isDirectory()
            ? Arrays.stream(file.listFiles()).flatMap(this::files)
            : Stream.of(file);
}

Answer 24

स्टेकर उत्तर के आधार पर। यहाँ JSP में बिना किसी बाहरी पुस्तकालयों के काम करने का एक समाधान है ताकि आप इसे अपने सर्वर पर लगभग कहीं भी रख सकें:

<!DOCTYPE html>
<%@ page session="false" %>
<%@ page import="java.util.*" %>
<%@ page import="java.io.*" %>
<%@ page contentType="text/html; charset=UTF-8" %>

<%!
    public List<String> files = new ArrayList<String>();
    /**
        Fills files array with all sub-files.
    */
    public void walk( File root ) {
        File[] list = root.listFiles();

        if (list == null) return;

        for ( File f : list ) {
            if ( f.isDirectory() ) {
                walk( f );
            }
            else {
                files.add(f.getAbsolutePath());
            }
        }
    }
%>
<%
    files.clear();
    File jsp = new File(request.getRealPath(request.getServletPath()));
    File dir = jsp.getParentFile();
    walk(dir);
    String prefixPath = dir.getAbsolutePath() + "/";
%>

तो आप बस कुछ ऐसा करें:

    <ul>
        <% for (String file : files) { %>
            <% if (file.matches(".+\\.(apk|ipa|mobileprovision)")) { %>
                <li><%=file.replace(prefixPath, "")%></li>
            <% } %>
        <% } %>
    </ul>

Comments

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

— सैमुअल केरेन

यह निर्भर करता है कि आप क्या कर रहे हैं। एक उद्यम के आकार के आवेदन में आप बिल्कुल सही हैं। यदि आपको बस एक सरल, स्टैंडअलोन लिस्टिंग के लिए ड्रॉप-इन के रूप में इसकी आवश्यकता है, तो यह पूरी तरह से ठीक है।

— नक्स