জাভাতে পুনরাবৃত্তভাবে ডিরেক্টরিগুলি মুছুন

382

জাভাতে পুনরুক্তি দিয়ে পুরো ডিরেক্টরি মুছে ফেলার কোনও উপায় আছে কি?

সাধারণ ক্ষেত্রে খালি ডিরেক্টরি মুছে ফেলা সম্ভব। তবে যখন বিষয়বস্তু সহ পুরো ডিরেক্টরি মুছে ফেলা যায়, এটি আর এত সহজ নয়।

আপনি জাভাতে সামগ্রিক ডিরেক্টরিগুলি কীভাবে মুছবেন?

java  file-io  filesystems  delete-directory 
— paweloque
সূত্র
4
ফাইল.ডিলেট () এর খালি খালি ডিরেক্টরিতে কল করার পরে কেবল এটি মিথ্যা ফিরিয়ে দেওয়া উচিত।
— বেন এস
আপনি যদি জাভা 8 ব্যবহার করছেন তবে @ রকের উত্তর দেখুন।
— রবিন

উত্তর:

462

আপনার অ্যাপাচি এর কমন্স-আইও পরীক্ষা করা উচিত । এটির একটি ফাইলUtils ক্লাস রয়েছে যা আপনি যা চান তা করবে।

FileUtils.deleteDirectory(new File("directory"));
— স্টিভ কে
সূত্র
3
এই ফাংশনটি সম্ভবত তার উত্তরে এরিকসন প্রদত্ত কোডটি মোড়বে।
— paweloque
14
এটি আরও কিছুটা পুঙ্খানুপুঙ্খ। এটি লিনাক্স / ইউনিক্সে প্রতীকী লিঙ্কগুলির মতো জিনিসগুলি সঠিকভাবে পরিচালনা করে। svn.apache.org/viewvc/commons/proper/io/trunk/src/java/org/…
— স্টিভ কে
1
@ স্টিভ কে, ইউআরএল এখন: svn.apache.org/viewvc/commons/proper/io/trunk/src/main/java/org/…
— রিচার্ড ইবি
— SWE
বাক্সের বাইরে জাভাতে কোনও সুবিধা থাকা অবস্থায় কেন অন্য একটি নির্ভরতা যুক্ত করবেন? এই পৃষ্ঠাতে rok দ্বারা উত্তর দেখুন, অথবা stackoverflow.com/questions/35988192/...
— foo বিন্যাস
190

জাভা 7 এর সাহায্যে আমরা শেষ পর্যন্ত এটি নির্ভরযোগ্য সিমেলিংক সনাক্তকরণের মাধ্যমে করতে পারি। ( এই মুহুর্তে আমি অ্যাপাচি-এর কমন্স-আইওকে নির্ভরযোগ্য সিমলিংক সনাক্তকরণ হিসাবে বিবেচনা করি না, কারণ এটি উইন্ডোজে তৈরি হওয়া লিঙ্কগুলি পরিচালনা করে না mklink।)

ইতিহাসের স্বার্থে, এখানে একটি পূর্ব-জাভা 7 উত্তর রয়েছে, যা সিমলিঙ্কগুলি অনুসরণ করে।

void delete(File f) throws IOException {
  if (f.isDirectory()) {
    for (File c : f.listFiles())
      delete(c);
  }
  if (!f.delete())
    throw new FileNotFoundException("Failed to delete file: " + f);
}
— এরিকসন
সূত্র
11
ফাইল.ডিলেট () এর সেই কার্যকারিতা নেই।
— বেন এস
14
@ ইরিকসন: ফাইলনটফাউন্ডএক্সেপশন মুছে ফেলার ব্যর্থতার জন্য কি খুব কম ব্যতিক্রম নয়? ফাইলটি যদি সত্যিই আর না থাকে, এটি অবশ্যই ইতিমধ্যে মুছে ফেলা হয়েছে, যার অর্থ, শব্দার্থকভাবে, মুছাটি ব্যর্থ হয়নি - এর কিছুই করার ছিল না। এবং যদি এটি অন্য কোনও কারণে ব্যর্থ হয় তবে ফাইলটি খুঁজে পাওয়া যায়নি বলে এটি ছিল না।
— লরেন্স ডল
46
হতে খুব সতর্কতা অবলম্বন । এটি প্রতীকীকরণগুলি ডেরিফারেন্স করবে। আপনি যেমন লিনাক্স, এবং একটি ফোল্ডার থাকে তাহলে fooএকটি লিঙ্ক সহ foo/linkযেমন যে link->/কলিং, delete(new File(foo)) আপনার ফাইল সিস্টেম এর যতটা মুছে ফেলবে যেমন আপনার ব্যবহারকারী অনুমোদিত হয় !!
— মিকুয়েল
4
@ মিকেলটি এর কোনও মানে নেই - কেন আমরা সাবধান হতে চাই? অবশ্যই প্রদত্ত কোডের পয়েন্টটি হ'ল একটি সম্পূর্ণ ডিরেক্টরি মুছে ফেলা, যা এটি প্রদর্শিত হয়। বিপদ এখানে কী তা বুঝতে পারছি না।
— জোহোত 200
12
@ জোহোহট ২০০ আপনি ঠিক বলেছেন, ডিরেক্টরিতে মুছে ফেলা সিমলিংক ডিরেক্টরি মুছে ফেলবে না, কেবলমাত্র সিমলিংক itself ডিরেক্টরি মুছতে প্রকৃতপক্ষে রিডসিমবোলিকলিঙ্ক ব্যবহার করে সিমিলিংকের অনুসরণ করা প্রয়োজন । আমার খারাপ! ভাল স্পটেড
— মিকেল
148

