“**MD5**” corresponds to a widely used cryptographic algorithm in Java which generates a hash of 128 bits. This algorithm utilizes the “**MessageDigest**” class which is contained in the “**java.security**” package. This algorithm is effective as it consumes less resources.

This article will discuss the approach to compute “MD5” in Java.

**What is MD5?**

“**MD5**” corresponds to a cryptographic algorithm that gives the hash functions to retrieve a fixed length i.e., 128-bit (16 bytes) hash value.

**How to Calculate MD 5 in Java?**

To compute the cryptographic hashing value in Java, the “**MessageDigest**” class is utilized. This class provides the following cryptographic hash function to return the hash value of a text:

- MD5
- SHA-1
- SHA-256

**Working of the “MessageDigest” Class**

The above-stated hash functions/algorithms are initialized in the static “**getInstance()**” method. After opting for the algorithm i.e., “MD5” etc., it computes the digest value and retrieves the results in a byte array. After that, the “**BigInteger**” class is applied which transforms the resultant byte array into the corresponding sign-magnitude representation.

**Advantages of MD5**

- Convenient for comparing small hashes.
- Less consumption of resources.
- Convenience in storing passwords.
- Improved Integrity.

**Working of MD5**

The “**MD5**” algorithm works based on the following 4 steps:

**Step 1: Add Extra Bits**

The first step of the algorithm includes appending extra bits to the provided string. It is done to make the length of the string a multiple of 512 bits.

**Step 2: Append/Add Length**

After adding extra bits, add length by appending 64 bits at last. It keeps track of the input’s length provided by the user.

**Step 3: Initialize the MD Buffer**

MD buffer refers to a 4-word (A, B, C, D) buffer where each word refers to a 32-bit register that calculates the message digest’s value.

**Step 4: Processing in a 16-Word Block**

The “**MD5**” algo utilizes the functions(auxiliary) that take the inputs as three 32-bit numbers and generate 32-bits as an outcome. These functions utilize the OR, XOR, and NOR operators.

**Example: Calculating the “MD5” Hash Value in Java**

The below code example computes the “**MD5**” hash value:

```
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5 {
public static String retrieveMd5(String x){
try {
MessageDigest a = MessageDigest.getInstance("MD5");
byte[] messageDigest = a.digest(x.getBytes());
BigInteger b = new BigInteger(1, messageDigest);
String hashtext = b.toString(16);
while (hashtext.length() < 32) {
hashtext = "0" + hashtext;
}
return hashtext;
}
catch (NoSuchAlgorithmException except) {
throw new RuntimeException(except);
}}
public static void main(String args[]) throws NoSuchAlgorithmException{
String c = "Harry";
System.out.println("HashCode Generated Via MD5 -> " + retrieveMd5(c));
}}
```

According to the above code limes, perform the below-given steps:

- Declare the function “
**retrieveMd5()**” that takes the passed string as its argument. - In the “try” block, apply the “
**getInstance()**” method with the “MD5” hashing. - After that, the “
**digest()**” method is utilized to compute the message digest of an input digest that retrieves an array of bytes. - Now, transform the array to the representation of signum.
- In the next step, convert the message digest to hex value via the combined “
**toString()**” and “**length()**” methods. - In the “catch” block, cope up with the probable message digest algorithms limitation.
- Finally, in “
**main**”, invoke the defined function by passing the defined string as its argument to fetch the corresponding hashcode based on this string.

**Output**

This outcome implies that the corresponding hash code with respect to the string is generated appropriately.

**Conclusion**

To compute the cryptographic hashing value in Java, the “**MessageDigest**” class is utilized to compute the digest value, retrieves the results in a byte array and the “**BigInteger**” class transforms the resultant byte array into its sign-magnitude representation. This write-up elaborated on computing the “MD 5” hash value in Java.