java - जावा से एक फ़ोल्डर में सभी फाइलें कैसे पढ़ती हैं?


जावा के माध्यम से एक फ़ोल्डर में सभी फाइलें कैसे पढ़ती हैं?



Answers



public void listFilesForFolder(final File folder) {
    for (final File fileEntry : folder.listFiles()) {
        if (fileEntry.isDirectory()) {
            listFilesForFolder(fileEntry);
        } else {
            System.out.println(fileEntry.getName());
        }
    }
}

final File folder = new File("/home/you/Desktop");
listFilesForFolder(folder);

Files.walk API 8 जावा से उपलब्ध है।

try (Stream<Path> paths = Files.walk(Paths.get("/home/you/Desktop"))) {
    paths
        .filter(Files::isRegularFile)
        .forEach(System.out::println);
} 

उदाहरण एपीआई गाइड में अनुशंसित प्रयास-के-संसाधनों का उपयोग करता है। यह सुनिश्चित करता है कि धारा कोई बात नहीं की स्थिति बंद हो जाएगी।




File folder = new File("/Users/you/folder/");
File[] listOfFiles = folder.listFiles();

for (File file : listOfFiles) {
    if (file.isFile()) {
        System.out.println(file.getName());
    }
}



जावा 8 में आप यह कर सकते हैं

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

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

Files.walk(Paths.get("/path/to/folder"))
     .filter(Files::isRegularFile)
     .collect(Collectors.toList())

यदि आप List<File> List<Path> की बजाय List<File> को वापस करना चाहते हैं:

List<File> filesInFolder = Files.walk(Paths.get("/path/to/folder"))
                                .filter(Files::isRegularFile)
                                .map(Path::toFile)
                                .collect(Collectors.toList());

आपको यह भी सुनिश्चित करना होगा कि आप स्ट्रीम बंद करें! अन्यथा आप एक अपवाद में चल सकते हैं जो आपको बताता है कि बहुत सी फ़ाइलें खुली हैं अधिक जानकारी के लिए यहां पढ़ें




इस विषय पर सभी उत्तरों जो कि नए जावा 8 फ़ंक्शंस का उपयोग करते हैं, स्ट्रीम को बंद करने की उपेक्षा करते हैं। स्वीकृत उत्तर में उदाहरण होना चाहिए:

try (Stream<Path> filePathStream=Files.walk(Paths.get("/home/you/Desktop"))) {
    filePathStream.forEach(filePath -> {
        if (Files.isRegularFile(filePath)) {
            System.out.println(filePath);
        }
    });
}

Files.walk विधि के javadoc से:

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




import java.io.File;


public class ReadFilesFromFolder {
  public static File folder = new File("C:/Documents and Settings/My Documents/Downloads");
  static String temp = "";

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.println("Reading files under the folder "+ folder.getAbsolutePath());
    listFilesForFolder(folder);
  }

  public static void listFilesForFolder(final File folder) {

    for (final File fileEntry : folder.listFiles()) {
      if (fileEntry.isDirectory()) {
        // System.out.println("Reading files under the folder "+folder.getAbsolutePath());
        listFilesForFolder(fileEntry);
      } else {
        if (fileEntry.isFile()) {
          temp = fileEntry.getName();
          if ((temp.substring(temp.lastIndexOf('.') + 1, temp.length()).toLowerCase()).equals("txt"))
            System.out.println("File= " + folder.getAbsolutePath()+ "\\" + fileEntry.getName());
        }

      }
    }
  }
}



private static final String ROOT_FILE_PATH="/";
File f=new File(ROOT_FILE_PATH);
File[] allSubFiles=f.listFiles();
for (File file : allSubFiles) {
    if(file.isDirectory())
    {
        System.out.println(file.getAbsolutePath()+" is directory");
        //Steps for directory
    }
    else
    {
        System.out.println(file.getAbsolutePath()+" is file");
        //steps for files
    }
}



जावा 7 में आप इसे इस तरह से कर सकते हैं - http://docs.oracle.com/javase/tutorial/essential/io/dirs.html#listdir

Path dir = ...;
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
    for (Path file: stream) {
        System.out.println(file.getFileName());
    }
} catch (IOException | DirectoryIteratorException x) {
    // IOException can never be thrown by the iteration.
    // In this snippet, it can only be thrown by newDirectoryStream.
    System.err.println(x);
}

आप एक फिल्टर भी बना सकते हैं जिसे बाद में newDirectoryStream पद्धति में पारित किया जा सकता है