জাভা 7+ এ আপনি Filesক্লাস ব্যবহার করতে পারেন । কোড খুব সহজ:

Path directory = Paths.get("/tmp");
Files.walkFileTree(directory, 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 {
       Files.delete(dir);
       return FileVisitResult.CONTINUE;
   }
});
— টমাসজ ডিজিসিলেওউস্কি
সূত্র
2
এই সমাধানটি খুব মার্জিত বলে মনে হচ্ছে এবং এতে কোনও ডিরেক্টরি ট্রভারসাল যুক্তি নেই!
— জিরো 3
1
"সমুদ্রের গভীরে একটি মুক্তো ডুবুরি সন্ধান করার জন্য"। এটি এখন পর্যন্ত আমার কাছে পাওয়া সর্বাধিক সমাধান রয়েছে। এটি খুঁজে পেতে গভীর ডুব দিতে হয়েছিল। উজ্জ্বল!
— বাসিল মুসা
20
"একটি হ'ল ডির :-) মুছে ফেলার জন্য কোড" খুব সহজ "নয় তবে ওহে এটি শুদ্ধ জাভা আমার গণনার সেরা সমাধান।
— মাদুর
1
অনুগ্রহ করে নোট করুন যে এখানে ব্যবহৃত ওয়াকফিলআউটরি ওভারলোড " প্রতীকী লিঙ্কগুলি অনুসরণ করে না "। ( জাভাদোক : ডকস.ওরাকল.com / জাভাসে / / / ডকস / এপি / জাভা / এনিও / ফাইলে / ))
— স্টিফান
1
আপনার সম্ভবত সম্ভবত super.postVisitDirectory(dir, exc);আপনার postVisitDirectoryপদ্ধতিতে কল করা উচিত , যদি হাঁটার কোনও ডিরেক্টরি তালিকাভুক্ত না করতে পারে blow
— টম অ্যান্ডারসন
68

ওয়ান-লাইনার সলিউশন (জাভা 8) সমস্ত ফাইল এবং ডিরেক্টরি মুছে ফেলার জন্য পুনরাবৃত্তভাবে ডিরেক্টরি শুরু করে:

Files.walk(Paths.get("c:/dir_to_delete/"))
                .map(Path::toFile)
                .sorted((o1, o2) -> -o1.compareTo(o2))
                .forEach(File::delete);

আমরা বিপরীত ক্রমের জন্য একটি তুলনামূলক ব্যবহার করি, অন্যথায় ফাইল :: মুছুন সম্ভবত শূন্যস্থান ডিরেক্টরি মুছে ফেলতে সক্ষম হবে না। সুতরাং, আপনি যদি ডিরেক্টরিগুলি রাখতে চান এবং কেবল ফাইলগুলি মুছতে চান তবে কেবল বাছাই করা () অনুসারে তুলনামূলক অপসারণ করুন বা সম্পূর্ণ বাছাই করা সরান এবং ফাইলগুলি ফিল্টার যুক্ত করুন:

Files.walk(Paths.get("c:/dir_to_delete/"))
                .filter(Files::isRegularFile)
                .map(Path::toFile)
                .forEach(File::delete);
— rok
সূত্র
1
সমস্ত ডিরেক্টরি মুছে ফেলার জন্য আপনাকে প্রথমে সাজানো (সারণি :: তুলনামূলক :: রিভার্সআর্ডার) এ পরিবর্তন করতে হবে। অন্যথায় সন্তানের আগে অভিভাবকত্ব নির্দেশটি অর্ডার করা হয় এবং এটি খালি না হওয়ায় মুছে ফেলা হবে না। জাভা 8 ব্যবহারকারীদের জন্য দুর্দান্ত উত্তর!
— রবিন
1
সঠিক উপায় হ'ল .sorted(Comparator.reverseOrder())প্রস্তাবটি কাজ Comparator::reverseOrderকরে না । দেখুন: stackoverflow.com/questions/43036611/...
— user1156544
4
রবিন, "-o1.compareTo (o2)" এ বিয়োগ সাইন ইন মনোযোগ দিন। এটি .sorted (Comparator.reversOrder) এর মতোই
— রক
ফাইলস.ওয়াকের ক্রমিক কি? অথবা এই উত্তরের জন্য কি খালি নয় ডিরেক্টরিগুলি মুছে ফেলার চেষ্টাটি এড়াতে forEach এর পরিবর্তে প্রত্যেকটি অর্ডার করা দরকার?
— সিলিং
শুধু ব্যবহার করুন: .sorted((f1, f2) -> f2.compareTo(f1)), তুলনা f2সঙ্গে f1পরিবর্তে f1সঙ্গে f2।
— বেটো নেটো
67

জাভা 7 সিমিলিংক হ্যান্ডলিং সহ ডিরেক্টরিগুলি হাঁটার জন্য যোগ করেছে:

import java.nio.file.*;

