Java 为什么以及如何获得相同两个文件的不同值？

我将一个txt文件放在两个不同的文件夹中，但名称相同。例如，我将file.txt放在两个目录中，它们都被命名为“MY”。我想计算它们的MD5值，所以我用7z软件用相同的算法压缩了这两个文件夹。接下来是令人震惊的事情：两个.zip文件的MD5值是不同的。有什么诀窍

java中的代码是：

String parseMd5Hex(FileInputStream fin ) throws IOException {
    Md5 md5 = new Md5 (fin);
    byte b[]= md5.getDigest();
    return md5.parseToValue(b);
}

public class Md5 {
private static final int BUFFER_SIZE = 1024 ;

private static final int S11 = 7 ;
private static final int S12 = 12 ;
private static final int S13 = 17 ;
private static final int S14 = 22 ;
private static final int S21 = 5 ;
private static final int S22 = 9 ;
private static final int S23 = 14 ;
private static final int S24 = 20 ;
private static final int S31 = 4 ;
private static final int S32 = 11 ;
private static final int S33 = 16 ;
private static final int S34 = 23 ;
private static final int S41 = 6 ;
private static final int S42 = 10 ;
private static final int S43 = 15 ;
private static final int S44 = 21 ;

private static byte padding[] = {
    (byte) 0x80, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
    (byte) 0, (byte) 0, (byte) 0, (byte) 0
} ;

private InputStream in       = null ;
private boolean     stringp  = false ;
private int         state[]  = null ;
private long        count    = 0 ;
private byte        buffer[] = null ;
private byte        digest[] = null ;


private static String stringify (byte buf[]) {
    StringBuffer sb = new StringBuffer(2*buf.length) ;
    for (int i = 0 ; i < buf.length; i++) {
        int h = (buf[i] & 0xf0) >> 4 ;
        int l = (buf[i] & 0x0f) ;
        sb.append (Character.valueOf((char)((h>9) ? 'a'+h-10 : '0'+h))) ;
        sb.append (Character.valueOf((char)((l>9) ? 'a'+l-10 : '0'+l))) ;
    }
    return sb.toString() ;
}

private final int F(int x, int y, int z) {
    return ((x & y) | ((~x) & z)) ;
}

private final int G(int x, int y, int z) {
    return ((x & z) | (y & (~z))) ;
}

private final int H(int x, int y, int z) {
    return (x ^ y ^ z) ;
}

private final int I(int x, int y, int z) {
    return (y ^ (x | (~z))) ;
}

private final int rotate_left(int x, int n) {
    return ((x << n) | (x >>> (32-n))) ;
}

private final int FF(int a,int b,int c,int d,int x,int s,int ac) {
    a += (F(b, c, d) + x + ac) ;
    a = rotate_left(a, s) ;
    a += b ;
    return a ;
}

private final int GG(int a,int b,int c,int d,int x,int s,int ac) {
    a += (G(b, c, d) + x + ac) ;
    a = rotate_left(a, s) ;
    a += b ;
    return a ;
}

private final int HH(int a,int b,int c,int d,int x,int s,int ac) {
    a += (H(b, c, d) + x + ac) ;
    a = rotate_left(a, s) ;
    a += b ;
    return a ;
}

private final int II(int a,int b,int c,int d,int x,int s,int ac) {
    a += (I(b, c, d) + x + ac) ;
    a = rotate_left(a, s) ;
    a += b ;
    return a;
}

private final void decode (int output[], byte input[], int off, int len) {
    int i = 0 ;
    int j = 0 ;
    for ( ; j < len; i++, j += 4) {
        output[i] = (((int) (input[off+j]&0xff))
             | (((int) (input[off+j+1] & 0xff)) << 8)
             | (((int) (input[off+j+2] & 0xff)) << 16)
             | (((int) (input[off+j+3] & 0xff)) << 24)) ;
    }
}

private final void transform (byte block[], int offset) {
    int a   = state[0] ;
    int b   = state[1] ;
    int c   = state[2] ;
    int d   = state[3] ;
    int x[] = new int[16] ;

    decode (x, block, offset, 64);
    /* Round 1 */
    a = FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
    d = FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
    c = FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
    b = FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
    a = FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
    d = FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
    c = FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
    b = FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
    a = FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
    d = FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
    c = FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
    b = FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
    a = FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
    d = FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
    c = FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
    b = FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
    /* Round 2 */
    a = GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
    d = GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
    c = GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
    b = GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
    a = GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
    d = GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
    c = GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
    b = GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
    a = GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
    d = GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
    c = GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
    b = GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
    a = GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
    d = GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
    c = GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
    b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

    /* Round 3 */
    a = HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
    d = HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
    c = HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
    b = HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
    a = HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
    d = HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
    c = HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
    b = HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
    a = HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
    d = HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
    c = HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
    b = HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
    a = HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
    d = HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
    c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
    b = HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

    /* Round 4 */
    a = II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
    d = II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
    c = II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
    b = II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
    a = II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
    d = II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
    c = II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
    b = II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
    a = II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
    d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
    c = II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
    b = II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
    a = II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
    d = II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
    c = II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
    b = II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
}

private final void update (byte input[], int len) {
    int index = ((int) (count >> 3)) & 0x3f ;
    count += (len << 3) ;
    int partLen = 64 - index ;
    int i = 0 ;
    if ( len >= partLen ) {
        System.arraycopy (input, 0, buffer, index, partLen) ;
        transform (buffer, 0) ;
        for (i = partLen ; i + 63 < len ; i+= 64)
            transform (input, i) ;
        index = 0 ;
    } else {
        i = 0 ;
    }
    System.arraycopy (input, i, buffer, index, len - i) ;
}

private byte[] end () {
    byte bits[] = new byte[8] ;
    for (int i = 0 ; i < 8 ; i++)
        bits[i] = (byte) ((count>>>(i*8)) & 0xff) ;
    int index  = ((int) (count >> 3)) & 0x3f ;
    int padlen = (index < 56) ? (56 - index) : (120 - index) ;
    update (padding, padlen) ;
    update (bits, 8) ;
    return encode(state, 16) ;
}

// Encode the content.state array into 16 bytes array
private byte[] encode (int input[], int len) {
    byte output[] = new byte[len] ;
    int i = 0 ;
    int j = 0 ;
    for ( ; j < len ; i++, j+= 4) {
        output[j]   = (byte) ((input[i]      ) & 0xff) ;
        output[j+1] = (byte) ((input[i] >> 8 ) & 0xff) ;
        output[j+2] = (byte) ((input[i] >> 16) & 0xff) ;
        output[j+3] = (byte) ((input[i] >> 24) & 0xff) ;
    }
    return output ;
}

/**
 * Get the digest for our input stream.
 * This method constructs the input stream digest, and returns it, as
 * a String, following the MD5 (rfc1321) algorithm
 * @return An instance of String, giving the message digest.
 * @exception IOException Thrown if the digestifier was unable to read
 *    the input stream.
 */
public byte[] getDigest ()
    throws IOException
{
    byte buffer[] = new byte[BUFFER_SIZE] ;
    int  got      = -1 ;

    if ( digest != null )
        return digest ;
    while ((got = in.read(buffer)) > 0 )
        update (buffer, got) ;
    this.digest = end () ;
    return digest ;
}

/**
 * Get the digest, for this string digestifier.
 * This method doesn't throw any IOException, since it knows that the
 * underlying stream was built from a String.
 */
public byte[] processString () {
    if ( ! stringp )
        throw new RuntimeException (this.getClass().getName()
                    + "[processString]"
                    + " not a string.") ;
    try {
        return getDigest() ;
    } catch (IOException ex) {
    }
    throw new RuntimeException (this.getClass().getName()
                    + "[processString]"
                    + ": implementation error.") ;
}

/**
 * Get the digest, as a proper string.
 */
public String getStringDigest() {
    if ( digest == null )
        throw new RuntimeException (this.getClass().getName()
                    + "[getStringDigest]"
                    + ": called before processing.") ;
    return stringify (digest) ;
}

/**
 * Construct a digestifier for the given input stream.
 * @param in The input stream to be digestified.
 */
public Md5 (InputStream in) {
    this.stringp = false ;
    this.in      = in ;
    this.state   = new int[4] ;
    this.buffer  = new byte[64] ;
    this.count   = 0 ;
    state[0] = 0x67452301;
    state[1] = 0xefcdab89;
    state[2] = 0x98badcfe;
    state[3] = 0x10325476;
}

public String parseToValue(byte b[]){
    return stringify(b);
}

String parseMd5Hex（FileInputStream-fin）引发IOException{
Md5 Md5=新的Md5（fin）；
字节b[]=md5.getDigest（）；
返回md5.parsetValue（b）；
}
公共类Md5{
私有静态最终整数缓冲区大小=1024；
专用静态最终int S11=7；
专用静态最终int S12=12；
专用静态最终int S13=17；
专用静态最终int S14=22；
专用静态最终int S21=5；
专用静态最终int S22=9；
专用静态最终int S23=14；
专用静态最终int S24=20；
专用静态最终int S31=4；
专用静态最终int S32=11；
专用静态最终int S33=16；
专用静态最终int S34=23；
专用静态最终int S41=6；
专用静态最终int S42=10；
专用静态最终int S43=15；
专用静态最终int S44=21；
专用静态字节填充[]={
（字节）0x80，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，（字节）0，
（字节）0，（字节）0，（字节）0，（字节）0
} ;
私有InputStream in=null；
私有布尔stringp=false；
私有int状态[]=null；
私有长计数=0；
专用字节缓冲区[]=null；
专用字节摘要[]=null；
私有静态字符串字符串化（字节buf[]{
StringBuffer sb=新的StringBuffer（2*buf.长度）；
对于（int i=0；i>4；
int l=（buf[i]&0x0f）；
sb.append（Character.valueOf（（char）（（h>9）？'a'+h-10:'0'+h））；
sb.append（Character.valueOf（（char）（（l>9）“'a'+l-10:'0'+l））；
}
使某人返回字符串（）；
}
私有最终整数F（整数x，整数y，整数z）{
返回（（x&y）|（~x&z））；
}
私有最终整数G（整数x，整数y，整数z）{
返回（（x&z）|（y&z））；
}
私有最终整数H（整数x，整数y，整数z）{
返回（x^y^z）；
}
私有最终整数I（整数x，整数y，整数z）{
返回（y^（x|（~z））；
}
私有最终整数向左旋转（整数x，整数n）{
返回（（x>>（32-n））；
}
私有最终整数FF（整数a、整数b、整数c、整数d、整数x、整数s、整数ac）{
a+=（F（b，c，d）+x+ac）；
a=向左旋转（a，s）；
a+=b；
返回a；
}
私有最终整数GG（整数a、整数b、整数c、整数d、整数x、整数s、整数ac）{
a+=（G（b，c，d）+x+ac）；
a=向左旋转（a，s）；
a+=b；
返回a；
}
私有最终整数HH（整数a、整数b、整数c、整数d、整数x、整数s、整数ac）{
a+=（H（b，c，d）+x+ac）；
a=向左旋转（a，s）；
a+=b；
返回a；
}
私人期末智力测验II（智力测验a、智力测验b、智力测验c、智力测验d、智力测验x、智力测验s、智力测验ac）{
a+=（I（b，c，d）+x+ac）；
a=向左旋转（a，s）；
a+=b；
返回a；
}
专用最终无效解码（int输出[]，字节输入[]，int关闭，int len）{
int i=0；
int j=0；
对于（；j>（i*8））&0xff）；
int索引=（（int）（计数>>3））&0x3f；
int-padlen=（指数<56）？（56-指数）：（120-指数）；
更新（padding，padlen）；
更新（位8）；
返回编码（状态，16）；
}
//将content.state数组编码为16字节数组
专用字节[]编码（整数输入[]，整数长度）{
字节输出[]=新字节[len]；
int i=0；
int j=0；
对于（；j>8）&0xff）；
输出[j+2]=（字节）（（输入[i]>>16）和0xff）；
输出[j+3]=（字节）（（输入[i]>>24）&0xff）；
}
返回输出；
}
/**
*获取输入流的摘要。
*此方法构造输入流摘要，并返回它，如下所示
*一个字符串，遵循MD5（rfc1321）算法
*@返回字符串实例，给出消息摘要。
*@exception IOException在消化器无法读取时引发
*输入流。
*/
公共字节[]getDigest（）
抛出IOException
{
字节缓冲区[]=新字节[缓冲区大小]；
int-got=-1；
if（摘要！=null）
返回摘要；
而（（got=in.read（buffer））>0）
更新（缓冲区，got）；
this.digest=end（）；
返回摘要；
}
/**
*获取此字符串摘要生成器的摘要。
*此方法不会引发任何IOException，因为它知道
*底层流是从字符串构建的。
*/
公共字节[]进程字符串（）{
如果（！stringp）
抛出新的RuntimeException（this.getClass（）.getName（））
+“[processString]”
+“不是字符串。”）；
试一试{
返回getDigest（）；
}捕获（IOEX异常）{
}
抛出新的RuntimeException（this.getClass（）.getName（））
+“[processString]”
+“：实现错误。”）；
}
/**
*以正确的字符串形式获取摘要。
*/
公共字符串getStringDigest（）{
如果（摘要==null）
抛出新的RuntimeException（this.getClass（）.getName（））
+“[getStringDigest]”
+