జావాలో ఫైల్‌ను తొలగించండి

మీరు పనికిరాని ఫైల్‌లను వదిలించుకోవాలనుకుంటే, జావా పద్ధతులను ఉపయోగించి వాటిని తొలగించండి. జావాలో ఫైల్‌లు మరియు డైరెక్టరీలను తీసివేయడం అనేది సరళమైన ప్రక్రియ. టాస్క్‌ను నిర్వహించడానికి అనేక రకాల పద్ధతులు ఉన్నాయి - డెవలపర్‌లు తమకు అత్యంత సౌకర్యవంతంగా ఉండేదాన్ని ఎంచుకోవచ్చు. మీ కోడ్‌ను విచ్ఛిన్నం చేయకుండానే అవసరం లేని జావా ఫైల్‌లను వదిలించుకోవడానికి ఇక్కడ ఒక చిన్న గైడ్ ఉంది. ప్రారంభిద్దాం.

java.io.File.Delete() పద్ధతితో జావాలో ఫైల్‌ను ఎలా తొలగించాలి

మీరు బ్రాకెట్లలో ఉంచిన పాత్‌నేమ్‌కు సరిపోలే డైరెక్టరీని లేదా ఫైల్‌ను తొలగించడానికి మీరు ఈ పద్ధతిని ఉపయోగించవచ్చు. డైరెక్టరీని తొలగించాలంటే, ఫైల్ ఏదీ కలిగి ఉండాల్సిన అవసరం లేదని గుర్తుంచుకోండి. ఉపయోగించి జావాలో ఫైల్‌ను ఎలా తొలగించాలో చూద్దాం File.Delete().

java.io.File.Delete()ని ప్రకటిస్తోంది

అనవసరమైన ఫైల్‌ను వదిలించుకోవడానికి మీరు పద్ధతిని ఎలా ప్రకటిస్తారో ఇక్కడ ఉంది:

// Java code for file deletion  
import java.io.*; 
  
public class Test 
{ 
    public static void main(String[] args) 
    { 
        File file = new File("C:\\Users\\Admin\\Files\\1.txt"); 
          
        if(file.delete()) 
        { 
            System.out.println("File deleted successfully"); 
        } 
        else
        { 
            System.out.println("Failed to delete the file"); 
        } 
    } 
}

మీరు ఫైల్‌ని యాక్సెస్ చేయగలిగితే మరియు అది ఉనికిలో ఉన్నట్లయితే, మీరు సంబంధిత రిటర్న్‌ను పొందుతారు. విఫలమైన సందర్భంలో, మీరు “ఫైల్‌ను తొలగించడంలో విఫలమైంది” హెచ్చరికను పొందుతారు.

జావా ఫైల్‌లను తీసివేయడానికి java.nio.files.deleteIfExists()ని ఉపయోగించడం

ఈ పద్ధతి జావా డెవలపర్‌లకు దాని మార్గాన్ని పేర్కొనడం ద్వారా ఫైల్‌ను తొలగించడానికి సహాయపడుతుంది. కు అదేవిధంగా java.io.FileDelete(), ఫైల్ యాక్సెస్ చేయబడి మరియు విజయవంతంగా తొలగించబడినట్లయితే, పద్ధతి నిజమైనదిగా చూపబడుతుంది మరియు ఏదైనా తప్పు జరిగితే వైఫల్యం అవుట్‌పుట్‌ను చూపుతుంది. వైఫల్యానికి అత్యంత సాధారణ కారణం java.nio.files.deleteIfExists()తప్పు మార్గం పేరు - సరళంగా చెప్పాలంటే, మీరు పేర్కొన్న డైరెక్టరీలో సరిపోలే పారామితులతో ఫైల్ లేదు. ఉంటే లోతైన అవగాహన పొందడానికి java.nio.files.deleteIfExists(), ఇది వివిధ ఫైల్ రకాలను ఎలా ప్రాసెస్ చేస్తుందో చూద్దాం:

• సింబాలిక్ లింక్‌లు - లింక్, దాని వెనుక ఉన్న ఫైల్ కాదు, తొలగించబడుతుంది.
• డైరెక్టరీలు - డైరెక్టరీ ఖాళీగా ఉన్న వెంటనే లేదా ప్రత్యేక ఎంట్రీలను కలిగి ఉన్న వెంటనే విజయవంతంగా తొలగించబడుతుంది (పద్ధతి యొక్క కొన్ని స్పెసిఫికేషన్‌లకు మాత్రమే సంబంధించినది).
• ఫైల్‌లు - చాలా సందర్భాలలో, మీరు పద్ధతిలో పేర్కొన్న మార్గం సరైనది మరియు మీరు ఫైల్‌కి ప్రాప్యత కలిగి ఉన్నంత వరకు, అది విజయవంతంగా తొలగించబడుతుంది. అయితే, కొన్ని ఆపరేటింగ్ సిస్టమ్‌ల స్పెసిఫికేషన్‌లు డెవలపర్‌లు ప్రస్తుతం తెరిచిన ఫైల్‌లను తొలగించడానికి అనుమతించవు.