public static void removeRecursive(Path path) throws IOException
{
    Files.walkFileTree(path, new SimpleFileVisitor<Path>()
    {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                throws IOException
        {
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException
        {
            // try to delete the file anyway, even if its attributes
            // could not be read, since delete-only access is
            // theoretically possible
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException
        {
            if (exc == null)
            {
                Files.delete(dir);
                return FileVisitResult.CONTINUE;
            }
            else
            {
                // directory iteration failed; propagate exception
                throw exc;
            }
        }
    });
}

আমি এটিকে প্ল্যাটফর্ম-নির্দিষ্ট পদ্ধতিগুলি থেকে ফ্যালব্যাক হিসাবে ব্যবহার করি (এই পরীক্ষিত কোডটিতে ):

public static void removeDirectory(Path directory) throws IOException
{
    // does nothing if non-existent
    if (Files.exists(directory))
    {
        try
        {
            // prefer OS-dependent directory removal tool
            if (SystemUtils.IS_OS_WINDOWS)
                Processes.execute("%ComSpec%", "/C", "RD /S /Q \"" + directory + '"');
            else if (SystemUtils.IS_OS_UNIX)
                Processes.execute("/bin/rm", "-rf", directory.toString());
        }
        catch (ProcessExecutionException | InterruptedException e)
        {
            // fallback to internal implementation on error
        }

        if (Files.exists(directory))
            removeRecursive(directory);
    }
}

(সিস্টেম ইউটিগুলি অ্যাপাচি কমন্স ল্যাং থেকে । প্রক্রিয়াগুলি ব্যক্তিগত তবে এর আচরণটি সুস্পষ্ট হওয়া উচিত))

— ট্রেভর রবিনসন
সূত্র
ফাইলস.ওয়ালকফাইলেটি ট্রিটিতে আমি একটি সমস্যা পেয়েছি - এটি পুনরাবৃত্তকরণ মুছার একটি সংস্করণ বাস্তবায়নের জন্য অপর্যাপ্ত যেখানে আপনি অপসারণ না হওয়া অবধি ফাইলগুলি মুছতে থাকুন। এটি একটি ব্যর্থ-দ্রুত সংস্করণের জন্য পর্যাপ্ত, তবে ব্যর্থ-দ্রুত সর্বদা আপনি যা চান তা তা নয় (যেমন আপনি যদি টেম্প ফাইলগুলি সাফ করেন, আপনি এখন মুছে ফেলতে চান, ব্যর্থ-দ্রুত নয়))
— ট্রেজকাজ
কেন সত্য তা আমি দেখছি না। আপনি চাইলে ত্রুটিগুলি পরিচালনা করতে পারেন - আপনার দ্রুত ব্যর্থ হওয়ার প্রয়োজন নেই। আমি কেবলমাত্র ইঙ্গিত করতে পারি যে এটি বর্তমান ডিরেক্টরি চলার সময় তৈরি হওয়া নতুন ফাইলগুলি পরিচালনা করতে পারে না তবে এটি কাস্টম সমাধানের পক্ষে আরও উপযুক্ত একটি অনন্য পরিস্থিতি suited
— ট্রেভর রবিনসন
1
যদি আপনি ভিজিটফাইলে ত্রুটিটি দমন করেন এবং একক ফাইলটিতে ওয়াকফিলটি ট্রি করুন যা ব্যর্থ হয় তবে আপনি কোনও ত্রুটি পান না (সুতরাং ভিজিটফাইলে অবশ্যই ঘটে যাওয়া কোনও ত্রুটি প্রচার করতে হবে )) আপনি যদি কোনও ডিরেক্টরি মুছতে থাকেন এবং একটি ফাইল মুছতে ব্যর্থ হন তবে কেবল কলব্যাক বলা হয় পোস্টভিসিটডাইরেক্টরি। উদাহরণস্বরূপ, আপনি যদি একটি ফাইল পরিদর্শন করতে ত্রুটি পান তবে এটি ডিরেক্টরিতে থাকা অন্য ফাইলগুলিতে যান না। এই আমি বলতে চাই। আমি নিশ্চিত যে এটিকে ঘিরে কাজ করার সম্ভবত কোনও উপায় আছে তবে আমরা এই মুহুর্তে পৌঁছার সাথে সাথে আমরা ইতিমধ্যে একটি traditionalতিহ্যবাহী পুনরাবৃত্ত মোছার রুটিনের চেয়ে বেশি কোড লিখেছি, তাই আমরা এটি ব্যবহারের বিরুদ্ধে সিদ্ধান্ত নিয়েছি।
— ট্রেজকাজ
আপনার 1 ম কোডের জন্য ধন্যবাদ, এটি আমার পক্ষে দরকারী ছিল, তবে আমাকে এটি পরিবর্তন করতে হয়েছিল, কারণ এটি একটি সরল বদ্বীপ পূর্ণ করেনি: আমাকে "পোস্টভিজিটডাইরেক্টরি" এ ব্যতিক্রম উপেক্ষা করতে হবে এবং নির্বিশেষে চালিয়ে যেতে হয়েছিল কারণ নিম্নলিখিত সরল গাছটি সম্পূর্ণরূপে করতে পারেনি মুছে ফেলা হবে: একটি ডিরেক্টরি যার ভিতরে অন্য ডিরেক্টরি ছিল যার মধ্যে একটি ফাইল ছিল। এগুলির সবগুলি উইন্ডোজে যতটা সহজ / সাধারণ হয়।
— ড্রিমস্পেসের রাষ্ট্রপতি
এটি সমস্ত একটি java.nio.file.DirectoryNotEmptyException থেকে শুরু হয়েছিল। ভিজিফেইলফয়েল ব্যবহৃত হয় এমন কেসটি আমি খুঁজে পেয়েছি। যদি আপনার ডিরেক্টরি কাঠামোর উইন্ডোতে একটি জংশন ধরণের লিঙ্ক থাকে। এটি আপনাকে 2 টি সমস্যার কারণ হতে পারে: *) ফাইলস.ওয়াকফাইলেফ্রিটি জাংশনে লিঙ্কটি অনুসরণ করে এবং সেখানকার সবকিছু মুছে দেয়। *) যদি জংশন টার্গেট ডিরেক্টরিটি ইতিমধ্যে মুছে ফেলা হয় তবে ফাইলসওয়াকফাইলেট্রি দ্বারা লিঙ্কটি বিশ্লেষণ করে NoSuchFileException এর সাথে ব্যর্থ হয় যা ভিজিটফেইলে ধরা হয়েছে।
— Andres Luuk
34

