जावा का उपयोग करके फ़ाइलों के साथ एक फ़ोल्डर कैसे हटाएं

Question

मैं जावा का उपयोग करके एक निर्देशिका बनाना और हटाना चाहता हूं, लेकिन यह काम नहीं कर रहा है।

File index = new File("/home/Work/Indexer1");
if (!index.exists()) {
    index.mkdir();
} else {
    index.delete();
    if (!index.exists()) {
        index.mkdir();
    }
}

Comments

जब आपने प्रयास किया तो क्या हुआ?

— अबिमारन कुगाथासन

प्रश्न क्या है?

— अनिकेत ठाकुर

अनुक्रमणिका फ़ाइल नहीं निकाली गई।

— मिस्टर

जावा में एक निर्देशिका को हटाने का

— अनिकेत ठाकुर

दुर्भाग्य से, @AniketThakur, वह दृष्टिकोण प्रतीकात्मक लिंक का अनुसरण करेगा और उन फ़ाइलों और निर्देशिकाओं को हटा देगा, जिनका इरादा नहीं था।

— हंक शुल्ज़

Answer 1

जावा इसमें डेटा वाले फ़ोल्डर्स को हटाने में सक्षम नहीं है। आपको फ़ोल्डर को हटाने से पहले सभी फ़ाइलों को हटाना होगा।

कुछ का उपयोग करें:

String[]entries = index.list();
for(String s: entries){
    File currentFile = new File(index.getPath(),s);
    currentFile.delete();
}

फिर आपको index.delete() अनटाइटेड का उपयोग करके फ़ोल्डर को हटाने में सक्षम होना चाहिए !

Comments

यह गैर-रिक्त उपनिर्देशिकाओं को नहीं हटाएगा।

— फ्रांसेस्को मेंजानी

आपको एक पुनरावर्ती विधि लिखनी होगी या FileUtils.deleteDirectory@Francesco Menzani ने कहा।

— EN20

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

— हांक शुल्त्

समाधान: कोड के इस भाग को लपेटें if (!index.delete()) {...}। फिर, यदि इंडेक्स एक प्रतीकात्मक लिंक है, तो इसकी परवाह किए बिना हटा दिया जाता है कि इसमें सामग्री है।

— हांक शुल्त्

यदि निर्देशिका को पढ़ने के दौरान I / O अपवाद है, तो यह NullPointerException को फेंक देगा। कोड को जांचना चाहिए कि क्या entriesअशक्त है।

— मर्स्टन

Answer 2

सिर्फ एक लाइनर।

import org.apache.commons.io.FileUtils;

FileUtils.deleteDirectory(new File(destination));

यहाँ प्रलेखन

Comments

अद्यतन लिंक: commons.apache.org/proper/commons-io/javadocs/api-2.5/org/…

— OhadR

उम नहीं। यह बाहरी निर्भरता वाला वन-लाइनर है, जिसे ध्यान में रखना एक महत्वपूर्ण बात है। बाहरी निर्भरता का उपयोग करने का एकमात्र समय यह सरल है जब आप एक व्यक्तिगत घर परियोजना कर रहे हैं, या आपकी कंपनी वास्तव में मुकदमा करने की संभावना के बारे में परवाह नहीं करती है।

— searchengine27

@ searchengine27 लेकिन ऐसा लगता है कि पुस्तकालय अपाचे कॉमन्स के अधीन है, इसलिए मुकदमा दायर करने का जोखिम नगण्य व्हाट्सएपर्सवर्थ . com/whitesource-blog/… है ।

— सिम्टिम

@simtim आपको वह बिंदु पूरी तरह याद आ रहा है। एक कंपनी कभी भी उपयोग की शर्तों और अंतिम उपयोगकर्ता समझौतों, और पहले पुस्तकालय से जुड़े किसी भी अन्य कानूनी दस्तावेजों को डालने वाले वकीलों की एक टीम के बिना उपयोग करने के लिए एक पुस्तकालय को मंजूरी नहीं देगी। किसी को उन वकीलों को भुगतान करना पड़ता है ... कभी-कभी कोई भी नहीं चाहता है, जिसका अर्थ है कि डेवलपर को इसका उपयोग करने की आवश्यकता नहीं है। जितनी बड़ी कंपनी के लिए आप काम करेंगे, उतनी ही लालफीताशाही से गुजरना पड़ेगा।

— 22eng