java.niofile.deleteIfExistsని ప్రకటిస్తోంది

పద్ధతిని ప్రకటించడం సూటిగా ఉంటుంది - దాని సాధారణ వాక్యనిర్మాణాన్ని పరిశీలిద్దాం.

public static boolean deleteIfExists(Path path)
                   throws IOException

java.niofile.deleteIfExists యొక్క పారామితులు

పద్ధతిని అమలు చేయడానికి డెవలపర్ పేర్కొనవలసిన ఒకే పరామితి ఉంది - అతను సిస్టమ్ నుండి తీసివేయాలనుకుంటున్న ఫైల్‌కి మార్గం.

java.niofile.deleteIfExists తిరిగి

పద్ధతికి రెండు రిటర్న్ విలువలు ఉన్నాయి:

• నిజమే, ఫైల్ సజావుగా తొలగించబడినప్పుడు.
• తప్పు, ప్రక్రియలో లోపం ఉన్నట్లయితే (డైరెక్టరీ ఖాళీగా లేదు, ఫైల్ ఉనికిలో లేదు, డెవలపర్‌కు అవసరమైన అనుమతులు లేవు మొదలైనవి).

java.niofile.deleteIfExists మినహాయింపులు

మినహాయింపుల విషయానికొస్తే, డెవలపర్లు తమను తాము బ్రేస్ చేసుకునేందుకు మూడు ఉదాహరణల దృశ్యాలు ఉన్నాయి:

• DirectoryNotEmptyException - పేరు సూచించినట్లుగా, మీ డైరెక్టరీలో ఫీల్డ్ ఉందని దీని అర్థం. మీరు వాటిని వేరే చోటికి తరలించిన తర్వాత, మీరు డైరెక్టరీ తొలగింపును విజయవంతంగా పూర్తి చేయగలుగుతారు.
• సెక్యూరిటీ మినహాయింపు - మీ పరికరంలో సెక్యూరిటీ మేనేజర్ ఇన్‌స్టాల్ చేయబడితే, ఫైల్ తొలగింపు పద్ధతి ద్వారా భర్తీ చేయబడుతుంది SecurityManager.checkdelete(String). ఫలితంగా, డెవలపర్‌కు మినహాయింపు హెచ్చరిక వస్తుంది.
• IOException I/O ఎర్రర్‌లతో సంబంధం కలిగి ఉంటుంది - హార్డ్ డ్రైవ్ అననుకూలత, కాలం చెల్లిన డ్రైవర్ ఎంపిక మొదలైనవి.

deleteIfExists()ని ఉపయోగించే ఉదాహరణలు

// Java program to show deleteIfExists() file handling
// java.nio.file.Files.deleteIfExists() method
  
import java.io.IOException;
import java.nio.file.*;
  
public class GFG {
    public static void main(String[] args)
    {
  
        // create object of Path
        Path path
            = Paths.get("D:\\Work\\Test\\file1.txt");
  
        // deleteIfExists File
        try {
  
            Files.deleteIfExists(path);
        }
        catch (IOException e) {
  
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

ఉదాహరణ #2

/ Sample Java deletion program
// java.nio.file.Files.deleteIfExists() method
  
import java.io.IOException;
import java.nio.file.*;
  
public class GFG {
    public static void main(String[] args)
    {
  
        // create an object of Path
        Path pathOfFile
            = Paths.get("D:\\Work\\Test\\"
                        + "text1.txt");
  
        // delete File if file exists
        try {
  
            boolean result
                = Files.deleteIfExists(pathOfFile);
  
            if (result)
                System.out.println("File is deleted");
            else
                System.out.println("File does not exists");
        }
        catch (IOException e) {
  
            // TODO Auto-generated catch block
            e.printStackTrace();

ముగింపు

జావాలో ఫైల్‌ను తొలగించడానికి ఇవి ప్రధాన మార్గాలు. అవి ఒకే పారామితులను కలిగి ఉన్నందున, వాటిని పరస్పరం మార్చుకోవడానికి సంకోచించకండి. జావా ఫైల్ తొలగింపును రెండుసార్లు ప్రాక్టీస్ చేసిన తర్వాత, మీరు ఖచ్చితంగా దాని హ్యాంగ్‌ను కలిగి ఉంటారు.