DirectoryStream.Filter<Path> filter = newDirectoryStream.Filter<Path>() {
    public boolean accept(Path file) throws IOException {
        try {
            return (Files.isRegularFile(path));
        } catch (IOException x) {
            // Failed to determine if it's a file.
            System.err.println(x);
            return false;
        }
    }
};

अन्य फ़िल्टरिंग उदाहरण - http://docs.oracle.com/javase/tutorial/essential/io/dirs.html#glob




बस Files.walkFileTree (जावा 7) का उपयोग कर सभी फाइलों के माध्यम से चलें

Files.walkFileTree(Paths.get(dir), new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        System.out.println("file: " + file);
        return FileVisitResult.CONTINUE;
    }
});



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

public static ArrayList<File> listFilesForFolder(final File folder,
        final boolean recursivity,
        final String patternFileFilter) {

    // Inputs
    boolean filteredFile = false;

    // Ouput
    final ArrayList<File> output = new ArrayList<File> ();

    // Foreach elements
    for (final File fileEntry : folder.listFiles()) {

        // If this element is a directory, do it recursivly
        if (fileEntry.isDirectory()) {
            if (recursivity) {
                output.addAll(listFilesForFolder(fileEntry, recursivity, patternFileFilter));
            }
        }
        else {
            // If there is no pattern, the file is correct
            if (patternFileFilter.length() == 0) {
                filteredFile = true;
            }
            // Otherwise we need to filter by pattern
            else {
                filteredFile = Pattern.matches(patternFileFilter, fileEntry.getName());
            }

            // If the file has a name which match with the pattern, then add it to the list
            if (filteredFile) {
                output.add(fileEntry);
            }
        }
    }

    return output;
}

बेस्ट, एड्रियन




https://.com/a/286001/146745 पर देखा गया java.io.FileFilter का अच्छा उपयोग

File fl = new File(dir);
File[] files = fl.listFiles(new FileFilter() {          
    public boolean accept(File file) {
        return file.isFile();
    }
});



    static File mainFolder = new File("Folder");
    public static void main(String[] args) {

        lf.getFiles(lf.mainFolder);
    }
    public void getFiles(File f) {
        File files[];
        if (f.isFile()) {
            String name=f.getName();

        } else {
            files = f.listFiles();
            for (int i = 0; i < files.length; i++) {
                getFiles(files[i]);
            }
        }
    }



मुझे लगता है कि यह एक फ़ोल्डर और उप फ़ोल्डर के सभी फाइलों को पढ़ने का अच्छा तरीका है

private static void addfiles (File input,ArrayList<File> files)
{
    if(input.isDirectory())
    {
        ArrayList <File> path = new ArrayList<File>(Arrays.asList(input.listFiles()));
        for(int i=0 ; i<path.size();++i)
        {
            if(path.get(i).isDirectory())
            {
                addfiles(path.get(i),files);
            }
            if(path.get(i).isFile())
            {
                files.add(path.get(i));
            }
        }
    }
    if(input.isFile())
    {
        files.add(input);
    }
}



सरल उदाहरण जो जावा 1.7 के साथ काम करता है, ताकि कमांड लाइन पर निर्दिष्ट निर्देशिकाओं में फाइलों को सूचीबद्ध किया जा सके:

import java.io.File;

public class List {
    public static void main(String[] args) {
        for (String f : args) {
            listDir(f);
        }
    }

    private static void listDir(String dir) {
        File f = new File(dir);
        File[] list = f.listFiles();

        if (list == null) {
            return;
        }

        for (File entry : list) {
            System.out.println(entry.getName());
            if (entry.isDirectory()) {
                listDir(entry.getAbsolutePath());
            }
        }
    }
}



File directory = new File("/user/folder");      
File[] myarray;  
myarray=new File[10];
myarray=directory.listFiles();
for (int j = 0; j < myarray.length; j++)
{
       File path=myarray[j];
       FileReader fr = new FileReader(path);
       BufferedReader br = new BufferedReader(fr);
       String s = "";
       while (br.ready()) {
          s += br.readLine() + "\n";
       }
}



package com;


import java.io.File;

/**
 *
 * @author ?Mukesh
 */
public class ListFiles {

     static File mainFolder = new File("D:\\Movies");

     public static void main(String[] args)
     {
         ListFiles lf = new ListFiles();
         lf.getFiles(lf.mainFolder);

         long fileSize = mainFolder.length();
             System.out.println("mainFolder size in bytes is: " + fileSize);
             System.out.println("File size in KB is : " + (double)fileSize/1024);
             System.out.println("File size in MB is :" + (double)fileSize/(1024*1024));
     }
     public void getFiles(File f){
         File files[];
         if(f.isFile())
             System.out.println(f.getAbsolutePath());
         else{
             files = f.listFiles();
             for (int i = 0; i < files.length; i++) {
                 getFiles(files[i]);
             }
         }
     }
}



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

