关于java：如何生成MD5哈希？

How can I generate an MD5 hash?

有没有方法在Java中生成字符串的MD5哈希？

MessageDigest类可以为您提供MD5摘要的实例。

在处理字符串和加密类时，请确保始终指定希望使用字节表示形式的编码。如果您只使用string.getBytes()，它将使用平台默认值。(并非所有平台都使用相同的默认值)

1
2
3
4
5
6
7
8

import java.security.*;

..

byte[] bytesOfMessage = yourString.getBytes("UTF-8");

MessageDigest md = MessageDigest.getInstance("MD5");
byte[] thedigest = md.digest(bytesOfMessage);

如果您有大量的数据，请看一看可以重复调用的.update(byte[])方法。然后调用.digest()获取得到的散列值。

相关讨论

你的朋友是你的。调用getInstance("MD5")获取您可以使用的MD5消息摘要。

相关讨论

如果您实际上希望将答案作为字符串而不是字节数组返回，则可以执行以下操作：

1
2
3
4
5
6
7
8
9
10
11

String plaintext ="your text here";
MessageDigest m = MessageDigest.getInstance("MD5");
m.reset();
m.update(plaintext.getBytes());
byte[] digest = m.digest();
BigInteger bigInt = new BigInteger(1,digest);
String hashtext = bigInt.toString(16);
// Now we need to zero pad it if you actually want the full 32 chars.
while(hashtext.length() < 32 ){
hashtext ="0"+hashtext;
}

号

相关讨论

您可能还想看看ApacheCommons编解码器项目的DigestUtils类，它提供了非常方便的方法来创建MD5或SHA Digests。

相关讨论

找到这个：

1
2
3
4
5
6
7
8
9
10
11
12
13

public String MD5(String md5) {
try {
java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
byte[] array = md.digest(md5.getBytes());
StringBuffer sb = new StringBuffer();
for (int i = 0; i < array.length; ++i) {
sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
}
return sb.toString();
} catch (java.security.NoSuchAlgorithmException e) {
}
return null;
}

在下面的网站上，我不相信它，但它是一个有效的解决方案！对于我来说，许多其他代码都不能正常工作，我最终在哈希表中丢失了0。这一个看起来和PHP一样。资料来源：http://m2tec.be/blog/2010/02/03/java-md5-hex-0093

相关讨论

以下是我如何使用它：

1
2
3
4
5

final MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.reset();
messageDigest.update(string.getBytes(Charset.forName("UTF8")));
final byte[] resultByte = messageDigest.digest();
final String result = new String(Hex.encodeHex(resultByte));

其中hex是：来自Apache Commons项目的org.apache.commons.codec.binary.Hex。

相关讨论

我刚下载了commons-codec.jar，得到了类似md5的完美PHP。这是说明书。

只需将其导入到项目中并使用

1
2
3

String Url ="your_url";

System.out.println( DigestUtils.md5Hex( Url ) );

。

就在这里。

相关讨论

我发现这是最清晰、最简洁的方法：

1
2
3

MessageDigest md5 = MessageDigest.getInstance("MD5");
md5.update(StandardCharsets.UTF_8.encode(string));
return String.format("%032x", new BigInteger(1, md5.digest()));

号

相关讨论

找到了这个解决方案，它在从MD5散列中获取字符串表示形式方面要干净得多。

1
2
3
4
5
6
7
8
9
10
11

import java.security.*;
import java.math.*;

public class MD5 {
public static void main(String args[]) throws Exception{
String s="This is a test";
MessageDigest m=MessageDigest.getInstance("MD5");
m.update(s.getBytes(),0,s.length());
System.out.println("MD5:"+new BigInteger(1,m.digest()).toString(16));
}
}

代码是从这里提取的。

相关讨论

另一个实现：

1
2
3
4

import javax.xml.bind.DatatypeConverter;

String hash = DatatypeConverter.printHexBinary(
MessageDigest.getInstance("MD5").digest("SOMESTRING".getBytes("UTF-8")));

。

相关讨论

另一种选择是使用guava散列方法：

1
2
3

Hasher hasher = Hashing.md5().newHasher();
hasher.putString("my string");
byte[] md5 = hasher.hash().asBytes();