কেবলমাত্র দেখেছে আমার সমাধানটি কমবেশি এরিকসনের মতোই, কেবল একটি স্থির পদ্ধতি হিসাবে প্যাকেজড। এটিকে কোথাও ফেলে দিন, এটি অ্যাপাচি কমন্সের সমস্ত কিছুর জন্য ইনস্টল করার চেয়ে অনেক হালকা ওজন (যা আপনি দেখতে পাচ্ছেন) বেশ সহজ।

public class FileUtils {
    /**
     * By default File#delete fails for non-empty directories, it works like "rm". 
     * We need something a little more brutual - this does the equivalent of "rm -r"
     * @param path Root File Path
     * @return true iff the file and all sub files/directories have been removed
     * @throws FileNotFoundException
     */
    public static boolean deleteRecursive(File path) throws FileNotFoundException{
        if (!path.exists()) throw new FileNotFoundException(path.getAbsolutePath());
        boolean ret = true;
        if (path.isDirectory()){
            for (File f : path.listFiles()){
                ret = ret && deleteRecursive(f);
            }
        }
        return ret && path.delete();
    }
}
— Paulitex
সূত্র
20

স্ট্যাক সহ এবং পুনরাবৃত্তির পদ্ধতি ছাড়াই একটি সমাধান:

File dir = new File("/path/to/dir");
File[] currList;
Stack<File> stack = new Stack<File>();
stack.push(dir);
while (! stack.isEmpty()) {
    if (stack.lastElement().isDirectory()) {
        currList = stack.lastElement().listFiles();
        if (currList.length > 0) {
            for (File curr: currList) {
                stack.push(curr);
            }
        } else {
            stack.pop().delete();
        }
    } else {
        stack.pop().delete();
    }
}
— trianam
সূত্র
2
স্ট্যাক ব্যবহারের জন্য +1। এটি এমন ডিরেক্টরিগুলির সাথে কাজ করবে যেখানে নেস্টেড সাব-ডাইরেক্টরিগুলির গভীর স্তর রয়েছে তবে অন্যান্য স্ট্যাক-ভিত্তিক পদ্ধতি ব্যর্থ হবে।
— নাথান ওসমান
4
আপনার প্রায়শই কয়েক শতাধিক কল কলকে বাসা বাঁধতে সমস্যা হয় না তা দেখে আমার মনে হয় আপনি অনেক আগে ফাইল সিস্টেম বিধিনিষেধে চলে যেতে পারেন।
— বোম্বে
2
list*ক্লাসের জন্য পদ্ধতিগুলি সম্পর্কে সতর্কতা অবলম্বন করুন java.io.File। জাভাডোকস থেকে: "যদি এই বিমূর্ত পথের নামটি ডিরেক্টরিকে বোঝায় না বা আই / ও ত্রুটি দেখা দেয় তবে নালটি ফিরে আসে।" সুতরাং: if (currList.length > 0) {হয়ে যায়if (null != currList && currList.length > 0) {
— কেভিনার্পে
1
আমি স্ট্যাকের পরিবর্তে একটি অ্যারেডেক ব্যবহার করি যা কিছুটা দ্রুত। (আনইনক্রোনাইজড)
— উইটজে
15

পেয়ারা 9Files.deleteRecursively(File) পর্যন্ত পেয়ারা সমর্থন করেছিল ।

পেয়ারা 10 থেকে :

অননুমোদিত। এই পদ্ধতিটি দুর্বল সিমলিংক সনাক্তকরণ এবং জাতি অবস্থার সাথে ভুগছে। এই বৈশিষ্ট্য শুধুমাত্র যেমন একটি অপারেটিং সিস্টেমের কমান্ড আউট shelling দ্বারা উপযুক্ত সমর্থিত হতে পারে rm -rfবা del /s। এই পদ্ধতিটি পেয়ারা থেকে গুয়ারা রিলিজ 11.0 এ মুছে ফেলার কথা।

সুতরাং, পেয়ারা 11 এ জাতীয় কোনও পদ্ধতি নেই ।

— অ্যান্ড্রু ম্যাককিনলে
সূত্র
6
খুব খারাপ. শেলিং আউট মনে হচ্ছে কিছু অশোধিত এবং পোর্টেবল নয়। যদি অ্যাপাচি কমন্স সংস্করণটি সঠিকভাবে কাজ করে তবে সম্ভবত এটি কার্যকর করা অসম্ভব।
— অ্যান্ড্রু ম্যাককিনলে
6
@ অ্যান্ড্রু অ্যাপাচি কমন্স বাস্তবায়নের ক্ষেত্রে যেমন পেয়ারা তাদের বাস্তবায়ন সরিয়ে ফেলছে
— orip
অ্যাপাচি কমন্স সংস্করণ সিমলিঙ্কগুলি সনাক্ত করে এবং কেবল ফাইলের বাচ্চাদেরকে অতিক্রম করে না।
— আজাক্স
5
পেয়ারা 21.0 এটিকে MoreFiles.deleteRecursively () হিসাবে যুক্ত করেছে ।
— রবার্ট ফ্লেমিং
12 
for(Path p : Files.walk(directoryToDelete).
        sorted((a, b) -> b.compareTo(a)). // reverse; files before dirs
        toArray(Path[]::new))
{
    Files.delete(p);
}

অথবা আপনি যদি পরিচালনা করতে চান IOException:

Files.walk(directoryToDelete).
    sorted((a, b) -> b.compareTo(a)). // reverse; files before dirs
    forEach(p -> {
        try { Files.delete(p); }
        catch(IOException e) { /* ... */ }
      });
— user3669782
সূত্র
2
এটি আমাকে স্কেল সংস্করণে আসতে সহায়তা করেছে:Files.walk(path).iterator().toSeq.reverse.foreach(Files.delete)
— জেমস ওয়ার্ড
বাছাই করা কি সত্যিই প্রয়োজনীয়? walkপদ্ধতি ইতিমধ্যে গভীরতা প্রথম ট্র্যাভেরসাল গ্যারান্টী বা নিশ্চয়তা দিচ্ছে।
— ভিজিআর
তুলনাকারী পুনর্ব্যবহারযোগ্য হতে পারে Collections.reverseOrder()তাই আপনার কোড for (Path p : Files.walk(directoryToDelete).sorted(reverseOrder()).toArray(Path[]::new))ধরে নেওয়া হবে যে এটি স্থিতিশীলভাবে আমদানি করা হয়েছে।
— namero999
@ namero999 আপনার মানে Comparator.reverseOrder? Files.walk(dir) .sorted(Comparator.reverseOrder()) .toArray(Path[]::new))
— জেফ
@
— জেফ
11 
public void deleteRecursive(File path){
    File[] c = path.listFiles();
    System.out.println("Cleaning out folder:" + path.toString());
    for (File file : c){
        if (file.isDirectory()){
            System.out.println("Deleting file:" + file.toString());
            deleteRecursive(file);
            file.delete();
        } else {
            file.delete();
        }
    }
    path.delete();
}
— AdamOutler
সূত্র
5
বুলিয়ান রিটার্ন মান এবং কোনও সদৃশ সহ বর্ধিত সংস্করণ: পেস্টবিন.
— com/ পাকজাইজুএক্সএক্স
9 
static public void deleteDirectory(File path) 
{
    if (path == null)
        return;
    if (path.exists())
    {
        for(File f : path.listFiles())
        {
            if(f.isDirectory()) 
            {
                deleteDirectory(f);
                f.delete();
            }
            else
            {
                f.delete();
            }
        }
        path.delete();
    }
}
— vladicho
সূত্র
দুর্দান্ত কোড, তবে একটি বাগ রয়েছে, ঠিক করার পরে এটি কার্যকর হয়। লাইন f.delete()অধীনে deleteDirectory(f)ইচ্ছা NoSuchFileException ছোঁড়ার কারণ deleteDirectory(f)ইতিমধ্যে যে ফাইল মুছে দিন। প্রতিটি ডিরেক্টরি একটি পাসে পরিণত হবে deleteDirectory(f)এবং এর মাধ্যমে মুছে ফেলা হবে path.delete()। অতএব, আমাদের দরকার নেই f.delete()এ if f.isDerectoryঅধ্যায়। সুতরাং, কেবল মুছে ফেলুন মুছে ফেলুন ডিরেক্টরি এর f.delete();অধীনে (চ) এবং এটি কার্যকর হবে।
— ট্রিইউ এনগুইন
5

সিমলিংক এবং উপরের কোডটি দিয়ে ব্যর্থ হওয়ার দুটি উপায় ... এবং সমাধানটি জানেন না।

উপায় # 1

একটি পরীক্ষা তৈরি করতে এটি চালান:

echo test > testfile
mkdir dirtodelete
ln -s badlink dirtodelete/badlinktodelete

এখানে আপনি আপনার পরীক্ষার ফাইল এবং পরীক্ষা ডিরেক্টরিটি দেখুন:

$ ls testfile dirtodelete
testfile

dirtodelete:
linktodelete

তারপরে আপনার কমন্স-আইও ডিলিট ডিরেক্টরি () চালান। ফাইলটি খুঁজে পাওয়া যায়নি বলে এটি ক্রাশ করে। অন্যান্য উদাহরণগুলি এখানে কী করে তা নিশ্চিত নয়। লিনাক্স আরএম কমান্ডটি কেবল লিঙ্কটি মুছে ফেলত, এবং ডিরেক্টরিতে rm -rও করে দেয়।

Exception in thread "main" java.io.FileNotFoundException: File does not exist: /tmp/dirtodelete/linktodelete

উপায় # 2

একটি পরীক্ষা তৈরি করতে এটি চালান:

mkdir testdir
echo test > testdir/testfile
mkdir dirtodelete
ln -s ../testdir dirtodelete/dirlinktodelete

এখানে আপনি আপনার পরীক্ষার ফাইল এবং পরীক্ষা ডিরেক্টরিটি দেখুন:

$ ls dirtodelete testdir
dirtodelete:
dirlinktodelete

testdir:
testfile

তারপরে আপনার কমন্স-আইও ডিলিট ডিরেক্টরি () বা পোস্ট কোড কোড লোকেদের চালান। এটি কেবল ডিরেক্টরিটিই মুছে দেয় না, তবে আপনার টেস্টফিল যা ডিরেক্টরিটির বাইরে রয়েছে মোছা হচ্ছে। (এটি ডিরেক্টরিকে স্পষ্টভাবে উল্লেখ করে এবং সামগ্রীগুলি মুছে দেয়)। rm -r কেবলমাত্র লিঙ্কটি মুছবে। আপনার এই জাতীয় কিছু ব্যবহার করতে হবে যা ডিফেরেন্সযুক্ত ফাইলগুলি মুছুন: "সন্ধান করুন -L ম্যানডোলেটলেট-টাইপ এফ-এক্সেক আরএম {} \;"।

$ ls dirtodelete testdir
ls: cannot access dirtodelete: No such file or directory
testdir:
— পিটার
সূত্র
4

আপনি ব্যবহার করতে পারেন:

org.apache.commons.io.FileUtils.deleteQuietly(destFile);

কোনও ফাইল মুছে ফেলে, কখনও ব্যতিক্রম ছুঁড়ে না ফেলে। যদি ফাইল ডিরেক্টরি হয় তবে এটি এবং সমস্ত উপ-ডিরেক্টরি মুছুন। ফাইল.ডিলেট () এবং এই পদ্ধতির মধ্যে পার্থক্য হ'ল: মুছে ফেলার জন্য একটি ডিরেক্টরি খালি থাকতে হবে না। কোনও ফাইল বা ডিরেক্টরি মুছতে না পারলে কোনও ব্যতিক্রম ছুঁড়ে দেওয়া হয় না।

— জান-তেরজে সেরেনসেন
সূত্র
4

একটি সর্বোত্তম সমাধান যা ব্যতিক্রমটিকে নিয়মিতভাবে পদ্ধতির সাথে পরিচালনা করে যে কোনও পদ্ধতি থেকে নিক্ষিপ্ত ব্যতিক্রমগুলি সর্বদা বর্ণনা করে যে সেই পদ্ধতিটি কী করতে চেষ্টা করেছে (এবং ব্যর্থ হয়েছে):

private void deleteRecursive(File f) throws Exception {
    try {
        if (f.isDirectory()) {
            for (File c : f.listFiles()) {
                deleteRecursive(c);
            }
        }
        if (!f.delete()) {
            throw new Exception("Delete command returned false for file: " + f);
        }
    } 
    catch (Exception e) {
        throw new Exception("Failed to delete the folder: " + f, e);
    }
}
— AgilePro
সূত্র
3

উত্তরাধিকার প্রকল্পগুলিতে, আমার নেটিভ জাভা কোড তৈরি করা দরকার। আমি এই কোডটি পলিটেক্স কোডের মতো তৈরি করি। ওটা দেখ:

public class FileHelper {

   public static boolean delete(File fileOrFolder) {
      boolean result = true;
      if(fileOrFolder.isDirectory()) {
         for (File file : fileOrFolder.listFiles()) {
            result = result && delete(file);
         }
      }
      result = result && fileOrFolder.delete();
      return result;
   } 
}

এবং ইউনিট পরীক্ষা:

public class FileHelperTest {

    @Before
    public void setup() throws IOException {
       new File("FOLDER_TO_DELETE/SUBFOLDER").mkdirs();
       new File("FOLDER_TO_DELETE/SUBFOLDER_TWO").mkdirs();
       new File("FOLDER_TO_DELETE/SUBFOLDER_TWO/TEST_FILE.txt").createNewFile();
    }

    @Test
    public void deleteFolderWithFiles() {
       File folderToDelete = new File("FOLDER_TO_DELETE");
       Assert.assertTrue(FileHelper.delete(folderToDelete));
       Assert.assertFalse(new File("FOLDER_TO_DELETE").exists());
    }

}
— Wendel,
সূত্র
3

কোডের নীচে পুনরাবৃত্তভাবে প্রদত্ত ফোল্ডারে সমস্ত সামগ্রী মুছুন। 

boolean deleteDirectory(File directoryToBeDeleted) {
    File[] allContents = directoryToBeDeleted.listFiles();
    if (allContents != null) {
        for (File file : allContents) {
            deleteDirectory(file);
        }
    }
    return directoryToBeDeleted.delete();
}
— প্রণব ভিআর
সূত্র
2

এখানে একটি খালি হাড়গুলির একটি প্রধান পদ্ধতি যা একটি কমান্ড লাইন আর্গুমেন্ট গ্রহণ করে, আপনার নিজের ত্রুটিটি পরীক্ষা করতে বা আপনাকে কীভাবে উপযুক্ত দেখায় তা মোল্ড করার প্রয়োজন হতে পারে।

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

public class DeleteFiles {

/**
 * @param intitial arguments take in a source to read from and a 
 * destination to read to
 */
    public static void main(String[] args)
                     throws FileNotFoundException,IOException {
        File src = new File(args[0]);
        if (!src.exists() ) {
            System.out.println("FAILURE!");
        }else{
            // Gathers files in directory
            File[] a = src.listFiles();
            for (int i = 0; i < a.length; i++) {
                //Sends files to recursive deletion method
                fileDelete(a[i]);
            }
            // Deletes original source folder
            src.delete();
            System.out.println("Success!");
        }
    }

    /**
     * @param srcFile Source file to examine
     * @throws FileNotFoundException if File not found
     * @throws IOException if File not found
     */
    private static void fileDelete(File srcFile)
                     throws FileNotFoundException, IOException {
        // Checks if file is a directory
        if (srcFile.isDirectory()) {
            //Gathers files in directory
            File[] b = srcFile.listFiles();
            for (int i = 0; i < b.length; i++) {
                //Recursively deletes all files and sub-directories
                fileDelete(b[i]);
            }
            // Deletes original sub-directory file
            srcFile.delete();
        } else {
            srcFile.delete();
        }
    }
}

আমি আশা করি এটি সাহায্য করবে!

— আঠা
সূত্র
1

এই সমস্যার সমাধান হতে পারে এরিকসনের উত্তর থেকে কোডটি ব্যবহার করে ফাইল শ্রেণীর মুছে ফেলার পদ্ধতিটি পুনরায় প্রয়োগ করা:

public class MyFile extends File {

  ... <- copy constructor

  public boolean delete() {
    if (f.isDirectory()) {
      for (File c : f.listFiles()) {
        return new MyFile(c).delete();
      }
    } else {
        return f.delete();
    }
  }
}
— paweloque
সূত্র
1
"Rm", "rmdir", এবং "del" এর মতো বেশিরভাগ কমান্ড শেল ইউটিলিটির আচরণ অনুকরণ করার জন্য এটি প্রয়োগ করা হয়েছে বলে আমি মনে করি। দুটি বিকল্পের মধ্যে, বর্তমান বাস্তবায়ন অবশ্যই সামগ্রিক আশ্চর্য (এবং রাগ) সম্ভাবনা হ্রাস করে। এটি পরিবর্তন হতে যাচ্ছে না।
— এরিকসন
4
সাধারণত, কেবলমাত্র জাভা জেআরই প্যাকেজগুলি আমি প্রসারিত দেখতে পাই সেগুলি সুইং থেকে। সাধারণত, java.io.File এর মতো অন্যান্য শ্রেণি প্রসারিত করা একটি খারাপ ধারণা, কারণ এতে অপ্রত্যাশিত উপায়ে জিনিসগুলির কারণ হওয়ার সম্ভাবনা রয়েছে।
— এডি
1

কমন্স আইও এবং <জাভা এসই 7 ছাড়াই 

public static void deleteRecursive(File path){
            path.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    if (pathname.isDirectory()) {
                        pathname.listFiles(this);
                        pathname.delete();
                    } else {
                        pathname.delete();
                    }
                    return false;
                }
            });
            path.delete();
        }
