La fermeture d'un fichier créé avec FileOutputStream, pour une prochaine supprimer

Je suis actuellement confronté à un problème avec un FileOutputStream dans mon code Java.

En fait, je suis en utilisant un FileOutputStream pour la création d'un fichier, mais une fois que le fichier est créé il n'y a aucun moyen de le supprimer. Aussi loin que je pouvais comprendre, cela peut venir du fait que le FileOutputstream n'est pas fermé.

Ci-dessous mes résumés code :

     outFile = new FileOutputStream(dir+"\\"+fileName);
     outFile.write("Test");
     outFile.flush();
     outFile.close();
     outFile = null;
     System.gc();

Alors il n'y a pas moyen de supprimer le fichier, même "à la main". Lorsque mon programme est lancé, je ne peux pas le supprimer de windows par un simple del. J'ai aussi essayé de supprimer le contenu du dossier dir et il n'a pas travaillé ni, à l'aide de ce code :

static public void delDir( String place )

{
    File path = new File( place );
    System.out.println(path.exists());//return true
    if( path.exists() )
        {
        File[] f = path.listFiles();
        for( int j = 0 ; j < f.length ; j++ )
            {
            if( f[ j ].isDirectory() )
                {
                deleteDirectory( path+"\\"+f[ j ] );
                }
            f[ j ].delete();
            }
        }
}

Donc ma question est :
Comment fermer ce fichier pour une prochaine supprimer (ou la façon de le supprimer correctement si on ne peut pas la fermer)?

OriginalL'auteur user1619114 | 2012-08-23

13

C'est un bug de Java. Oui il sont rares, mais ils existent 😉 Pourriez-vous ajouter après outFile.close()
```
outFile = null;
System.gc();
```
Et ensuite essayer de le supprimer. Il y a plus de possibilité si ce n'est pas de travail. Laissez-moi savoir.

Mise à JOUR

Pour moi cela fonctionne:
```
public class FileDeleteExample {
    public static void main(String[] args) throws Exception {
        File f = new File("test.txt");

        FileOutputStream outFile = null;

        try {
            outFile = new FileOutputStream(f);
            outFile.write("Test".getBytes());
        } finally {
            outFile.flush();
            outFile.close();
            outFile = null;
            System.gc();
        }

        f.delete();
    }
}
```
Mise à JOUR

Je l'ai essayé avec l'exemple Sumit Singh a mentionné en supprimant les lignes outFile=null; System.gc; et cela fonctionne bien pour moi. Donc il ne devrait pas être un problème avec le FileOutputStream. Pourriez-vous essayer le petit exemple ci-dessus et dire si ça marche ou pas?

Mise à JOUR
```
void closeQuietly(FileOutputStream out) {
    try { out.flush(); out.close(); } catch(Exception e) {} 
}
```
Maintenant, il suffit d'appeler la méthode dans le finally bloc!