@ searchengine27 नहीं, आप इस बिंदु को पूरी तरह से याद कर रहे हैं। एक कंपनी जिसे अपाचे कॉमन्स का उपयोग करने की अनुमति देने के लिए वकीलों की एक सेना की आवश्यकता होती है, वह पूर्ण पैथोलॉजी है, और आईटी दुनिया में आदर्श के पास कुछ भी नहीं है। मैंने कभी भी ऐसी किसी समस्या के बारे में नहीं सुना है और यदि आपके पास ऐसी समस्याएं हैं, तो आपके पास एसओ तक पहुंचने की सबसे अधिक संभावना है, इसलिए उत्तर वैसे भी आपके लिए सुलभ नहीं होगा।

— 9ilsdx 9rvj 0lo

Answer 3

यह काम करता है, और जब यह निर्देशिका परीक्षण को छोड़ने के लिए अक्षम दिखता है, तो यह नहीं है: परीक्षण तुरंत होता है listFiles()।

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            deleteDir(f);
        }
    }
    file.delete();
}

प्रतीकात्मक लिंक से बचने के लिए अपडेट करें:

void deleteDir(File file) {
    File[] contents = file.listFiles();
    if (contents != null) {
        for (File f : contents) {
            if (! Files.isSymbolicLink(f.toPath())) {
                deleteDir(f);
            }
        }
    }
    file.delete();
}

Comments

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

— जेफ लीमैन

@ 9ilsdx9rvj0lo नमकीन होने के बजाय, शायद आप सहानुभूति को संभालने के लिए संपादन प्रदान कर सकें। ओपी ने अपने पोस्ट में प्रतीकात्मक लिंक के बारे में कुछ नहीं कहा । बस एक निर्देशिका बनाने और हटाने। कृपया "बहुत सी बातें याद आ रही हैं" को भी सूचीबद्ध करें। हमारी मदद करो।

— पेरी ट्यु

@PerryTew मैं भद्दा नहीं हूं। मैं सिर्फ इशारा कर रहा हूं, कि मैं उत्तर बेहतर होने के बारे में आपकी टिप्पणी से पूरी तरह असहमत हूं क्योंकि कोई बाहरी पुस्तकालयों का उपयोग नहीं किया जा रहा है। यह नहीं। एक अच्छा कारण यह है कि लोग अपाचे कॉमन्स का उपयोग कर रहे हैं: आपको किसी एक चीज को स्वयं प्रोग्राम करने की आवश्यकता नहीं है। Symlinks सिर्फ उन चीजों का एक उदाहरण है जिन्हें आप स्क्रैच से सब कुछ लिखने से चूक जाएंगे।

— 9ilsdx 9rvj 0lo

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

— जेफ लीमैन

Answer 4

मैं जावा 8 पर इस समाधान को पसंद करता हूं:

  Files.walk(pathToBeDeleted)
    .sorted(Comparator.reverseOrder())
    .map(Path::toFile)
    .forEach(File::delete);

इस साइट से: http://www.baeldung.com/java-delete-directory

Comments

ध्यान दें कि इसमें स्कैलेबिलिटी समस्या हो सकती है क्योंकि यह पूरी सूची बनाता है, एक सॉर्ट की गई कॉपी बनाता है, और फिर सॉर्ट की गई कॉपी पर पुनरावृत्ति करता है। पुराने दिनों में वापस जब स्मृति अटूट नहीं थी, यह एक बहुत बुरा विचार होगा। यह संक्षिप्त है लेकिन अंतरिक्ष में लागत (O (N) बनाम O (1)) और दक्षता (O (N log N) बनाम O (N)) है। यह ज्यादातर उपयोग के मामलों में मायने नहीं रखेगा।

— जेफ लीमैन

मुझे ऊपर "स्पेस ओ (एन) बनाम ओ (गहराई)" कहना चाहिए था, जहां गहराई निर्देशिका पेड़ की गहराई है (पुनरावर्ती लोगों के लिए इस समाधान की तुलना करना।)

— जेफ लीमैन

यह सुरुचिपूर्ण है, काम करता है और बाहरी पुस्तकालयों पर निर्भर नहीं करता है। इसे प्यार करता था

— लियो