。

如果你已经在使用番石榴(如果你没有，你可能应该使用)。

相关讨论

我有一个类(hash)来转换格式为md5或sha1的哈希纯文本，类似于php函数(md5、sha1)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class Hash {
/**
*
* @param txt, text in plain format
* @param hashType MD5 OR SHA1
* @return hash in hashType
*/
public static String getHash(String txt, String hashType) {
try {
java.security.MessageDigest md = java.security.MessageDigest.getInstance(hashType);
byte[] array = md.digest(txt.getBytes());
StringBuffer sb = new StringBuffer();
for (int i = 0; i < array.length; ++i) {
sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
}
return sb.toString();
} catch (java.security.NoSuchAlgorithmException e) {
//error action
}
return null;
}

public static String md5(String txt) {
return Hash.getHash(txt,"MD5");
}

public static String sha1(String txt) {
return Hash.getHash(txt,"SHA1");
}
}

用JUnit和PHP测试PHP脚本：

1
2
3
4
5
6

<?php

echo 'MD5 :' . md5('Hello World') ."
";
echo 'SHA1:' . sha1('Hello World') ."
";

。输出PHP脚本：

1 2	MD5 :b10a8db164e0754105b7a99be72e3fe5 SHA1:0a4d55a8d778e5022fab701977c5d840bbc486d0

使用示例和JUnit测试：

1
2
3
4
5
6
7
8
9
10

public class HashTest {

@Test
public void test() {
String txt ="Hello World";
assertEquals("b10a8db164e0754105b7a99be72e3fe5", Hash.md5(txt));
assertEquals("0a4d55a8d778e5022fab701977c5d840bbc486d0", Hash.sha1(txt));
}

}

。GitHub中的代码

https://github.com/fitorec/java-hashes

号

相关讨论

我的回答不是很透彻：

1
2
3
4
5
6
7
8
9
10
11

private String md5(String s) {
try {
MessageDigest m = MessageDigest.getInstance("MD5");
m.update(s.getBytes(), 0, s.length());
BigInteger i = new BigInteger(1,m.digest());
return String.format("%1$032x", i);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}

。

相关讨论

不必太复杂。DigestUtils工作正常，在使用MD5哈希时让您感到舒适。

1	DigestUtils.md5Hex(_hash);

号

或

1	DigestUtils.md5(_hash);

您可以使用任何其他加密方法，如sha或md。

Bombe的回答是正确的，但是请注意，除非您绝对必须使用MD5(例如为了互操作性而强制使用MD5)，否则更好的选择是sha1，因为MD5在长期使用中存在弱点。

我应该补充一下，sha1也有理论上的弱点，但并没有那么严重。散列技术的最新发展是有许多候选替换散列函数，但还没有一个函数成为替换sha1的标准最佳实践。因此，根据您的需要，我们建议您将哈希算法配置为可配置的，以便将来可以替换它。

相关讨论

春季还有一个DigestUtils班：

http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/util/digestutils.html

此类包含执行该作业的方法md5DigestAsHex()。

相关讨论

你可以尝试跟踪。请参阅以下详细信息并下载代码：http://jkssweetlife.com/java-hashgenerator-md5-sha-1/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Example {

public static void main(String[] args) throws Exception {

final String inputString ="Hello MD5";

System.out.println("MD5 hex for '" + inputString +"' :");
System.out.println(getMD5Hex(inputString));
}

public static String getMD5Hex(final String inputString) throws NoSuchAlgorithmException {

MessageDigest md = MessageDigest.getInstance("MD5");
md.update(inputString.getBytes());

byte[] digest = md.digest();

return convertByteToHex(digest);
}

private static String convertByteToHex(byte[] byteData) {

StringBuilder sb = new StringBuilder();
for (int i = 0; i < byteData.length; i++) {
sb.append(Integer.toString((byteData[i] & 0xff) + 0x100, 16).substring(1));
}

return sb.toString();
}
}

。

另一种实现：快速MD5在爪哇中的实现

1	String hash = MD5.asHex(MD5.getHash(new File(filename)));

。

相关讨论

