有没有在Java应用程序内部创建临时目录的标准可靠方法？Java的问题数据库中有一个条目，注释中包含一些代码，但是我想知道是否可以在其中一种常用的库（Apache Commons等）中找到一种标准的解决方案？
有没有在Java应用程序内部创建临时目录的标准可靠方法？Java的问题数据库中有一个条目，注释中包含一些代码，但是我想知道是否可以在其中一种常用的库（Apache Commons等）中找到一种标准的解决方案？
Answers:
如果您使用的是JDK 7，请使用新的Files.createTempDirectory类创建临时目录。
Path tempDirWithPrefix = Files.createTempDirectory(prefix);在JDK 7之前，应该这样做：
public static File createTempDirectory()
throws IOException
{
final File temp;
temp = File.createTempFile("temp", Long.toString(System.nanoTime()));
if(!(temp.delete()))
{
throw new IOException("Could not delete temp file: " + temp.getAbsolutePath());
}
if(!(temp.mkdir()))
{
throw new IOException("Could not create temp directory: " + temp.getAbsolutePath());
}
return (temp);
}
如果需要，可以提出更好的异常（IOException子类）。
temp.delete(); temp = new File(temp.getPath + ".d"); temp.mkdir(); ..., temp.delete();。
Google Guava库具有大量有用的实用程序。这里要注意的一个是Files类。它有很多有用的方法，包括：
File myTempDir = Files.createTempDir();这完全符合您的要求。如果您在此处阅读文档，将会看到建议的改编File.createTempFile("install", "dir")通常会引入安全漏洞。
如果您需要一个临时目录进行测试并且正在使用jUnit，则@Rule可以TemporaryFolder解决您的问题：
@Rule
public TemporaryFolder folder = new TemporaryFolder();从文档中：
TemporaryFolder规则允许创建保证在测试方法完成时（无论通过还是失败）都将被删除的文件和文件夹。
更新：
如果使用的是JUnit Jupiter（版本5.1.1或更高版本），则可以选择使用JUnit Pioneer（即JUnit 5扩展包）。
从项目文档复制：
例如，以下测试为单个测试方法注册扩展名，创建文件并将其写入临时目录，然后检查其内容。
@Test
@ExtendWith(TempDirectory.class)
void test(@TempDir Path tempDir) {
Path file = tempDir.resolve("test.txt");
writeFile(file);
assertExpectedFileContent(file);
}JavaDoc和TempDirectory的JavaDoc中的更多信息
摇篮：
dependencies {
testImplementation 'org.junit-pioneer:junit-pioneer:0.1.2'
}Maven：
<dependency>
<groupId>org.junit-pioneer</groupId>
<artifactId>junit-pioneer</artifactId>
<version>0.1.2</version>
<scope>test</scope>
</dependency>更新2：
该@TempDir注释添加到JUnit的木星5.4.0版本作为实验性的功能。从《JUnit 5用户指南》复制的示例：
@Test
void writeItemsToFile(@TempDir Path tempDir) throws IOException {
Path file = tempDir.resolve("test.txt");
new ListWriter(file).write("a", "b", "c");
assertEquals(singletonList("a,b,c"), Files.readAllLines(file));
}用于解决此问题的幼稚代码受竞争条件的影响，其中包括此处的几个答案。从历史上看，您可以仔细考虑比赛条件并自己编写，或者可以使用Google的Guava之类的第三方库（如Spina的答案所建议。），或者可以编写错误的代码。
但是从JDK 7开始，有个好消息！Java标准库本身现在提供了解决此问题的正确方法（非民主）。您需要java.nio.file.Files＃createTempDirectory（）。从文档中：
public static Path createTempDirectory(Path dir,
String prefix,
FileAttribute<?>... attrs)
throws IOException在指定的目录中创建一个新目录，使用给定的前缀生成其名称。结果路径与给定目录与同一文件系统关联。
有关目录名称的构造方式的详细信息取决于实现方式，因此未指定。在可能的情况下，前缀用于构造候选名称。
这有效地解决了Sun bug跟踪器中令人尴尬的古老bug报告，该报告只需要这样的功能。
这是Guava库的Files.createTempDir（）的源代码。它没有您想像的那么复杂：
public static File createTempDir() {
File baseDir = new File(System.getProperty("java.io.tmpdir"));
String baseName = System.currentTimeMillis() + "-";
for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) {
File tempDir = new File(baseDir, baseName + counter);
if (tempDir.mkdir()) {
return tempDir;
}
}
throw new IllegalStateException("Failed to create directory within "
+ TEMP_DIR_ATTEMPTS + " attempts (tried "
+ baseName + "0 to " + baseName + (TEMP_DIR_ATTEMPTS - 1) + ')');
}默认：
private static final int TEMP_DIR_ATTEMPTS = 10000;deleteOnExit()即使以后明确删除它也不要使用。
谷歌“ deleteonexit是邪恶的”以获得更多信息，但是问题的要点是：
deleteOnExit() 仅在正常JVM关闭时删除，而不会崩溃或杀死JVM进程。
deleteOnExit() 仅在JVM关闭时删除-不适合长时间运行的服务器进程，因为：
最邪恶的- deleteOnExit()占用每个临时文件条目的内存。如果您的进程运行了几个月，或者在很短的时间内创建了许多临时文件，则您将消耗内存，并且在JVM关闭之前永远不要释放内存。
这是我决定为自己的代码执行的操作：
/**
* Create a new temporary directory. Use something like
* {@link #recursiveDelete(File)} to clean this directory up since it isn't
* deleted automatically
* @return the new directory
* @throws IOException if there is an error creating the temporary directory
*/
public static File createTempDir() throws IOException
{
final File sysTempDir = new File(System.getProperty("java.io.tmpdir"));
File newTempDir;
final int maxAttempts = 9;
int attemptCount = 0;
do
{
attemptCount++;
if(attemptCount > maxAttempts)
{
throw new IOException(
"The highly improbable has occurred! Failed to " +
"create a unique temporary directory after " +
maxAttempts + " attempts.");
}
String dirName = UUID.randomUUID().toString();
newTempDir = new File(sysTempDir, dirName);
} while(newTempDir.exists());
if(newTempDir.mkdirs())
{
return newTempDir;
}
else
{
throw new IOException(
"Failed to create temp dir named " +
newTempDir.getAbsolutePath());
}
}
/**
* Recursively delete file or directory
* @param fileOrDir
* the file or dir to delete
* @return
* true iff all files are successfully deleted
*/
public static boolean recursiveDelete(File fileOrDir)
{
if(fileOrDir.isDirectory())
{
// recursively delete contents
for(File innerFile: fileOrDir.listFiles())
{
if(!FileUtilities.recursiveDelete(innerFile))
{
return false;
}
}
}
return fileOrDir.delete();
}好吧，“ createTempFile”实际上创建了文件。那么，为什么不先删除它，然后再对其执行mkdir呢？
该代码应该可以正常工作：
public static File createTempDir() {
final String baseTempPath = System.getProperty("java.io.tmpdir");
Random rand = new Random();
int randomInt = 1 + rand.nextInt();
File tempDir = new File(baseTempPath + File.separator + "tempDir" + randomInt);
if (tempDir.exists() == false) {
tempDir.mkdir();
}
tempDir.deleteOnExit();
return tempDir;
}如本RFE及其评论所述，您可以tempDir.delete()先致电。或者，您可以在其中使用System.getProperty("java.io.tmpdir")并创建目录。无论哪种方式，您都应该记住调用tempDir.deleteOnExit()，否则操作完成后该文件将不会被删除。
只是为了完成，这是来自Google番石榴库的代码。这不是我的代码，但我认为在此线程中显示它很有价值。
/** Maximum loop count when creating temp directories. */
private static final int TEMP_DIR_ATTEMPTS = 10000;
/**
* Atomically creates a new directory somewhere beneath the system's temporary directory (as
* defined by the {@code java.io.tmpdir} system property), and returns its name.
*
* <p>Use this method instead of {@link File#createTempFile(String, String)} when you wish to
* create a directory, not a regular file. A common pitfall is to call {@code createTempFile},
* delete the file and create a directory in its place, but this leads a race condition which can
* be exploited to create security vulnerabilities, especially when executable files are to be
* written into the directory.
*
* <p>This method assumes that the temporary volume is writable, has free inodes and free blocks,
* and that it will not be called thousands of times per second.
*
* @return the newly-created directory
* @throws IllegalStateException if the directory could not be created
*/
public static File createTempDir() {
File baseDir = new File(System.getProperty("java.io.tmpdir"));
String baseName = System.currentTimeMillis() + "-";
for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) {
File tempDir = new File(baseDir, baseName + counter);
if (tempDir.mkdir()) {
return tempDir;
}
}
throw new IllegalStateException(
"Failed to create directory within "
+ TEMP_DIR_ATTEMPTS
+ " attempts (tried "
+ baseName
+ "0 to "
+ baseName
+ (TEMP_DIR_ATTEMPTS - 1)
+ ')');
}我遇到了同样的问题，所以这只是对那些有兴趣的人的另一个答案，它与上述之一相似：
public static final String tempDir = System.getProperty("java.io.tmpdir")+"tmp"+System.nanoTime();
static {
File f = new File(tempDir);
if(!f.exists())
f.mkdir();
}对于我的应用程序，我决定添加一个选项来清除退出时的温度，因此我添加了一个关闭挂钩：
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
//stackless deletion
String root = MainWindow.tempDir;
Stack<String> dirStack = new Stack<String>();
dirStack.push(root);
while(!dirStack.empty()) {
String dir = dirStack.pop();
File f = new File(dir);
if(f.listFiles().length==0)
f.delete();
else {
dirStack.push(dir);
for(File ff: f.listFiles()) {
if(ff.isFile())
ff.delete();
else if(ff.isDirectory())
dirStack.push(ff.getPath());
}
}
}
}
});该方法在删除temp之前先删除所有子目录和文件，而不使用调用栈（这是完全可选的，此时您可以使用递归进行此操作），但是我想保持安全。
正如您在其他答案中看到的那样，没有标准的方法出现。因此，您已经提到了Apache Commons，我提出了使用Apache Commons IO中的 FileUtils的以下方法：
/**
* Creates a temporary subdirectory in the standard temporary directory.
* This will be automatically deleted upon exit.
*
* @param prefix
* the prefix used to create the directory, completed by a
* current timestamp. Use for instance your application's name
* @return the directory
*/
public static File createTempDirectory(String prefix) {
final File tmp = new File(FileUtils.getTempDirectory().getAbsolutePath()
+ "/" + prefix + System.currentTimeMillis());
tmp.mkdir();
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
try {
FileUtils.deleteDirectory(tmp);
} catch (IOException e) {
e.printStackTrace();
}
}
});
return tmp;
}这是首选，因为apache commons是最接近要求的“标准”的库，并且可与JDK 7和更早版本一起使用。这还会返回一个“旧” File实例（基于流），而不是一个“ new” Path实例（基于缓冲区，这是JDK7的getTemporaryDirectory（）方法的结果）->因此，它返回大多数人在需要时他们想创建一个临时目录。
在Java 7之前，您还可以：
File folder = File.createTempFile("testFileUtils", ""); // no suffix
folder.delete();
folder.mkdirs();
folder.deleteOnExit();试试这个小例子：
码：
try {
Path tmpDir = Files.createTempDirectory("tmpDir");
System.out.println(tmpDir.toString());
Files.delete(tmpDir);
} catch (IOException e) {
e.printStackTrace();
}
导入：
java.io.IOException
java.nio.file.Files
java.nio.file.Path
Windows计算机上的控制台输出：
C：\ Users \ userName \ AppData \ Local \ Temp \ tmpDir2908538301081367877
注释：
Files.createTempDirectory原子地生成唯一ID-2908538301081367877。
注意：
阅读以下内容以递归方式删除目录：在Java中以递归方式
删除目录
使用File#createTempFile和delete为目录创建唯一名称似乎没问题。您应该添加一个ShutdownHook以在JVM关闭时删除该目录（递归）。