J'ai essayé et ça n'a pas fonctionné. J'ai deviné que c'était un bug oui, que ce que j'ai lu sur d'autres forum. Toute autre solution s'il vous plaît ? Vous semble connaître le sujet =)
(Oui tiens, j'essaie. Je vous remercie pour votre aide)
ok. n'oubliez pas que test.txt devraient existe en vertu de votre projet chemin 🙂
Oui cet exemple fonctionne pour moi. Je ne sais pas quel est le problème avec le mien, peut-être parce que je n'ai pas de chasse d'eau, fermer, etc. dans une enfin ? Lorsque je fais cela, il requiert de mettre certains de lancer ou attraper dans le enfin, c'est vraiment bizarre
oui dans la enfin, vous devez attraper les exceptions. dans mon exemple, j'ai juste jette le Exception donc je n'ai pas à gérer ^^ mais c'est uniquement pour l'exemple. à mon avis, vous devez les gérer. J'ai ajouté un morceau de code que vous pouvez utiliser.

OriginalL'auteur christian.vogel
1

J'ai eu le même problème, la méthode delete() a retourné false pour mon dossier.

Dans mon cas, quelque part entre la création du fichier, écrit à son FileOutputStream et de supprimer le fichier, j'ai été en utilisant un FileInputStream et j'ai oublié d'appeler close ().

Alors, peut-être quelque part dans votre code que vous avez joint un autre flux de ce fichier, et l'a laissé ouvert.

Avant de trouver la vraie source du problème, j'ai utilisé un simle hack temporairement résoudre ce problème:
```
FileOutputStream fos = new FileOutputStream(myFile);
fos.close();
myFile.delete();
```
Droite avant d'appeler supprimer sur mon Fichier, j'ai créé un autre FileOutputStream dessus et puis juste appelé close().

Cela déverrouille toutes les previuous verrous sur ce fichier et vous permet d'appeler delete().

Encore ce n'est pas une bonne pratique de le faire. Vous devez savoir qui utilise votre fichier et de le résoudre de la bonne façon.

OriginalL'auteur Cornelia
0

Bien, le moyen de fermer un fichier d'entrée et de sortie des flux est:
```
name.close()
```
et votre code de suppression a l'air bien. Ma recommandation serait d'utiliser FileIO au lieu de FileOutputStream, sauf si vous utilisez FileOutputStream pour une bonne raison. Pouvez-vous supprimer le fichier une fois que le programme se ferme?

Oui je peux les supprimer une fois qu'ils sont fermés, merci de lire mon propre code ci-dessus.

OriginalL'auteur sciguy1121
0

Vous pouvez essayer ce code..
```
    File file = new File(dir+"\\"+fileName);
    FileOutputStream outFile;
    try {
        outFile = new FileOutputStream(file);
        outFile.write("Test".getBytes());
        outFile.flush();
        outFile.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
   file.delete();
```
Vous pouvez vérifier ces liens ci-dessous..
Non j'ai utilisé de la chasse aussi, j'ai oublié de l'ajouter, mais il ne fonctionne pas ... autant Que j'ai pu lire c'est un bug donc je suis à la recherche d'une solution.
est droit. le rinçage ne va pas aider, car il s'agit d'un bug
Je ne sais pas pourquoi sa ne fonctionne pas pour vous, parce que son travail pour moi . Peut-être votre fichier est ouvert dans une autre application. avez-vous l'ouvrez à l'aide de quelques éditeur ...? Si oui, alors vérifier dans votre moniteur système, Peut-être que l'application est toujours en cours d'exécution.
Non, il n'est pas ouvert partout ailleurs :/ ... s'il vous Plaît prendre un coup d'oeil à la réponse de christian.vogel, il semble être un bug connu, mais je ne sais pas quoi faire !
vous pouvez vérifier les liens de la Réponse peut être son aide à vous..

OriginalL'auteur Sumit Singh
0

Mieux utiliser FileUtils.deleteDirectory de Apache Commons IO. Surmonte la Java supprimer bug, réduit la quantité de code utilisé et la plupart de tous, il fonctionne.

Au lieu de l'appeler
```
delDir(place);
```
appelez simplement
```
FileUtils.deleteDirectory(new File(place));
```
Mise à jour:
Dans votre delDir méthode, vous composez le:
```
deleteDirectory(new File(path + "\\" + f[j]));
```
mais le résultat de
```
File[] f = path.listFiles();
```
sera incluent déjà le chemin d'accès dans le fichier, de sorte que vous pouvez simplement utiliser:
```
deleteDirectory( f[j].getPath() );
```
Bonjour, comme vous avez pu le voir le voir, oui, j'ai utilisé "deleteDirectory( chemin+"\\"+f[ j ] ); ", ou peut-être que j'ai mal compris votre proposition?
J'ai vérifié et il ne le travail. Voir ma mise à jour.
J'ai eu l'erreur suivante : Impossible de trouver le symbole "FileUtils"
Vous devez télécharger la bibliothèque commons.apache.org/io/download_io.cgi & ajouter les Pots de votre classpath
Ok je l'ai fait mais c'est le même problème, j'ai eu la même exception : java.io.IOException: Impossible de supprimer le fichier"

OriginalL'auteur Reimeus
0

Pas vraiment, mais liées:

Cette solution de la fermeture d'un fichier m'a aidé avec un autre problème. Lors de l'exécution d'un programme à partir de la version 6 de java le nouveau processus a été suspendu jusqu'à ce que j'ai fermé mon application (dans java 7, il est ok).
La solution basée sur cette réponse m'a aidé:
```
    String[] com = new String[]{javaRun, arg1, arg2, arg3, arg4};

    Process proc = Runtime.getRuntime().exec(com, null, dir);

    proc = null;
    System.gc();
```
Cela fonctionne avec la version 6 de java. Merci pour l'inspiration.

OriginalL'auteur tremoor
0

Le problème peut être dans la première ligne:
outFile = new FileOutputStream(dir+"\"+fileName);
1. Pas sûr que le nouveau est requise.
2. Ne crois pas que le répertoire doit être inclus dans le chemin. Autant que je sache, le répertoire pour FileOutputStream est définie comme l'application d'annuaire interne.
HTH

OriginalL'auteur John L

Vous devez vous connecter pour publier un commentaire.