我不知道这是否与读这本书的人有关，但我只是遇到了我想解决的问题。

从给定的URL下载文件并
将其MD5与已知值进行比较。

我只想使用JRE类(没有ApacheCommons或类似的类)。快速的Web搜索并没有显示同时执行这两个操作的示例代码片段，而是分别执行每个任务。因为这需要读取同一个文件两次，所以我想写一些代码来统一这两个任务，在下载文件时即时计算校验和是值得的。这是我的结果(对不起，如果它不是完美的Java，但我想你还是得到了这个想法)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.security.DigestOutputStream; // new
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

void downloadFile(String fromURL, String toFile, BigInteger md5)
throws IOException, NoSuchAlgorithmException
{
ReadableByteChannel in = Channels.newChannel(new URL(fromURL).openStream());
MessageDigest md5Digest = MessageDigest.getInstance("MD5");
WritableByteChannel out = Channels.newChannel(
//new FileOutputStream(toFile)); // old
new DigestOutputStream(new FileOutputStream(toFile), md5Digest)); // new
ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024); // 1 MB

while (in.read(buffer) != -1) {
buffer.flip();
//md5Digest.update(buffer.asReadOnlyBuffer()); // old
out.write(buffer);
buffer.clear();
}

BigInteger md5Actual = new BigInteger(1, md5Digest.digest());
if (! md5Actual.equals(md5))
throw new RuntimeException(
"MD5 mismatch for file" + toFile +
": expected" + md5.toString(16) +
", got" + md5Actual.toString(16)
);
}

相关讨论

请看下面的链接，该示例获取所提供映像的MD5哈希：图像的MD5哈希

对于它的价值，我偶然发现了这一点，因为我想从一个将安装COM组件的程序的自然键合成guid；我想进行Syhthesize，以便不管理guid生命周期。我将使用MD5，然后使用UUID类从中获取一个字符串。(http://stackoverflow.com/questions/2190890/how-can-i-generate-guid-for-a-string-values/12867439引发了这个问题)。

在任何情况下，java.util.uuid都可以从md5字节中获得一个很好的字符串。

1	return UUID.nameUUIDFromBytes(md5Bytes).toString();

相关讨论

1
2
3
4
5
6
7

import java.security.*;
import javax.xml.bind.*;

byte[] bytesOfMessage = yourString.getBytes("UTF-8");
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] bytesOfDigest = md.digest(bytesOfMessage);
String digest = DatatypeConverter.printHexBinary(bytesOfDigest).toLowerCase();

如果您不需要最好的安全性，MD5是非常好的，而且如果您正在做一些类似于检查文件完整性的事情，那么安全性不是一个考虑因素。在这种情况下，您可能需要考虑更简单和更快速的一些东西，例如AdLeR32，Java语言也支持它。

相关讨论

试试这个：

1
2
3
4
5
6
7
8
9
10
11
12

public static String getHashMD5(String string) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
BigInteger bi = new BigInteger(1, md.digest(string.getBytes()));
return bi.toString(16);
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(MD5Utils.class
.getName()).log(Level.SEVERE, null, ex);

return"";
}
}

号

相关讨论

从MySQL的MD5函数或PHP的MD5函数等中可以得到准确的MD5。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static String md5( String input ) {
try {
java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
byte[] array = md.digest(input.getBytes("UTF-8" ));
StringBuffer sb = new StringBuffer();
for (int i = 0; i < array.length; i++) {
sb.append( String.format("%02x", array[i]));
}
return sb.toString();
} catch ( NoSuchAlgorithmException | UnsupportedEncodingException e) {
return null;
}

}

号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import java.security.MessageDigest

val digest = MessageDigest.getInstance("MD5")

//Quick MD5 of text
val text ="MD5 this text!"
val md5hash1 = digest.digest(text.getBytes).map("%02x".format(_)).mkString

//MD5 of text with updates
digest.update("MD5".getBytes())
digest.update("this".getBytes())
digest.update("text!".getBytes())
val md5hash2 = digest.digest().map(0xFF & _).map("%02x".format(_)).mkString

//Output
println(md5hash1 +" should be the same as" + md5hash2)

号

相关讨论