क्या यह फ़ाइल हैंडल लीक की समस्या नहीं है? यह उदाहरण द्वारा दी गई धारा को बंद नहीं करता है Files.walk(), जो स्पष्ट रूप से एपीआई डॉक्स में इंगित किया गया है। मुझे पता है कि यदि आप Files.list()उदाहरण के लिए दी गई स्ट्रीम को बंद नहीं करते हैं , तो आप हैंडल से बाहर भाग सकते हैं और प्रोग्राम क्रैश हो जाएगा। उदाहरण के लिए देखें stackoverflow.com/q/36990053/421049 और stackoverflow.com/q/26997240/421049 ।

— गैरेट विल्सन

Answer 5

JDK 7 में आप फाइलों के एक पेड़ का उपयोग Files.walkFileTree()और Files.deleteIfExists()हटा सकते हैं। (नमूना: http://fahdshariff.blogspot.ru/2011/08/java-7-de हटाना-directory-by.walw.html )

JDK 6 में एक संभव तरीका अपाचे कॉमन्स से FileUtils.deleteQuietly का उपयोग करना है जो एक फाइल, एक डायरेक्टरी या फाइलों और उप-निर्देशिकाओं के साथ एक डायरेक्टरी को हटा देगा।

Comments

यहाँ एक नमूना है: fahdshariff.blogspot.ru/2011/08/…

— एंड्री चेशेव

Answer 6

Apache Commons-IO का उपयोग करते हुए, यह एक-लाइनर का अनुसरण कर रहा है:

import org.apache.commons.io.FileUtils;

FileUtils.forceDelete(new File(destination));

यह (थोड़ा) अधिक प्रदर्शन है FileUtils.deleteDirectory।

Comments

समूह: 'कॉमन्स-आईओ', नाम: 'कॉमन्स-आईओ', संस्करण: '2. +' - उपयोगी

— माइक कृंतक

Answer 7

जैसा कि उल्लेख किया गया है, जावा फ़ाइलों को हटाने वाले फ़ोल्डर को हटाने में सक्षम नहीं है, इसलिए पहले फ़ाइलों और फिर फ़ोल्डर को हटा दें।

यहाँ यह करने के लिए एक सरल उदाहरण है:

import org.apache.commons.io.FileUtils;



// First, remove files from into the folder 
FileUtils.cleanDirectory(folder/path);

// Then, remove the folder
FileUtils.deleteDirectory(folder/path);

या:

FileUtils.forceDelete(new File(destination));

Answer 8

मेरा मूल पुनरावर्ती संस्करण, JDK के पुराने संस्करणों के साथ काम कर रहा है:

public static void deleteFile(File element) {
    if (element.isDirectory()) {
        for (File sub : element.listFiles()) {
            deleteFile(sub);
        }
    }
    element.delete();
}

Comments

यदि निर्देशिका पढ़ते समय I / O अपवाद है, तो यह NullPointerException को फेंक देगा। कोड को यह जांचना चाहिए कि क्या listFiles()कॉल करने के बजाय अशक्त है या नहीं isDirectory()।

— 23st में

Answer 9

यह सबसे अच्छा समाधान है Java 7+:

public static void deleteDirectory(String directoryFilePath) throws IOException
{
    Path directory = Paths.get(directoryFilePath);

    if (Files.exists(directory))
    {
        Files.walkFileTree(directory, new SimpleFileVisitor<Path>()
        {
            @Override
            public FileVisitResult visitFile(Path path, BasicFileAttributes basicFileAttributes) throws IOException
            {
                Files.delete(path);
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path directory, IOException ioException) throws IOException
            {
                Files.delete(directory);
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

Answer 10

बचाव के लिए अमरूद 21+। केवल तभी उपयोग करें जब कोई निर्देशिका से हटने के लिए कोई सिम्बलिंक न हों।

com.google.common.io.MoreFiles.deleteRecursively(
      file.toPath(),
      RecursiveDeleteOption.ALLOW_INSECURE
) ;

(यह प्रश्न Google द्वारा अच्छी तरह से अनुक्रमणित है, इसलिए अन्य लोगों ने अमरूद को इस उत्तर को पाकर खुश हो सकते हैं, भले ही यह अन्य उत्तरों के साथ बेमानी हो।)

Answer 11

मुझे यह समाधान सबसे ज्यादा पसंद है। यह 3rd पार्टी लाइब्रेरी का उपयोग नहीं करता है, इसके बजाय यह जावा 7 के NIO2 का उपयोग करता है ।

/**
 * Deletes Folder with all of its content
 *
 * @param folder path to folder which should be deleted
 */
public static void deleteFolderAndItsContent(final Path folder) throws IOException {
    Files.walkFileTree(folder, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
            if (exc != null) {
                throw exc;
            }
            Files.delete(dir);
            return FileVisitResult.CONTINUE;
        }
    });
}

Answer 12

एक और विकल्प वसंत की org.springframework.util.FileSystemUtilsप्रासंगिक विधि का उपयोग करना है जो निर्देशिका की सभी सामग्री को पुन: हटा देगा।

File directoryToDelete = new File(<your_directory_path_to_delete>);
FileSystemUtils.deleteRecursively(directoryToDelete);

वह काम करेगा!

Answer 13

इसमें

index.delete();

            if (!index.exists())
               {
                   index.mkdir();
               }

आप बुला रहे हैं

 if (!index.exists())
                   {
                       index.mkdir();
                   }

उपरांत

index.delete();

इसका मतलब यह है कि आप फ़ाइल को हटाने के बाद फिर से फ़ाइल बना रहे हैं। फ़ाइल () एक बूलियन मान लौटाता है। यदि आप जांच करना चाहते हैं, तो System.out.println(index.delete());यदि आप प्राप्त करते हैं trueतो इसका मतलब है कि फ़ाइल हटा दी गई है

File index = new File("/home/Work/Indexer1");
    if (!index.exists())
       {
             index.mkdir();
       }
    else{
            System.out.println(index.delete());//If you get true then file is deleted




            if (!index.exists())
               {
                   index.mkdir();// here you are creating again after deleting the file
               }




        }

नीचे दी गई टिप्पणियों से , अद्यतन उत्तर इस तरह है

File f=new File("full_path");//full path like c:/home/ri
    if(f.exists())
    {
        f.delete();
    }
    else
    {
        try {
            //f.createNewFile();//this will create a file
            f.mkdir();//this create a folder
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

Answer 14

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

private void deleteTempFile(File tempFile) {
        try
        {
            if(tempFile.isDirectory()){
               File[] entries = tempFile.listFiles();
               for(File currentFile: entries){
                   deleteTempFile(currentFile);
               }
               tempFile.delete();
            }else{
               tempFile.delete();
            }
        getLogger().info("DELETED Temporal File: " + tempFile.getPath());
        }
        catch(Throwable t)
        {
            getLogger().error("Could not DELETE file: " + tempFile.getPath(), t);
        }
    }

Answer 15

आप FileUtils.deleteDirectory का उपयोग कर सकते हैं । JAVA File.delete () के साथ गैर-खाली फ़ोल्डरों को हटा नहीं सकता है ।

Answer 16

डायरेक्ट्री केवल तभी डिलीट नहीं कर सकती है जब उसमें फाइलें हों ताकि आपको पहले और फिर डायरेक्टरी के अंदर फाइल डिलीट करनी पड़े

public class DeleteFileFolder {

public DeleteFileFolder(String path) {

    File file = new File(path);
    if(file.exists())
    {
        do{
            delete(file);
        }while(file.exists());
    }else
    {
        System.out.println("File or Folder not found : "+path);
    }

}
private void delete(File file)
{
    if(file.isDirectory())
    {
        String fileList[] = file.list();
        if(fileList.length == 0)
        {
            System.out.println("Deleting Directory : "+file.getPath());
            file.delete();
        }else
        {
            int size = fileList.length;
            for(int i = 0 ; i < size ; i++)
            {
                String fileName = fileList[i];
                System.out.println("File path : "+file.getPath()+" and name :"+fileName);
                String fullPath = file.getPath()+"/"+fileName;
                File fileOrFolder = new File(fullPath);
                System.out.println("Full Path :"+fileOrFolder.getPath());
                delete(fileOrFolder);
            }
        }
    }else
    {
        System.out.println("Deleting file : "+file.getPath());
        file.delete();
    }
}

Answer 17

उप निर्देशिका मौजूद है, तो आप पुनरावर्ती कॉल कर सकते हैं

import java.io.File;

class DeleteDir {
public static void main(String args[]) {
deleteDirectory(new File(args[0]));
}

static public boolean deleteDirectory(File path) {
if( path.exists() ) {
  File[] files = path.listFiles();
  for(int i=0; i<files.length; i++) {
     if(files[i].isDirectory()) {
       deleteDirectory(files[i]);
     }
     else {
       files[i].delete();
     }
  }
}
return( path.delete() );
}
}

Answer 18

हम spring-coreनिर्भरता का उपयोग कर सकते हैं ;

boolean result = FileSystemUtils.deleteRecursively(file);

Answer 19

अधिकांश उत्तर (यहां तक ​​कि हाल ही में) JDK वर्गों को संदर्भित करते हुए भरोसा करते हैं File.delete()लेकिन यह एक त्रुटिपूर्ण एपीआई है क्योंकि ऑपरेशन चुपचाप विफल हो सकता है। विधि दस्तावेज़ कहता है:
java.io.File.delete()

ध्यान दें कि जब कोई फ़ाइल नहीं हटाई जा सकती है, तो java.nio.file.Filesकक्षा deleteउसे फेंकने की विधि को परिभाषित करती IOExceptionहै। यह त्रुटि रिपोर्टिंग और निदान करने के लिए उपयोगी है कि किसी फ़ाइल को हटाया क्यों नहीं जा सकता है।

प्रतिस्थापन के रूप में, आपको एक त्रुटि संदेश के साथ Files.delete(Path p) फेंकता है कि एहसान करना चाहिए IOException।

वास्तविक कोड को इस तरह लिखा जा सकता है:

Path index = Paths.get("/home/Work/Indexer1");

if (!Files.exists(index)) {
    index = Files.createDirectories(index);
} else {

    Files.walk(index)
         .sorted(Comparator.reverseOrder())  // as the file tree is traversed depth-first and that deleted dirs have to be empty  
         .forEach(t -> {
             try {
                 Files.delete(t);
             } catch (IOException e) {
                 // LOG the exception and potentially stop the processing

             }
         });
    if (!Files.exists(index)) {
        index = Files.createDirectories(index);
    }
}

Answer 20

आप निम्नानुसार कोशिश कर सकते हैं

  File dir = new File("path");
   if (dir.isDirectory())
   {
         dir.delete();
   }

यदि आपके फ़ोल्डर के अंदर उप फ़ोल्डर हैं, तो आपको उन्हें पुन: हटाने की आवश्यकता हो सकती है।

Answer 21

private void deleteFileOrFolder(File file){
    try {
        for (File f : file.listFiles()) {
            f.delete();
            deleteFileOrFolder(f);
        }
    } catch (Exception e) {
        e.printStackTrace(System.err);
    }
}

Answer 22

        import org.apache.commons.io.FileUtils;

        List<String> directory =  new ArrayList(); 
        directory.add("test-output"); 
        directory.add("Reports/executions"); 
        directory.add("Reports/index.html"); 
        directory.add("Reports/report.properties"); 
        for(int count = 0 ; count < directory.size() ; count ++)
        {
        String destination = directory.get(count);
        deleteDirectory(destination);
        }





      public void deleteDirectory(String path) {

        File file  = new File(path);
        if(file.isDirectory()){
             System.out.println("Deleting Directory :" + path);
            try {
                FileUtils.deleteDirectory(new File(path)); //deletes the whole folder
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        else {
        System.out.println("Deleting File :" + path);
            //it is a simple file. Proceed for deletion
            file.delete();
        }

    }

एक जादू की तरह काम करता है । फ़ोल्डर और फ़ाइलों दोनों के लिए। सलाम :)

Answer 23

इसे दूसरे भाग से निकालें

File index = new File("/home/Work/Indexer1");
if (!index.exists())
{
     index.mkdir();
     System.out.println("Dir Not present. Creating new one!");
}
index.delete();
System.out.println("File deleted successfully");

Answer 24

इनमें से कुछ उत्तर अनावश्यक रूप से लंबे लगते हैं:

if (directory.exists()) {
    for (File file : directory.listFiles()) {
        file.delete();
    }
    directory.delete();
}

उप निर्देशिकाओं के लिए भी काम करता है।

Answer 25

आप इस फ़ंक्शन का उपयोग कर सकते हैं

public void delete()    
{   
    File f = new File("E://implementation1/");
    File[] files = f.listFiles();
    for (File file : files) {
        file.delete();
    }
}

Comments

यह सभी बंद फाइलों के साथ एक निर्देशिका के साथ ठीक काम करता है। लेकिन जब खुली फ़ाइलों के साथ निर्देशिका पर कोशिश की जाती है तो यह काम नहीं करता है। क्या आप मुझे खुली फाइलों के फ़ोल्डर

— इंस्पायर

यह गैर-रिक्त उपनिर्देशिकाओं को नहीं हटाएगा।

— पेंग