— আলেকজান্ডার সিডিকভ ফেফিফ
সূত্র
0

ফাইল.ডিলেট () ব্যবহার করে ফাইলগুলি সহজে মুছে ফেলা যায়, তবে ডিরেক্টরিগুলি মোছার জন্য খালি থাকতে হবে। এটি সহজেই করতে পুনরাবৃত্তি ব্যবহার করুন। উদাহরণ স্বরূপ:

public static void clearFolders(String[] args) {
        for(String st : args){
            File folder = new File(st);
            if (folder.isDirectory()) {
                File[] files = folder.listFiles();
                if(files!=null) { 
                    for(File f: files) {
                        if (f.isDirectory()){
                            clearFolders(new String[]{f.getAbsolutePath()});
                            f.delete();
                        } else {
                            f.delete();
                        }
                    }
                }
            }
        }
    }
— ভরত সিং
সূত্র
0

আমি এই রুটিনটিকে কোড করেছিলাম যাতে নিরাপদ ব্যবহারের জন্য 3 টি সুরক্ষা মানদণ্ড রয়েছে।

package ch.ethz.idsc.queuey.util;

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

/** recursive file/directory deletion
 * 
 * safety from erroneous use is enhanced by three criteria
 * 1) checking the depth of the directory tree T to be deleted
 * against a permitted upper bound "max_depth"
 * 2) checking the number of files to be deleted #F
 * against a permitted upper bound "max_count"
 * 3) if deletion of a file or directory fails, the process aborts */