与PHP不同的是，您可以通过调用MD5函数IEDCX1(0)来实现文本的MD5散列，在Java中，它被稍微复杂化了。我通常通过调用返回MD5哈希文本的函数来实现它。下面是我如何实现它的，首先在您的主类中创建一个名为md5hashing的函数，如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public static String md5hashing(String text)
{ String hashtext = null;
try
{
String plaintext = text;
MessageDigest m = MessageDigest.getInstance("MD5");
m.reset();
m.update(plaintext.getBytes());
byte[] digest = m.digest();
BigInteger bigInt = new BigInteger(1,digest);
hashtext = bigInt.toString(16);
// Now we need to zero pad it if you actually want the full 32 chars.
while(hashtext.length() < 32 ){
hashtext ="0"+hashtext;
}
} catch (Exception e1)
{
// TODO: handle exception
JOptionPane.showMessageDialog(null,e1.getClass().getName() +":" + e1.getMessage());
}
return hashtext;
}

号

现在，在需要时调用函数，如下所示。

1 2	String text = textFieldName.getText(); String pass = md5hashing(text);

号

在这里，您可以看到hashtext附加了一个零，使其与PHP中的MD5哈希匹配。

相关讨论

这就是我来这里的目的-一个方便的scala函数，它返回MD5哈希字符串：

1	def md5(text: String) : String = java.security.MessageDigest.getInstance("MD5").digest(text.getBytes()).map(0xFF & _).map {"%02x".format(_) }.foldLeft(""){_ + _}

号

通过使用java.security包中MessageDigest类中的方法，可以为给定文本生成MD5哈希。下面是完整的代码片段，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.xml.bind.DatatypeConverter;

public class MD5HashGenerator
{

public static void main(String args[]) throws NoSuchAlgorithmException
{
String stringToHash ="MyJavaCode";
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.update(stringToHash.getBytes());
byte[] digiest = messageDigest.digest();
String hashedOutput = DatatypeConverter.printHexBinary(digiest);
System.out.println(hashedOutput);
}
}

。

MD5函数的输出是一个128位哈希，由32个十六进制数字表示。

