ජාවා හි ගොනුවක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

ජාවා ( පර්ල්ස් වලට සමාන -e $filename) කියවීම සඳහා එය විවෘත කිරීමට පෙර ගොනුවක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද ?

SO හි ඇති එකම සමාන ප්‍රශ්නය ගොනුව ලිවීම හා සම්බන්ධ වන අතර මෙයට පිළිතුරු FileWriterසපයන්නේ පැහැදිලිවම මෙහි අදාළ නොවේ.

හැකි නම්, සමහර "ගොනුවක් විවෘත කිරීමට සහ පිටපතේ 'ගොනුවක් නැත' යන්න ඔබ පරික්ෂා කරන ව්‍යතිරේකයක් විසි කරන විට අල්ලා ගැනීමට සමහර API ට වඩා සත්‍ය / අසත්‍ය නැවත පැමිණීමට මම කැමතියි , නමුත් මට ජීවත් විය හැකිය පසු.

භාවිතා කිරීම java.io.File:

File f = new File(filePathString);
if(f.exists() && !f.isDirectory()) { 
    // do something
}

ඒ isFile()වෙනුවට භාවිතා කිරීමට මම නිර්දේශ කරමි exists(). බොහෝ විට ඔබ සොයන්නේ මාර්ගය ගොනුවකට යොමු වන්නේ එය පමණක් නොව එයද යන්නයි. exists()ඔබේ මාර්ගය නාමාවලියකට යොමු කළහොත් එය සත්‍යයක් බව මතක තබා ගන්න .

new File("path/to/file.txt").isFile();

new File("C:/").exists() සත්‍ය බවට පත්වන නමුත් එය ගොනුවක් ලෙස විවෘත කර කියවීමට ඔබට ඉඩ නොදේ.

ජාවා SE 7 හි nio භාවිතා කිරීමෙන්,

import java.nio.file.*;

Path path = Paths.get(filePathString);

if (Files.exists(path)) {
  // file exist
}

if (Files.notExists(path)) {
  // file is not exist
}

දෙකම නම් existsහා notExistsආපසු බොරු, ගොනුව පැවැත්ම තහවුරු කර ගත නොහැකි ය. (සමහර විට මෙම මාර්ගයට ප්‍රවේශ වීමේ අයිතියක් නැත)

pathනාමාවලියක් හෝ සාමාන්‍ය ගොනුවක් දැයි ඔබට පරීක්ෂා කළ හැකිය .

if (Files.isDirectory(path)) {
  // path is directory
}

if (Files.isRegularFile(path)) {
  // path is regular file
}

කරුණාකර මෙම ජාවා SE 7 නිබන්ධනය පරීක්ෂා කරන්න .

ජාවා 8 භාවිතා කිරීම:

if(Files.exists(Paths.get(filePathString))) { 
    // do something
}

File f = new File(filePathString); 

මෙය භෞතික ගොනුවක් සාදන්නේ නැත. පංති ගොනුවේ වස්තුවක් නිර්මාණය කරයි. ගොනුවක් භෞතිකව නිර්මාණය කිරීම සඳහා ඔබ එය පැහැදිලිවම නිර්මාණය කළ යුතුය:

f.createNewFile();

එබැවින් f.exists()එවැනි ගොනුවක් තිබේද නැද්ද යන්න පරීක්ෂා කිරීමට භාවිතා කළ හැකිය.

f.isFile() && f.canRead()

මෙය සාක්ෂාත් කර ගැනීම සඳහා විවිධ ක්‍රම තිබේ.

1. සාධාරණ පැවැත්මක් සඳහා නම්. එය ගොනුවක් හෝ නාමාවලියක් විය හැකිය.

   new File("/path/to/file").exists();

2. ගොනුව සඳහා පරීක්ෂා කරන්න

   File f = new File("/path/to/file"); 
     if(f.exists() && f.isFile()) {}

3. නාමාවලිය සඳහා පරීක්ෂා කරන්න.

   File f = new File("/path/to/file"); 
     if(f.exists() && f.isDirectory()) {}

4. ජාවා 7 මාර්ගය.

   Path path = Paths.get("/path/to/file");
   Files.exists(path)  // Existence 
   Files.isDirectory(path)  // is Directory
   Files.isRegularFile(path)  // Regular file 
   Files.isSymbolicLink(path)  // Symbolic Link

ඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය: File.exists()

ගූගල් හි "ජාවා ගොනුව පවතී" සඳහා පළමු පහර:

import java.io.*;

public class FileTest {
    public static void main(String args[]) {
        File f = new File(args[0]);
        System.out.println(f + (f.exists()? " is found " : " is missing "));
    }
}

එපා. අල්ලා ගන්න FileNotFoundException.ගොනු පද්ධතියට කෙසේ හෝ ගොනුව තිබේද යන්න පරීක්ෂා කළ යුතුය. ඒ සියල්ල දෙවරක් කිරීමෙන් පලක් නැත, එසේ නොකිරීමට හේතු කිහිපයක්:

• කේතය දෙගුණ කරන්න
• ඔබ පරීක්‍ෂා කරන විට ගොනුව පැවතිය හැකි කාල කවුළු ගැටළුව, නමුත් ඔබ විවෘත කරන විට නොව, අනෙක් අතට, සහ
• මෙම ප්‍රශ්නයේ පැවැත්ම පෙන්නුම් කරන පරිදි, ඔබට වැරදි පරීක්‍ෂණයක් කර වැරදි පිළිතුරක් ලබා ගත හැකිය.

පද්ධතිය දෙවන වරට අනුමාන කිරීමට උත්සාහ නොකරන්න. එය දනී. අනාගතය ගැන අනාවැකි කීමට උත්සාහ නොකරන්න. පොදුවේ ගත් කල ඕනෑම සම්පතක් තිබේදැයි පරීක්ෂා කිරීමට හොඳම ක්‍රමය එය භාවිතා කිරීමට උත්සාහ කිරීමයි.

මට නම් ෂෝන් ඒ ඕ හාර්නි විසින් පිළිගත් පිළිතුරේ එකතුවක් සහ එහි ප්‍රති ing ලයක් ලෙස කෝර්ට් 3z අදහස් දැක්වීම හොඳම විසඳුම බව පෙනේ.

පහත දැක්වෙන ස්නිපටය භාවිතා කරන ලදි:

File f = new File(filePathString);
if(f.exists() && f.isFile()) {
    //do something ...
}

මෙය යමෙකුට උපකාර කරනු ඇතැයි සිතමි.

මම දන්නවා මම මේ ත්‍රෙඩ් එකේ ටිකක් පරක්කුයි කියලා. කෙසේ වෙතත්, මෙන්න මගේ පිළිතුර, ජාවා 7 සහ ඊට ඉහළ සිට වලංගු වේ.

පහත දැක්වෙන ස්නිපටය

if(Files.isRegularFile(Paths.get(pathToFile))) {
    // do something
}

ගොනුව නොපවතින නම් ක්‍රමය isRegularFileනැවත පැමිණෙන බැවින් එය පරිපූර්ණ තෘප්තිමත් falseවේ. එබැවින්, තිබේදැයි පරීක්ෂා කිරීම අවශ්ය නොවේ Files.exists(...).

වෙනත් පරාමිතීන් සබැඳි හැසිරවිය යුතු ආකාරය දැක්වෙන විකල්පයන් බව සලකන්න. පෙරනිමියෙන්, සංකේතාත්මක සම්බන්ධතා අනුගමනය කරනු ලැබේ.

ජාවා ඔරකල් ප්‍රලේඛනයෙන්

එය ද Commons හුරුපුරුදු හොඳින් වටිනවා FileUtils https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/FileUtils.html මෙම ගොනු කළමනාකරණය සඳහා අතිරේක ක්රම ඇති අතර බොහෝ විට JDK ට වඩා හොඳයි.

හොඳ කේතීකරණ භාවිතයන් සහ සියලු අවස්ථා ආවරණය කරන සරල උදාහරණය:

 private static void fetchIndexSafely(String url) throws FileAlreadyExistsException {
        File f = new File(Constants.RFC_INDEX_LOCAL_NAME);
        if (f.exists()) {
            throw new FileAlreadyExistsException(f.getAbsolutePath());
        } else {
            try {
                URL u = new URL(url);
                FileUtils.copyURLToFile(u, f);
            } catch (MalformedURLException ex) {
                Logger.getLogger(RfcFetcher.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IOException ex) {
                Logger.getLogger(RfcFetcher.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

යොමු සහ තවත් උදාහරණ

https://zgrepcode.com/examples/java/java/nio/file/filealreadyexistsexception-implementations

String සමඟ ගොනු සාදන්නා භාවිතා නොකරන්න.
මෙය ක්‍රියාත්මක නොවනු ඇත!
මෙම භාවිතය වෙනුවට URI:

File f = new File(new URI("file:///"+filePathString.replace('\\', '/')));
if(f.exists() && !f.isDirectory()) { 
    // to do
}

ඔබට එය මේ ආකාරයෙන් කළ හැකිය

import java.nio.file.Paths;

String file = "myfile.sss";
if(Paths.get(file).toFile().isFile()){
    //...do somethinh
}

මෙම ක්‍රම සැලසුම් කිරීම සඳහා නිශ්චිත අරමුණක් ඇත. ගොනුවක් තිබේද නැද්ද යන්න පරීක්ෂා කිරීමට කිසිවෙකු භාවිතා කරන්නැයි අපට පැවසිය නොහැක.

1. isFile () : ද යන්න ටෙස්ට් තරග ගොනුව මෙම වියුක්ත pathname මගින් වන සාමාන්ය ගොනුවකි.
2. පවතී () : මෙම වියුක්ත මාර්ග නාමයෙන් දැක්වෙන ගොනුව හෝ නාමාවලිය තිබේද යන්න පරීක්ෂා කරයි . docs.oracle.com