public final class FileDelete {
    /** Example: The command
     * FileDelete.of(new File("/user/name/myapp/recordings/log20171024"), 2, 1000);
     * deletes given directory with sub directories of depth of at most 2,
     * and max number of total files less than 1000. No files are deleted
     * if directory tree exceeds 2, or total of files exceed 1000.
     * 
     * abort criteria are described at top of class
     * 
     * @param file
     * @param max_depth
     * @param max_count
     * @return
     * @throws Exception if criteria are not met */
    public static FileDelete of(File file, int max_depth, int max_count) throws IOException {
        return new FileDelete(file, max_depth, max_count);
    }

    // ---
    private final File root;
    private final int max_depth;
    private int removed = 0;

    /** @param root file or a directory. If root is a file, the file will be deleted.
     *            If root is a directory, the directory tree will be deleted.
     * @param max_depth of directory visitor
     * @param max_count of files to delete
     * @throws IOException */
    private FileDelete(final File root, final int max_depth, final int max_count) throws IOException {
        this.root = root;
        this.max_depth = max_depth;
        // ---
        final int count = visitRecursively(root, 0, false);
        if (count <= max_count) // abort criteria 2)
            visitRecursively(root, 0, true);
        else
            throw new IOException("more files to be deleted than allowed (" + max_count + "<=" + count + ") in " + root);
    }