在这种情况下，如果您使用的是像mysql这样的数据库，那么您也可以用更简单的方法来实现这一点。查询Select MD5("text here")将返回括号中文本的MD5哈希。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
* MD5 encryption
*
* @author Hongten
*
*/
public class MD5 {

public static void main(String[] args) {
System.out.println(MD5.getMD5("123456"));
}

/**
* Use md5 encoded code value
*
* @param sInput
* clearly
* @ return md5 encrypted password
*/
public static String getMD5(String sInput) {

String algorithm ="";
if (sInput == null) {
return"null";
}
try {
algorithm = System.getProperty("MD5.algorithm","MD5");
} catch (SecurityException se) {
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
byte buffer[] = sInput.getBytes();

for (int count = 0; count < sInput.length(); count++) {
md.update(buffer, 0, count);
}
byte bDigest[] = md.digest();
BigInteger bi = new BigInteger(bDigest);
return (bi.toString(16));
}
}

有一篇关于编码工具包的文章。查看：http://codingkit.com/a/java/2013/1020/2216.html

1
2
3
4
5
6
7
8
9
10
11
12

private String hashuj(String dane) throws ServletException{
try {
MessageDigest m = MessageDigest.getInstance("MD5");
byte[] bufor = dane.getBytes();
m.update(bufor,0,bufor.length);
BigInteger hash = new BigInteger(1,m.dige`enter code here`st());
return String.format("%1$032X", hash);

} catch (NoSuchAlgorithmException nsae) {
throw new ServletException("Algorytm szyfrowania nie jest obs?ugiwany!");
}
}

号

相关讨论

我这样做了…似乎工作正常-我相信有人会指出错误…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

public final class MD5 {
public enum SaltOption {
BEFORE, AFTER, BOTH, NONE;
}
private static final String ALG ="MD5";
//For conversion to 2-char hex
private static final char[] digits = {
'0' , '1' , '2' , '3' , '4' , '5' ,
'6' , '7' , '8' , '9' , 'a' , 'b' ,
'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
'o' , 'p' , 'q' , 'r' , 's' , 't' ,
'u' , 'v' , 'w' , 'x' , 'y' , 'z'
};

private SaltOption opt;

/**
* Added the SaltOption constructor since everybody
* has their own standards when it comes to salting
* hashes.
*
* This gives the developer the option...
*
* @param option The salt option to use, BEFORE, AFTER, BOTH or NONE.
*/
public MD5(final SaltOption option) {
//TODO: Add Char Encoding options too... I was too lazy!
this.opt = option;
}

/**
*
* Returns the salted MD5 checksum of the text passed in as an argument.
*
* If the salt is an empty byte array - no salt is applied.
*
* @param txt The text to run through the MD5 algorithm.
* @param salt The salt value in bytes.
* @return The salted MD5 checksum as a <wyn>byte[]</wyn>
* @throws NoSuchAlgorithmException
*/
private byte[] createChecksum(final String txt, final byte[] salt) throws NoSuchAlgorithmException {
final MessageDigest complete = MessageDigest.getInstance(ALG);
if(opt.equals(SaltOption.BEFORE) || opt.equals(SaltOption.BOTH)) {
complete.update(salt);
}
complete.update(txt.getBytes());
if(opt.equals(SaltOption.AFTER) || opt.equals(SaltOption.BOTH)) {
complete.update(salt);
}
return complete.digest();
}

/**
*
* Returns the salted MD5 checksum of the file passed in as an argument.
*
* If the salt is an empty byte array - no salt is applied.
*
* @param fle The file to run through the MD5 algorithm.
* @param salt The salt value in bytes.
* @return The salted MD5 checksum as a <wyn>byte[]</wyn>
* @throws IOException
* @throws NoSuchAlgorithmException
*/
private byte[] createChecksum(final File fle, final byte[] salt)
throws IOException, NoSuchAlgorithmException {
final byte[] buffer = new byte[1024];
final MessageDigest complete = MessageDigest.getInstance(ALG);
if(opt.equals(SaltOption.BEFORE) || opt.equals(SaltOption.BOTH)) {
complete.update(salt);
}
int numRead;
InputStream fis = null;
try {
fis = new FileInputStream(fle);
do {
numRead = fis.read(buffer);
if (numRead > 0) {
complete.update(buffer, 0, numRead);
}
} while (numRead != -1);
} finally {
if (fis != null) {
fis.close();
}
}
if(opt.equals(SaltOption.AFTER) || opt.equals(SaltOption.BOTH)) {
complete.update(salt);
}
return complete.digest();
}

/**
*
* Efficiently converts a byte array to its 2 char per byte hex equivalent.
*
* This was adapted from JDK code in the Integer class, I just didn't like
* having to use substrings once I got the result...
*
* @param b The byte array to convert
* @return The converted String, 2 chars per byte...
*/
private String convertToHex(final byte[] b) {
int x;
int charPos;
int radix;
int mask;
final char[] buf = new char[32];
final char[] tmp = new char[3];
final StringBuilder md5 = new StringBuilder();
for (int i = 0; i < b.length; i++) {
x = (b[i] & 0xFF) | 0x100;
charPos = 32;
radix = 1 << 4;
mask = radix - 1;
do {
buf[--charPos] = digits[x & mask];
x >>>= 4;
} while (x != 0);
System.arraycopy(buf, charPos, tmp, 0, (32 - charPos));
md5.append(Arrays.copyOfRange(tmp, 1, 3));
}
return md5.toString();
}

/**
*
* Returns the salted MD5 checksum of the file passed in as an argument.
*
* @param fle The file you want want to run through the MD5 algorithm.
* @param salt The salt value in bytes
* @return The salted MD5 checksum as a 2 char per byte HEX <wyn>String</wyn>
* @throws NoSuchAlgorithmException
* @throws IOException
*/
public String getMD5Checksum(final File fle, final byte[] salt)
throws NoSuchAlgorithmException, IOException {
return convertToHex(createChecksum(fle, salt));
}

/**
*
* Returns the MD5 checksum of the file passed in as an argument.
*
* @param fle The file you want want to run through the MD5 algorithm.
* @return The MD5 checksum as a 2 char per byte HEX <wyn>String</wyn>
* @throws NoSuchAlgorithmException
* @throws IOException
*/
public String getMD5Checksum(final File fle)
throws NoSuchAlgorithmException, IOException {
return convertToHex(createChecksum(fle, new byte[0]));
}

/**
*
* Returns the salted MD5 checksum of the text passed in as an argument.
*
* @param txt The text you want want to run through the MD5 algorithm.
* @param salt The salt value in bytes.
* @return The salted MD5 checksum as a 2 char per byte HEX <wyn>String</wyn>
* @throws NoSuchAlgorithmException
* @throws IOException
*/
public String getMD5Checksum(final String txt, final byte[] salt)
throws NoSuchAlgorithmException {
return convertToHex(createChecksum(txt, salt));
}

/**
*
* Returns the MD5 checksum of the text passed in as an argument.
*
* @param txt The text you want want to run through the MD5 algorithm.
* @return The MD5 checksum as a 2 char per byte HEX <wyn>String</wyn>
* @throws NoSuchAlgorithmException
* @throws IOException
*/
public String getMD5Checksum(final String txt)
throws NoSuchAlgorithmException {

return convertToHex(createChecksum(txt, new byte[0]));
}
}

。

我知道，问题是关于Java的，但是我想在这里列出一个ActionScript 1的源代码(这里是许可证)，以不同于本页列出的答案来生成MD5。

下面的函数工作得很好，当然可以转换成Java：

/* MD5 implementation from http://www.webtoolkit.info */

function md5(string) {

function RotateLeft(lValue, iShiftBits) {
return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits));
}

