首次执行Java解压程序失败，二次执行正常问题求助

首次解压失败、第二次成功的核心原因，大概率是目标zip文件尚未完全被系统释放或写入完成——即便你看到文件已经存在，下载工具可能还持有文件句柄，或是系统在后台完成文件的最终写入/校验操作，导致第一次读取时文件不可访问或不完整。

针对这个问题，你可以从以下几个方面修改代码：

1. 增加文件读取重试机制 #

在尝试解压前，先验证文件是否可正常读取，若失败则重试几次（比如间隔1秒重试3次），给系统足够时间释放文件句柄。

2. 校验Zip文件有效性 #

用ZipFile类替代直接用FileInputStream，它能更准确地判断文件是否为有效的Zip包，避免读取不完整的文件。

3. 优化最新文件获取逻辑 #

替换listFiles为Files.list，它能获取更实时的目录文件状态，避免File类的缓存导致获取到未就绪的文件。

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Comparator;
import java.util.Optional;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

public class UnzipLatestZipFile {

    private String unzippedFileName;
    private static final int MAX_RETRIES = 3;
    private static final long RETRY_DELAY_MS = 1000;

    public void processLatestZipFile() {
        String downloadsFolderPath = System.getProperty("user.home") + File.separator + "Downloads";
        String unzippedFolderPath = downloadsFolderPath + File.separator + "unzipped";
        Optional<Path> latestZipPath = getLatestZipFile(downloadsFolderPath);

        if (latestZipPath.isPresent()) {
            File latestZipFile = latestZipPath.get().toFile();
            System.out.println("Latest Zip File: " + latestZipFile.getName());
            
            boolean unzipSuccess = false;
            int retryCount = 0;
            while (!unzipSuccess && retryCount < MAX_RETRIES) {
                try {
                    // 先校验文件是否可读取且是有效Zip
                    validateZipFile(latestZipFile);
                    unzipFile(latestZipFile, unzippedFolderPath);
                    System.out.println("File successfully unzipped to: " + unzippedFolderPath);
                    System.out.println("Unzipped File Name: " + unzippedFileName);
                    unzipSuccess = true;
                } catch (IOException e) {
                    retryCount++;
                    System.err.println("Attempt " + retryCount + " failed: " + e.getMessage());
                    if (retryCount < MAX_RETRIES) {
                        try {
                            Thread.sleep(RETRY_DELAY_MS);
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
            
            if (!unzipSuccess) {
                System.err.println("Failed to unzip file after " + MAX_RETRIES + " attempts.");
            }
        } else {
            System.out.println("No zip files found in the Downloads folder.");
        }
    }

    private Optional<Path> getLatestZipFile(String folderPath) {
        try {
            return Files.list(Paths.get(folderPath))
                    .filter(path -> path.getFileName().toString().toLowerCase().endsWith(".zip"))
                    .filter(Files::isRegularFile)
                    .max(Comparator.comparingLong(path -> {
                        try {
                            return Files.getLastModifiedTime(path).toMillis();
                        } catch (IOException e) {
                            return 0;
                        }
                    }));
        } catch (IOException e) {
            System.err.println("Error scanning downloads folder: " + e.getMessage());
            return Optional.empty();
        }
    }

    private void validateZipFile(File zipFile) throws IOException {
        // 尝试打开ZipFile验证文件有效性
        try (ZipFile zip = new ZipFile(zipFile)) {
            // 简单校验：至少有一个条目
            if (zip.size() == 0) {
                throw new IOException("Zip file is empty or invalid.");
            }
        }
    }

    private void unzipFile(File zipFile, String outputFolder) throws IOException {
        byte[] buffer = new byte[1024];
        File outputDir = new File(outputFolder);
        if (!outputDir.exists()) {
            outputDir.mkdirs();
        }

        try (ZipFile zipFileObj = new ZipFile(zipFile)) {
            zipFileObj.stream().forEach(zipEntry -> {
                String entryName = zipEntry.getName();
                File entryFile = new File(outputFolder + File.separator + entryName);
                
                // 创建父目录
                if (!entryFile.getParentFile().exists()) {
                    entryFile.getParentFile().mkdirs();
                }

                if (!zipEntry.isDirectory()) {
                    try (InputStream is = zipFileObj.getInputStream(zipEntry);
                         FileOutputStream fos = new FileOutputStream(entryFile)) {
                        int len;
                        while ((len = is.read(buffer)) > 0) {
                            fos.write(buffer, 0, len);
                        }
                        unzippedFileName = entryFile.getName();
                    } catch (IOException e) {
                        throw new RuntimeException("Failed to extract entry: " + entryName, e);
                    }
                }
            });
        }
    }
}

• 重试机制：增加3次重试，每次间隔1秒，给系统足够时间释放文件句柄。
• Zip有效性校验：用ZipFile提前验证文件是否有效，避免读取不完整的文件。
• 实时目录扫描：用Files.list替代File.listFiles，获取更准确的文件状态，绕过File类的缓存。
• 异常处理优化：更清晰地捕获每一步的错误，方便排查问题。

内容的提问来源于stack exchange，提问作者Pura R