Java 文件等于

Question

我不知道你们怎么想，但至少我预计下面的代码中 f1 将等于 f2，但显然情况并非如此！您对此有何看法？看来我必须写自己的 equals 方法来支持它，对吗？

import java.io.*;

public class FileEquals
{
    public static void main(String[] args)
    {
        File f1 = new File("./hello.txt");
        File f2 = new File("hello.txt");
        System.out.println("f1: " + f1.getName());
        System.out.println("f2: " + f2.getName());
        System.out.println("f1.equals(f2) returns " + f1.equals(f2));
        System.out.println("f1.compareTo(f2) returns " + f1.compareTo(f2));
    }
}

Answer 1

不，事实并非如此。因为 equals 正在比较绝对路径的相等性（在上面的例子中，它类似于：

some-project\.\hello.txt
some-project\hello.txt

所以它们自然是不同的。

看来我必须编写自己的 equals 方法来支持它，
对吗？

可能是的。但首先你要知道你要比较什么？只有路径名吗？如果是，请以这种方式比较其规范路径：

f1.getCanonicalPath().equals(f2.getCanonicalPath())

但是如果您想比较两个不同文件的内容，那么是，您应该编写自己的方法 - 或者只是从互联网上的某个地方复制。

Answer 2

要正确测试 equals，您必须调用 getCanonicalFile()。例如，

public static void main(String[] args) throws IOException
   {
       File f1 = new File("./hello.txt").getCanonicalFile();
       File f2 = new File("hello.txt").getCanonicalFile();
       System.out.println("f1: " + f1.getAbsolutePath());
       System.out.println("f2: " + f2.getAbsolutePath());
       System.out.println("f1.equals(f2) returns " + f1.equals(f2));
       System.out.println("f1.compareTo(f2) returns " + f1.compareTo(f2));
   }

如果等于，则返回 true。请注意，getCanonicalFile 可能会抛出 IOException，因此我将其添加到方法签名中。

Answer 3

如果您只想比较每个文件的内容，您可以将内容读入字节数组，如下所示：

byte[] f1 = Files.readAllBytes(file1);
byte[] f2 = Files.readAllBytes(file2);

然后从那里准确比较您想要的内容。

请注意，此方法调用仅存在于 Java 7 中。对于旧版本，Guava 和 Apache 具有执行类似操作但名称和详细信息不同的方法。

编辑：或者更好的选择（特别是如果您正在比较大文件）可能是简单地逐字节比较，而不是将整个文件加载到内存中，如下所示：

FileInputStream f1 = new FileInputStream(file1);
DataInputStream d1 = new DataInputStream(f1);
FileInputStream f2 = new FileInputStream(file2);
DataInputStream d2 = new DataInputStream(f2);

byte b1 = d1.readByte();
byte b2 = d2.readByte();

然后从那里进行比较。

Answer 4

我发现比较两个文件的更快方法如下。

这只是解决这个问题的建议。

不确定性能（如果每个文件都是 10 GB 怎么办？）

    File file = new File("/tmp/file.txt");
    File secondFile = new File("/tmp/secondFile.txt");

    // Bytes diff
    byte[] b1 = Files.readAllBytes(file.toPath());
    byte[] b2 = Files.readAllBytes(secondFile.toPath());

    boolean equals = Arrays.equals(b1, b2);

    System.out.println("the same? " + equals);

    // List Diff
    List<String> c1 = Files.readAllLines(file.toPath());
    List<String> c2 = Files.readAllLines(secondFile.toPath());

    boolean containsAll = c1.containsAll(c2);
    System.out.println("the same? " + containsAll);                
}

编辑

但是，unix 系统上的 diff 实用程序会更快、更冗长。
取决于你需要比较什么。

Answer 5

如果您只想根据路径检查文件是否相同，请使用

java.nio.file.Files#isSameFile

例如

Assert.assertTrue(Files.isSameFile(
     new File("some-project\.\hello.txt").toPath(),
     new File("some-project\hello.txt").toPath()
));

Answer 6

下面是这两种方法的实现：

/**
 * Tests this abstract pathname for equality with the given object.
 * Returns <code>true</code> if and only if the argument is not
 * <code>null</code> and is an abstract pathname that denotes the same file
 * or directory as this abstract pathname.  Whether or not two abstract
 * pathnames are equal depends upon the underlying system.  On UNIX
 * systems, alphabetic case is significant in comparing pathnames; on Microsoft Windows
 * systems it is not.
 *
 * @param   obj   The object to be compared with this abstract pathname
 *
 * @return  <code>true</code> if and only if the objects are the same;
 *          <code>false</code> otherwise
 */
public boolean equals(Object obj) {
    if ((obj != null) && (obj instanceof File)) {
        return compareTo((File)obj) == 0;
    }
    return false;
}

/**
 * Compares two abstract pathnames lexicographically.  The ordering
 * defined by this method depends upon the underlying system.  On UNIX
 * systems, alphabetic case is significant in comparing pathnames; on Microsoft Windows
 * systems it is not.
 *
 * @param   pathname  The abstract pathname to be compared to this abstract
 *                    pathname
 *
 * @return  Zero if the argument is equal to this abstract pathname, a
 *          value less than zero if this abstract pathname is
 *          lexicographically less than the argument, or a value greater
 *          than zero if this abstract pathname is lexicographically
 *          greater than the argument
 *
 * @since   1.2
 */
public int compareTo(File pathname) {
    return fs.compare(this, pathname);
}

Answer 7

如果您使用的是Windows，请参阅类Win32FileSystem

比较方法如下，因此您的文件对象不同是很正常的。

    public int compare(File f1, File f2) {
      return f1.getPath().compareToIgnoreCase(f2.getPath());
    }

将这些行添加到您的代码中

        System.out.println(f1.getPath());
        System.out.println(f2.getPath());

，它将打印

.\hello.txt
hello.txt

因此它们不相等，因为使用 File 对象的路径属性进行比较