function AddUnsigned(lX,lY) {
var lX4,lY4,lX8,lY8,lResult;
lX8 = (lX & 0x80000000);
lY8 = (lY & 0x80000000);
lX4 = (lX & 0x40000000);
lY4 = (lY & 0x40000000);
lResult = (lX & 0x3FFFFFFF)+(lY & 0x3FFFFFFF);
if (lX4 & lY4) {
return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
}
if (lX4 | lY4) {
if (lResult & 0x40000000) {
return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
} else {
return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
}
} else {
return (lResult ^ lX8 ^ lY8);
}
}

function F(x,y,z) { return (x & y) | ((~x) & z); }
function G(x,y,z) { return (x & z) | (y & (~z)); }
function H(x,y,z) { return (x ^ y ^ z); }
function I(x,y,z) { return (y ^ (x | (~z))); }

function FF(a,b,c,d,x,s,ac) {
a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
return AddUnsigned(RotateLeft(a, s), b);
};

function GG(a,b,c,d,x,s,ac) {
a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
return AddUnsigned(RotateLeft(a, s), b);
};

function HH(a,b,c,d,x,s,ac) {
a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
return AddUnsigned(RotateLeft(a, s), b);
};

function II(a,b,c,d,x,s,ac) {
a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
return AddUnsigned(RotateLeft(a, s), b);
};

function ConvertToWordArray(string) {
var lWordCount;
var lMessageLength = string.length;
var lNumberOfWords_temp1=lMessageLength + 8;
var lNumberOfWords_temp2=(lNumberOfWords_temp1-(lNumberOfWords_temp1 % 64))/64;
var lNumberOfWords = (lNumberOfWords_temp2+1)*16;
var lWordArray=Array(lNumberOfWords-1);
var lBytePosition = 0;
var lByteCount = 0;
while ( lByteCount < lMessageLength ) {
lWordCount = (lByteCount-(lByteCount % 4))/4;
lBytePosition = (lByteCount % 4)*8;
lWordArray[lWordCount] = (lWordArray[lWordCount] |
(string.charCodeAt(lByteCount)<<lBytePosition));
lByteCount++;
}
lWordCount = (lByteCount-(lByteCount % 4))/4;
lBytePosition = (lByteCount % 4)*8;
lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80<<lBytePosition);
lWordArray[lNumberOfWords-2] = lMessageLength<<3;
lWordArray[lNumberOfWords-1] = lMessageLength>>>29;
return lWordArray;
};

