Como as outras respostas nota, arquivos temporários criados com File.createTempFile()
o não ser excluído automaticamente, exceto que pedir explicitamente.
A maneira genérica e portátil de fazer isso é chamar .deleteOnExit()
o File
objeto, o que agendará o arquivo para exclusão quando a JVM for encerrada. Uma ligeira desvantagem desse método, no entanto, é que ele só funciona se a VM terminar normalmente; em um encerramento anormal (ou seja, uma falha da VM ou encerramento forçado do processo VM), o arquivo pode permanecer não apagado.
Em sistemas Unixish (como Linux), é realmente possível obter uma solução um pouco mais confiável excluindo o arquivo temporário imediatamente após abri-lo . Isso funciona porque os sistemas de arquivos Unix permitem que um arquivo seja excluído ( desvinculado , para ser mais preciso) enquanto ele ainda está aberto por um ou mais processos. Esses arquivos podem ser acessados normalmente por meio do filehandle aberto, e o espaço que ocupam no disco só será recuperado pelo sistema operacional após o último processo que mantém um identificador aberto para o arquivo sair.
Portanto, esta é a maneira mais confiável e portátil que conheço de garantir que um arquivo temporário seja excluído adequadamente após o encerramento do programa:
import java.io.File;
import java.io.RandomAccessFile;
import java.io.IOException;
public class TempFileTest
{
public static void main(String[] args)
{
try {
File temp = File.createTempFile("tempfiletest", ".tmp");
String path = temp.getAbsolutePath();
System.err.println("Temp file created: " + path);
RandomAccessFile fh = new RandomAccessFile (temp, "rw");
System.err.println("Temp file opened for random access.");
boolean deleted = false;
try {
deleted = temp.delete();
} catch (SecurityException e) {
}
if (deleted) {
System.err.println("Temp file deleted.");
} else {
temp.deleteOnExit();
System.err.println("Temp file scheduled for deletion.");
}
try {
String str = "A quick brown fox jumps over the lazy dog.";
fh.writeUTF(str);
System.err.println("Wrote: " + str);
fh.seek(0);
String out = fh.readUTF();
System.err.println("Read: " + out);
} finally {
fh.close();
System.err.println("Temp file closed.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Em um sistema Unixish, executar isso deve produzir algo como a seguinte saída:
Temp file created: /tmp/tempfiletest587200103465311579.tmp
Temp file opened for random access.
Temp file deleted.
Wrote: A quick brown fox jumps over the lazy dog.
Read: A quick brown fox jumps over the lazy dog.
Temp file closed.
enquanto no Windows, a saída parece um pouco diferente:
Temp file created: C:\DOCUME~1\User\LOCALS~1\Temp\tempfiletest5547070005699628548.tmp
Temp file opened for random access.
Temp file scheduled for deletion.
Wrote: A quick brown fox jumps over the lazy dog.
Read: A quick brown fox jumps over the lazy dog.
Temp file closed.
Em ambos os casos, entretanto, o arquivo temporário não deve permanecer no disco após o término do programa.
Ps. Ao testar esse código no Windows, observei um fato bastante surpreendente: aparentemente, apenas deixar o arquivo temporário aberto é suficiente para evitar que seja excluído . Obviamente, isso também significa que qualquer travamento que ocorrer enquanto o arquivo temporário estiver em uso fará com que ele não seja excluído, o que é exatamente o que estamos tentando evitar aqui.
AFAIK, a única maneira de evitar isso é garantir que o arquivo temporário sempre seja fechado usando um finally
bloco. Obviamente, você também pode excluir o arquivo do mesmo finally
bloco. Não tenho certeza do que usar, se é que alguma coisa, .deleteOnExit()
realmente venceria você sobre isso.