    private int visitRecursively(final File file, final int depth, final boolean delete) throws IOException {
        if (max_depth < depth) // enforce depth limit, abort criteria 1)
            throw new IOException("directory tree exceeds permitted depth");
        // ---
        int count = 0;
        if (file.isDirectory()) // if file is a directory, recur
            for (File entry : file.listFiles())
                count += visitRecursively(entry, depth + 1, delete);
        ++count; // count file as visited
        if (delete) {
            final boolean deleted = file.delete();
            if (!deleted) // abort criteria 3)
                throw new IOException("cannot delete " + file.getAbsolutePath());
            ++removed;
        }
        return count;
    }

    public int deletedCount() {
        return removed;
    }

    public void printNotification() {
        int count = deletedCount();
        if (0 < count)
            System.out.println("deleted " + count + " file(s) in " + root);
    }
}
— datahaki
সূত্র
0

ঠিক আছে, আসুন একটি উদাহরণ ধরে নেওয়া যাক,

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

public class DeleteDirectory
{
   private static final String folder = "D:/project/java";

   public static void main(String[] args) throws IOException
   {
      File fl = new File(folder);
      if(!fl.exists()) // checking if directory exists
      {
         System.out.println("Sorry!! directory doesn't exist.");
      }
      else
      {
         DeleteDirectory dd = new DeleteDirectory();
         dd.deleteDirectory(fl);
      }
   }

   public void deleteDirectory(File file) throws IOException
   {
      if(file.isDirectory())
      {
         if(file.list().length == 0)
         { 
            deleteEmptyDirectory(file); // here if directory is empty delete we are deleting
         }
         else
         {
            File fe[] = file.listFiles();
            for(File deleteFile : fe)
            {
               deleteDirectory(deleteFile); // recursive call
            }
            if(file.list().length == 0)
            {
               deleteEmptyDirectory(file);
            }
         }
      }
      else
      {
         file.delete();
         System.out.println("File deleted : " + file.getAbsolutePath());
      }
   }

   private void deleteEmptyDirectory(File fi)
   {
      fi.delete();
      System.out.println("Directory deleted : " + fi.getAbsolutePath());
   }
}

আরও তথ্যের জন্য নীচের সংস্থানসমূহ দেখুন

ডিরেক্টরি মুছুন

— শিব
সূত্র
0

rm -rfচেয়ে অনেক বেশি পারফরম্যান্ট ছিল FileUtils.deleteDirectory।

ব্যাপক বেঞ্চমার্কিংয়ের পরে, আমরা দেখতে পেলাম যে ব্যবহারটি ব্যবহারের rm -rfচেয়ে বহুগুণ দ্রুত ছিলFileUtils.deleteDirectory ।

অবশ্যই, আপনার যদি একটি ছোট বা সাধারণ ডিরেক্টরি থাকে তবে এটি কোনও ব্যাপার নয় তবে আমাদের ক্ষেত্রে আমাদের একাধিক গিগাবাটি এবং গভীরভাবে নেস্টেড সাব ডিরেক্টরি রয়েছে যেখানে এটি 10 ​​মিনিটের সাথে FileUtils.deleteDirectoryএবং কেবল 1 মিনিটের সাথে লাগবে rm -rf।

এটি করার জন্য এখানে আমাদের রুক্ষ জাভা বাস্তবায়ন: 

// Delete directory given and all subdirectories and files (i.e. recursively).
//
static public boolean deleteDirectory( File file ) throws IOException, InterruptedException {

    if ( file.exists() ) {

        String deleteCommand = "rm -rf " + file.getAbsolutePath();
        Runtime runtime = Runtime.getRuntime();

        Process process = runtime.exec( deleteCommand );
        process.waitFor();

        return true;
    }

    return false;

}

আপনি বড় বা জটিল ডিরেক্টরি নিয়ে কাজ করছেন যদি চেষ্টা করা মূল্যবান।

— জোশুয়া পিন্টার
সূত্র
এই ক্রস-প্ল্যাটফর্ম কাজ করে ??
— ওয়ান ক্রিকেটার
@ ক্রিকেট_007 কোন প্ল্যাটফর্ম?
— জোশুয়া পিন্টার
উইন্ডোজ? OpenWrt? বাসদ?
— ওয়ান ক্রিকেটার
1
@ ক্রিকেট_007 অবশ্যই উইন্ডোজ নয়। এটি অ্যান্ড্রয়েড এবং ম্যাকোজে পরীক্ষিত হয়েছিল এবং ব্যবহৃত হয়েছিল।
— জোশুয়া পিন্টার
0

পেয়ারা এক মাছ ধরার নৌকা প্রদান করে: MoreFiles.deleteRecursively()।

ভাগ করা অনেক উদাহরণের থেকে পৃথক, এটি প্রতীকী লিঙ্কগুলির জন্য অ্যাকাউন্ট করে এবং সরবরাহকৃত পথের বাইরে ফাইলগুলি (ডিফল্টরূপে) মুছবে না।

— dimo414
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.