function WordToHex(lValue) {
var WordToHexValue="",WordToHexValue_temp="",lByte,lCount;
for (lCount = 0;lCount<=3;lCount++) {
lByte = (lValue>>>(lCount*8)) & 255;
WordToHexValue_temp ="0" + lByte.toString(16);
WordToHexValue = WordToHexValue +
WordToHexValue_temp.substr(WordToHexValue_temp.length-2,2);
}
return WordToHexValue;
};

function Utf8Encode(string) {

var utftext ="";

for (var n = 0; n < string.length; n++) {

var c = string.charCodeAt(n);

if (c < 128) {
utftext += String.fromCharCode(c);
}
else if((c > 127) && (c < 2048)) {
utftext += String.fromCharCode((c >> 6) | 192);
utftext += String.fromCharCode((c & 63) | 128);
}
else {
utftext += String.fromCharCode((c >> 12) | 224);
utftext += String.fromCharCode(((c >> 6) & 63) | 128);
utftext += String.fromCharCode((c & 63) | 128);
}

}

return utftext;
};

var x=Array();
var k,AA,BB,CC,DD,a,b,c,d;
var S11=7, S12=12, S13=17, S14=22;
var S21=5, S22=9 , S23=14, S24=20;
var S31=4, S32=11, S33=16, S34=23;
var S41=6, S42=10, S43=15, S44=21;

string = Utf8Encode(string);

x = ConvertToWordArray(string);

a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;

for (k=0;k<x.length;k+=16) {
AA=a; BB=b; CC=c; DD=d;
a=FF(a,b,c,d,x[k+0], S11,0xD76AA478);
d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
c=FF(c,d,a,b,x[k+2], S13,0x242070DB);
b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
d=FF(d,a,b,c,x[k+5], S12,0x4787C62A);
c=FF(c,d,a,b,x[k+6], S13,0xA8304613);
b=FF(b,c,d,a,x[k+7], S14,0xFD469501);
a=FF(a,b,c,d,x[k+8], S11,0x698098D8);
d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
a=FF(a,b,c,d,x[k+12],S11,0x6B901122);
d=FF(d,a,b,c,x[k+13],S12,0xFD987193);
c=FF(c,d,a,b,x[k+14],S13,0xA679438E);
b=FF(b,c,d,a,x[k+15],S14,0x49B40821);
a=GG(a,b,c,d,x[k+1], S21,0xF61E2562);
d=GG(d,a,b,c,x[k+6], S22,0xC040B340);
c=GG(c,d,a,b,x[k+11],S23,0x265E5A51);
b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
a=GG(a,b,c,d,x[k+5], S21,0xD62F105D);
d=GG(d,a,b,c,x[k+10],S22,0x2441453);
c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
d=GG(d,a,b,c,x[k+14],S22,0xC33707D6);
c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
b=GG(b,c,d,a,x[k+8], S24,0x455A14ED);
a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
c=GG(c,d,a,b,x[k+7], S23,0x676F02D9);
b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
d=HH(d,a,b,c,x[k+8], S32,0x8771F681);
c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
b=HH(b,c,d,a,x[k+6], S34,0x4881D05);
a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
a=II(a,b,c,d,x[k+0], S41,0xF4292244);
d=II(d,a,b,c,x[k+7], S42,0x432AFF97);
c=II(c,d,a,b,x[k+14],S43,0xAB9423A7);
b=II(b,c,d,a,x[k+5], S44,0xFC93A039);
a=II(a,b,c,d,x[k+12],S41,0x655B59C3);
d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
b=II(b,c,d,a,x[k+1], S44,0x85845DD1);
a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
c=II(c,d,a,b,x[k+6], S43,0xA3014314);
b=II(b,c,d,a,x[k+13],S44,0x4E0811A1);
a=II(a,b,c,d,x[k+4], S41,0xF7537E82);
d=II(d,a,b,c,x[k+11],S42,0xBD3AF235);
c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
b=II(b,c,d,a,x[k+9], S44,0xEB86D391);
a=AddUnsigned(a,AA);
b=AddUnsigned(b,BB);
c=AddUnsigned(c,CC);
d=AddUnsigned(d,DD);
}

var temp = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);

return temp.toLowerCase();
}

号