How to Generate an Md5 Hash in Java

How can I generate an MD5 hash in Java?

You need java.security.MessageDigest.

Call MessageDigest.getInstance("MD5") to get a MD5 instance of MessageDigest you can use.

The compute the hash by doing one of:

Feed the entire input as a byte[] and calculate the hash in one operation with md.digest(bytes).
Feed the MessageDigest one byte[] chunk at a time by calling md.update(bytes). When you're done adding input bytes, calculate the hash with
md.digest().

The byte[] returned by md.digest() is the MD5 hash.

Getting a File's MD5 Checksum in Java

There's an input stream decorator, java.security.DigestInputStream, so that you can compute the digest while using the input stream as you normally would, instead of having to make an extra pass over the data.

MessageDigest md = MessageDigest.getInstance("MD5");
try (InputStream is = Files.newInputStream(Paths.get("file.txt"));
     DigestInputStream dis = new DigestInputStream(is, md)) 
{
  /* Read decorated stream (dis) to EOF as normal... */
}
byte[] digest = md.digest();

Create a MD5 hash from the contents of a path in Java

You could read the content of the file by using:

String filepath = "" ; // the full path from system.in
byte[] content = Files.readAllBytes(Paths.get(filepath));

After that, you could get the hash of this bytes array:

public static byte[] MD5(byte[] data) {
    try {
        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        messageDigest.update(data);
        return messageDigest.digest();
    }
    catch(Exception e){
        // any processing
    }
}

for displying the binary content (the bytes array) or send it as string, you could convert it safely using any base-16/32/64 encoding:

String hashString = Base64.getEncoder().encodeToString(bytesArray);

So final code could be:

import java.nio.file.*;
import java.util.*;
import java.security.*;

public class Demo {
    public static void main (String[]args) throws Exception {
        Scanner sc = new Scanner(System.in);
        String path = sc.nextLine(); // read all the string from keyboard
        
        byte[] content = Files.readAllBytes(Paths.get(path));
        byte[] hash = MD5(content);
        
        String hashString = Base64.getEncoder().encodeToString(hash);
        System.out.println("MD5: "+ hashString); 
    }
    
    public static byte[] MD5(byte[] data) throws Exception{
        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        messageDigest.update(data);
        return messageDigest.digest();
    }    
}

Java calculate MD5 hash

You must be missing something. The linked code is just fine. Make sure the issue is nowhere else, related to displaying the result. Possibilities:

in a GUI too small
in a console with multithreading issues
over a network package which is being cut off to soon
you cut the length to 20 instead of 0x20, which is 32.

How to manually write MD5 (to get the hash of a file) algorithm in Java?

I found this implementation of MD5: https://rosettacode.org/wiki/MD5/Implementation#Java

I haven't tested if this is 100% correct though

MD5 Generates 31 character hash in Java

The only issue in your code is when MSB is less than Ox10, the result hash string will only have 31 bytes, instead of 32 bytes, missing the leading zero.

Create your md5 string in this way:

            byte messageDigest[] = m.digest();

            hexString = new StringBuffer();
            for (int i=0;i<messageDigest.length;i++) {
                String hex=Integer.toHexString(0xFF & messageDigest[i]);
                if(hex.length()==1)
                    hexString.append('0');

                hexString.append(hex);
            }

Hash Function MD5 30 length

For generating unique IDs from strings, hash functions are never the correct answer.

What you would need is define a one-to-one mapping of text strings (such as "v1.0.0") onto 30-character-long strings (such as "123123..."). This is also known as a bijection, although in your case a injection (a simple one-to-one mapping from inputs to outputs, not necessarily onto) may be enough. As the other answer at the time of this writing notes, hash functions don't necessarily ensure this mapping, but there are other possibilities, such as full-period linear congruential generators (if they take a seed that you can map one-to-one onto input string values), or other reversible functions.

However, if the set of possible input strings is larger than the set of possible output strings, then you can't map all input strings one-to-one with all output strings (without creating duplicates), due to the pigeonhole principle.

See also this question: How to generate a GUID with a custom alphabet, that behaves similar to an MD5 hash (in JavaScript)?.

Indeed, if you use hash functions, the chance of collision will be close to zero but never exactly zero (meaning that the risk of duplicates will always be there). If we take MD5 as an example (which produces any of 2^128 hash codes), then roughly speaking, the chance of accidental collision becomes non-negligible only after 2^64 IDs are generated, which is well over 1 trillion.

But MD5 and other hash functions are not the right way to do what you want to do. This is discussed next.

If you can't restrict the format of your input strings to 30 digits and can't compress them to 30 digits or less and can't tolerate the risk of duplicates, then the next best thing is to create a database table mapping your input strings to randomly generated IDs.

This database table should have two columns: one column holds your input strings (e.g., "<UUID>-NAME-<UUID>"), and the other column holds randomly generated IDs associated with those strings. Since random numbers don't ensure uniqueness, every time you create a new random ID you will need to check whether the random ID already exists in the database, and if it does exist, try a new random ID (but the chance that a duplicate is found will shrink as the size of the ID grows).