public class AvoidNullExp {

public static void main(String[] args) {

    List<File> fileList =new ArrayList<>();
     final File folder = new File("g:/master");
     new AvoidNullExp().listFilesForFolder(folder, fileList);
}

    public void listFilesForFolder(final File folder,List<File> fileList) {
        File[] filesInFolder = folder.listFiles();
        if (filesInFolder != null) {
            for (final File fileEntry : filesInFolder) {
                if (fileEntry.isDirectory()) {
                    System.out.println("DIR : "+fileEntry.getName());
                listFilesForFolder(fileEntry,fileList);
            } else {
                System.out.println("FILE : "+fileEntry.getName());
                fileList.add(fileEntry);
            }
         }
        }
     }


}



क्लास पथ के अंदर मौजूद टेस्ट फ़ोल्डर से फ़ाइलें सूचीबद्ध करें

import java.io.File;
import java.io.IOException;

public class Hello {

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

        System.out.println("List down all the files present on the server directory");
        File file1 = new File("/prog/FileTest/src/Test");
        File[] files = file1.listFiles();
        if (null != files) {
            for (int fileIntList = 0; fileIntList < files.length; fileIntList++) {
                String ss = files[fileIntList].toString();
                if (null != ss && ss.length() > 0) {
                    System.out.println("File: " + (fileIntList + 1) + " :" + ss.substring(ss.lastIndexOf("\\") + 1, ss.length()));
                }
            }
        }


    }


}



/**
 * Function to read all mp3 files from sdcard and store the details in an
 * ArrayList
 */


public ArrayList<HashMap<String, String>> getPlayList() 
    {
        ArrayList<HashMap<String, String>> songsList=new ArrayList<>();
        File home = new File(MEDIA_PATH);

        if (home.listFiles(new FileExtensionFilter()).length > 0) {
            for (File file : home.listFiles(new FileExtensionFilter())) {
                HashMap<String, String> song = new HashMap<String, String>();
                song.put(
                        "songTitle",
                        file.getName().substring(0,
                                (file.getName().length() - 4)));
                song.put("songPath", file.getPath());

                // Adding each song to SongList
                songsList.add(song);
            }
        }
        // return songs list array
        return songsList;
    }

    /**
     * Class to filter files which have a .mp3 extension
     * */
    class FileExtensionFilter implements FilenameFilter 
    {
        @Override
        public boolean accept(File dir, String name) {
            return (name.endsWith(".mp3") || name.endsWith(".MP3"));
        }
    }

आप किसी भी टेक्स्टफ़ाइल या किसी अन्य एक्सटेंशन को फ़िल्टर कर सकते हैं .. इसे केवल एमपी 3 के साथ बदलें




void getFiles(){
        String dirPath = "E:/folder_name";
        File dir = new File(dirPath);
        String[] files = dir.list();
        if (files.length == 0) {
            System.out.println("The directory is empty");
        } else {
            for (String aFile : files) {
                System.out.println(aFile);
            }
        }
    }



हालांकि मैं रिच, ओरियन और बाकी का उपयोग करने के लिए सहमत हूं:

    final File keysFileFolder = new File(<path>); 
    File[] fileslist = keysFileFolder.listFiles();

    if(fileslist != null)
    {
        //Do your thing here...
    }

किसी कारण के लिए यहां सभी उदाहरण पूर्ण पथ का उपयोग करते हैं (अर्थात् रूट से सभी प्रकार, या, कहते हैं, ड्राइव अक्षर (सी: \) विंडोज़ के लिए ..)

मैं जोड़ना चाहूंगा कि रिश्तेदार पथ का प्रयोग करना संभव है-अच्छी तरह से इसलिए, यदि आप पीडब्ल्यूडी (वर्तमान निर्देशिका / फ़ोल्डर) हैं तो फ़ोल्डर 1 है और आप फ़ोल्डर 1 / सबफोल्डर को पार्स करना चाहते हैं, तो आप बस (इसके बजाय उपरोक्त कोड में) लिखते हैं:

    final File keysFileFolder = new File("subfolder");



जावा 8 Files.walk(..) अच्छा है जब आप Files.walk(..) तो यह फेंक नहीं करेगा जावा 8 फाइलों से बचें। वाल (..) का समापन कारण (java.nio.file.AccessDeniedException)

यहां एक सुरक्षित समाधान है, हालांकि जावा 8 Files.walk(..) रूप में सुंदर नहीं हैं:

int[] count = {0};
try {
    Files.walkFileTree(Paths.get(dir.getPath()), new HashSet<FileVisitOption>(Arrays.asList(FileVisitOption.FOLLOW_LINKS)),
            Integer.MAX_VALUE, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file , BasicFileAttributes attrs) throws IOException {
                    System.out.printf("Visiting file %s\n", file);
                    ++count[0];

                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult visitFileFailed(Path file , IOException e) throws IOException {
                    System.err.printf("Visiting failed for %s\n", file);

                    return FileVisitResult.SKIP_SUBTREE;
                }

                @Override
                public FileVisitResult preVisitDirectory(Path dir , BasicFileAttributes attrs) throws IOException {
                     System.out.printf("About to visit directory %s\n", dir);
                    return FileVisitResult.CONTINUE;
                }
            });
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}



बस स्वीकार्य उत्तर पर विस्तार करने के लिए मैं फाइलनामों को एक अर्रेइस्ट (केवल उन्हें सिस्टम। आउट.प्रिंटएलएन में डंप करने के बजाय) में संग्रहीत करता हूं मैंने एक सहायक वर्ग "मायफ़ाइल यूथल्स" बनाया जिससे कि इसे अन्य परियोजनाओं द्वारा आयात किया जा सके:

class MyFileUtils {
    public static void loadFilesForFolder(final File folder, List<String> fileList){
        for (final File fileEntry : folder.listFiles()) {
            if (fileEntry.isDirectory()) {
                loadFilesForFolder(fileEntry, fileList);
            } else {
                fileList.add( fileEntry.getParent() + File.separator + fileEntry.getName() );
            }
        }
    }
}

मैंने फ़ाइल नाम का पूर्ण पथ जोड़ा। आप इसे इस तरह प्रयोग करेंगे:

import MyFileUtils;

List<String> fileList = new ArrayList<String>();
final File folder = new File("/home/you/Desktop");
MyFileUtils.loadFilesForFolder(folder, fileList);

// Dump file list values
for (String fileName : fileList){
    System.out.println(fileName);
}

ArrayList को "मान" से पारित किया गया है, लेकिन मूल्य का उपयोग करने के लिए JVM हीप में रहने वाले समान ArrayList ऑब्जेक्ट को इंगित किया जाता है। इस तरह, प्रत्येक पुनरावर्ती कॉल में फ़ाइल नाम उसी अर्रेलिस्ट (हम प्रत्येक रिकर्सिव कॉल पर एक नया अर्रेलिस्ट नहीं बना रहे हैं) कहते हैं।




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

 ClassLoader contextClassLoader = 
 Thread.currentThread().getContextClassLoader();
    URL resource = contextClassLoader.getResource("");
    File file = new File(resource.toURI());
    File[] files = file.listFiles();
    for (File f : files) {
        System.out.println(f.getName());
    }

अब एक विशिष्ट फ़ोल्डर से फाइल प्राप्त करने के लिए, मान लें कि आपके पास संसाधन फ़ोल्डर में 'res' नामक एक फ़ोल्डर है, बस इसे बदलें:

URL resource = contextClassLoader.getResource("res");

यदि आप अपने com.company नाम पैकेज में पहुंच चाहते हैं तो:

contextClassLoader.getResource("com.companyName");



सूचीफ़ाइलें () फ़ंक्शन पर Nullpointerexceptions को रोकने के लिए और उप-डायरेक्टरीज़ से सभी फ़ाइलों को बार-बार मिलता है ..

 public void listFilesForFolder(final File folder,List<File> fileList) {
    File[] filesInFolder = folder.listFiles();
    if (filesInFolder != null) {
        for (final File fileEntry : filesInFolder) {
            if (fileEntry.isDirectory()) {
            listFilesForFolder(fileEntry,fileList);
        } else {
            fileList.add(fileEntry);
        }
     }
    }
 }

 List<File> fileList = new List<File>();
 final File folder = new File("/home/you/Desktop");
 listFilesForFolder(folder);



import java.io.File;


public class Test {

public void test1() {
    System.out.println("TEST 1");
}

public static void main(String[] args) throws SecurityException, ClassNotFoundException{

    File actual = new File("src");
    File list[] = actual.listFiles();
    for(int i=0; i<list.length; i++){
        String substring = list[i].getName().substring(0, list[i].getName().indexOf("."));
        if(list[i].isFile() && list[i].getName().contains(".java")){
                if(Class.forName(substring).getMethods()[0].getName().contains("main")){
                    System.out.println("CLASS NAME "+Class.forName(substring).getName());
                }

         }
    }

}
}

बस अपने फ़ोल्डर को पास करें, यह आपको विधि के बारे में मुख्य वर्ग बताएगा।










Links