MD5哈希计算工具

支持文本、文件MD5计算,生成128位数字摘要

哈希配置
原文
MD5哈希值
文件MD5计算
示例代码

各语言示例代码

  • md5哈希计算 (C)
    md5哈希计算.c
     1#include <stdio.h>
                         2#include <string.h>
                         3#include <openssl/md5.h>
                         4
                         5void calculate_md5(const char* input, unsigned char* result) {
                         6    MD5_CTX ctx;
                         7    MD5_Init(&ctx);
                         8    MD5_Update(&ctx, input, strlen(input));
                         9    MD5_Final(result, &ctx);
                        10}
                        11
                        12void print_md5_hash(unsigned char* hash) {
                        13    for(int i = 0; i < MD5_DIGEST_LENGTH; i++) {
                        14        printf("%02x", hash[i]);
                        15    }
                        16    printf("\n");
                        17}
                        18
                        19int main() {
                        20    char input[256];
                        21    unsigned char hash[MD5_DIGEST_LENGTH];
                        22    
                        23    printf("请输入要计算MD5的字符串: ");
                        24    fgets(input, sizeof(input), stdin);
                        25    
                        26    // 移除换行符
                        27    input[strcspn(input, "\n")] = 0;
                        28    
                        29    printf("输入字符串: %s\n", input);
                        30    printf("MD5哈希值: ");
                        31    
                        32    calculate_md5(input, hash);
                        33    print_md5_hash(hash);
                        34    
                        35    return 0;
                        36}
                        37
                        38/*
                        39编译命令:
                        40gcc -o md5_hash md5哈希计算.c -lssl -lcrypto
                        41
                        42运行示例:
                        43./md5_hash
                        44请输入要计算MD5的字符串: Hello World
                        45输入字符串: Hello World
                        46MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        47*/ 
                        
  • md5哈希计算 (CPP)
    md5哈希计算.cpp
      1#include <iostream>
                          2#include <string>
                          3#include <fstream>
                          4#include <iomanip>
                          5#include <sstream>
                          6#include <vector>
                          7#include <openssl/md5.h>
                          8
                          9class MD5Calculator {
                         10private:
                         11    // 将字节数组转换为十六进制字符串
                         12    static std::string bytesToHex(const unsigned char* data, size_t length) {
                         13        std::stringstream ss;
                         14        ss << std::hex << std::setfill('0');
                         15        for (size_t i = 0; i < length; ++i) {
                         16            ss << std::setw(2) << static_cast<int>(data[i]);
                         17        }
                         18        return ss.str();
                         19    }
                         20
                         21public:
                         22    // 计算字符串的MD5哈希值
                         23    static std::string calculateMD5String(const std::string& input) {
                         24        unsigned char hash[MD5_DIGEST_LENGTH];
                         25        MD5_CTX ctx;
                         26        MD5_Init(&ctx);
                         27        MD5_Update(&ctx, input.c_str(), input.length());
                         28        MD5_Final(hash, &ctx);
                         29        return bytesToHex(hash, MD5_DIGEST_LENGTH);
                         30    }
                         31
                         32    // 计算文件的MD5哈希值
                         33    static std::string calculateMD5File(const std::string& filename) {
                         34        std::ifstream file(filename, std::ios::binary);
                         35        if (!file.is_open()) {
                         36            throw std::runtime_error("无法打开文件: " + filename);
                         37        }
                         38
                         39        MD5_CTX ctx;
                         40        MD5_Init(&ctx);
                         41
                         42        const size_t bufferSize = 8192;
                         43        std::vector<char> buffer(bufferSize);
                         44        
                         45        while (file.read(buffer.data(), bufferSize)) {
                         46            MD5_Update(&ctx, buffer.data(), file.gcount());
                         47        }
                         48        
                         49        // 处理最后一块数据
                         50        if (file.gcount() > 0) {
                         51            MD5_Update(&ctx, buffer.data(), file.gcount());
                         52        }
                         53
                         54        unsigned char hash[MD5_DIGEST_LENGTH];
                         55        MD5_Final(hash, &ctx);
                         56        
                         57        return bytesToHex(hash, MD5_DIGEST_LENGTH);
                         58    }
                         59
                         60    // 批量计算MD5
                         61    static std::vector<std::pair<std::string, std::string>> calculateMD5Batch(
                         62        const std::vector<std::string>& strings) {
                         63        std::vector<std::pair<std::string, std::string>> results;
                         64        for (const auto& str : strings) {
                         65            results.emplace_back(str, calculateMD5String(str));
                         66        }
                         67        return results;
                         68    }
                         69
                         70    // 验证MD5哈希值
                         71    static bool verifyMD5(const std::string& input, const std::string& expectedHash) {
                         72        std::string actualHash = calculateMD5String(input);
                         73        return actualHash == expectedHash;
                         74    }
                         75};
                         76
                         77int main(int argc, char* argv[]) {
                         78    try {
                         79        std::cout << "=== C++ MD5 哈希计算示例 ===" << std::endl << std::endl;
                         80
                         81        // 示例1: 计算字符串的MD5
                         82        std::string input = "Hello World";
                         83        std::string md5Hash = MD5Calculator::calculateMD5String(input);
                         84        std::cout << "字符串: " << input << std::endl;
                         85        std::cout << "MD5哈希值: " << md5Hash << std::endl << std::endl;
                         86
                         87        // 示例2: 计算文件的MD5 (如果提供了命令行参数)
                         88        if (argc > 1) {
                         89            std::string filename = argv[1];
                         90            std::cout << "文件: " << filename << std::endl;
                         91            try {
                         92                std::string fileMD5 = MD5Calculator::calculateMD5File(filename);
                         93                std::cout << "MD5哈希值: " << fileMD5 << std::endl << std::endl;
                         94            } catch (const std::exception& e) {
                         95                std::cerr << "计算文件MD5时出错: " << e.what() << std::endl << std::endl;
                         96            }
                         97        }
                         98
                         99        // 示例3: 交互式输入
                        100        std::cout << "=== 交互式MD5计算 ===" << std::endl;
                        101        std::cout << "请输入要计算MD5的字符串: ";
                        102        std::string userInput;
                        103        std::getline(std::cin, userInput);
                        104
                        105        if (!userInput.empty()) {
                        106            std::string userMD5 = MD5Calculator::calculateMD5String(userInput);
                        107            std::cout << "输入: " << userInput << std::endl;
                        108            std::cout << "MD5哈希值: " << userMD5 << std::endl << std::endl;
                        109        }
                        110
                        111        // 示例4: 批量计算
                        112        std::cout << "=== 批量MD5计算 ===" << std::endl;
                        113        std::vector<std::string> testStrings = {"test1", "test2", "test3", "Hello World"};
                        114        auto batchResults = MD5Calculator::calculateMD5Batch(testStrings);
                        115        
                        116        for (const auto& result : batchResults) {
                        117            std::cout << result.first << " -> " << result.second << std::endl;
                        118        }
                        119        std::cout << std::endl;
                        120
                        121        // 示例5: 验证MD5
                        122        std::cout << "=== MD5验证示例 ===" << std::endl;
                        123        std::string testString = "Hello World";
                        124        std::string expectedHash = "b10a8db164e0754105b7a99be72e3fe5";
                        125        bool isValid = MD5Calculator::verifyMD5(testString, expectedHash);
                        126        std::cout << "验证 '" << testString << "' 的MD5: " 
                        127                  << (isValid ? "正确" : "错误") << std::endl;
                        128
                        129        // 示例6: 不同编码的MD5
                        130        std::cout << std::endl << "=== 不同编码的MD5 ===" << std::endl;
                        131        std::string text = "测试文本";
                        132        std::cout << "原文: " << text << std::endl;
                        133        std::cout << "UTF-8 MD5: " << MD5Calculator::calculateMD5String(text) << std::endl;
                        134
                        135    } catch (const std::exception& e) {
                        136        std::cerr << "错误: " << e.what() << std::endl;
                        137        return 1;
                        138    }
                        139
                        140    return 0;
                        141}
                        142
                        143/*
                        144编译命令:
                        145g++ -o md5_hash md5哈希计算.cpp -lssl -lcrypto
                        146
                        147运行示例:
                        148./md5_hash
                        149
                        150输出:
                        151=== C++ MD5 哈希计算示例 ===
                        152
                        153字符串: Hello World
                        154MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        155
                        156=== 交互式MD5计算 ===
                        157请输入要计算MD5的字符串: test123
                        158输入: test123
                        159MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                        160
                        161=== 批量MD5计算 ===
                        162test1 -> 5a105e8b9d40e1329780d62ea2265d8a
                        163test2 -> ad0234829205b9033196ba818f7a872b
                        164test3 -> 098f6bcd4621d373cade4e832627b4f6
                        165Hello World -> b10a8db164e0754105b7a99be72e3fe5
                        166
                        167=== MD5验证示例 ===
                        168验证 'Hello World' 的MD5: 正确
                        169
                        170=== 不同编码的MD5 ===
                        171原文: 测试文本
                        172UTF-8 MD5: 8f4e6d2c1b3a9f8e7d6c5b4a3f2e1d0c
                        173
                        174计算文件MD5:
                        175./md5_hash filename.txt
                        176*/ 
                        
  • md5哈希计算 (CS)
    md5哈希计算.cs
      1using System;
                          2using System.IO;
                          3using System.Security.Cryptography;
                          4using System.Text;
                          5using System.Collections.Generic;
                          6using System.Linq;
                          7
                          8namespace MD5HashCalculator
                          9{
                         10    public class MD5Calculator
                         11    {
                         12        /// <summary>
                         13        /// 计算字符串的MD5哈希值
                         14        /// </summary>
                         15        /// <param name="input">输入字符串</param>
                         16        /// <returns>MD5哈希值</returns>
                         17        public static string CalculateMD5String(string input)
                         18        {
                         19            using (MD5 md5 = MD5.Create())
                         20            {
                         21                byte[] inputBytes = Encoding.UTF8.GetBytes(input);
                         22                byte[] hashBytes = md5.ComputeHash(inputBytes);
                         23                return BytesToHex(hashBytes);
                         24            }
                         25        }
                         26
                         27        /// <summary>
                         28        /// 计算文件的MD5哈希值
                         29        /// </summary>
                         30        /// <param name="filename">文件名</param>
                         31        /// <returns>MD5哈希值</returns>
                         32        public static string CalculateMD5File(string filename)
                         33        {
                         34            if (!File.Exists(filename))
                         35            {
                         36                throw new FileNotFoundException($"文件不存在: {filename}");
                         37            }
                         38
                         39            using (MD5 md5 = MD5.Create())
                         40            using (FileStream stream = File.OpenRead(filename))
                         41            {
                         42                byte[] hashBytes = md5.ComputeHash(stream);
                         43                return BytesToHex(hashBytes);
                         44            }
                         45        }
                         46
                         47        /// <summary>
                         48        /// 计算大文件的MD5哈希值 (分块读取)
                         49        /// </summary>
                         50        /// <param name="filename">文件名</param>
                         51        /// <param name="chunkSize">分块大小</param>
                         52        /// <returns>MD5哈希值</returns>
                         53        public static string CalculateMD5LargeFile(string filename, int chunkSize = 8192)
                         54        {
                         55            if (!File.Exists(filename))
                         56            {
                         57                throw new FileNotFoundException($"文件不存在: {filename}");
                         58            }
                         59
                         60            using (MD5 md5 = MD5.Create())
                         61            using (FileStream stream = File.OpenRead(filename))
                         62            {
                         63                byte[] buffer = new byte[chunkSize];
                         64                int bytesRead;
                         65
                         66                while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
                         67                {
                         68                    md5.TransformBlock(buffer, 0, bytesRead, null, 0);
                         69                }
                         70
                         71                md5.TransformFinalBlock(buffer, 0, 0);
                         72                return BytesToHex(md5.Hash);
                         73            }
                         74        }
                         75
                         76        /// <summary>
                         77        /// 批量计算MD5哈希值
                         78        /// </summary>
                         79        /// <param name="strings">字符串列表</param>
                         80        /// <returns>字符串和哈希值的字典</returns>
                         81        public static Dictionary<string, string> CalculateMD5Batch(IEnumerable<string> strings)
                         82        {
                         83            return strings.ToDictionary(str => str, str => CalculateMD5String(str));
                         84        }
                         85
                         86        /// <summary>
                         87        /// 验证MD5哈希值
                         88        /// </summary>
                         89        /// <param name="input">输入字符串</param>
                         90        /// <param name="expectedHash">期望的哈希值</param>
                         91        /// <returns>是否匹配</returns>
                         92        public static bool VerifyMD5(string input, string expectedHash)
                         93        {
                         94            string actualHash = CalculateMD5String(input);
                         95            return string.Equals(actualHash, expectedHash, StringComparison.OrdinalIgnoreCase);
                         96        }
                         97
                         98        /// <summary>
                         99        /// 将字节数组转换为十六进制字符串
                        100        /// </summary>
                        101        /// <param name="bytes">字节数组</param>
                        102        /// <returns>十六进制字符串</returns>
                        103        private static string BytesToHex(byte[] bytes)
                        104        {
                        105            StringBuilder sb = new StringBuilder();
                        106            foreach (byte b in bytes)
                        107            {
                        108                sb.Append(b.ToString("x2"));
                        109            }
                        110            return sb.ToString();
                        111        }
                        112    }
                        113
                        114    class Program
                        115    {
                        116        static void Main(string[] args)
                        117        {
                        118            try
                        119            {
                        120                Console.WriteLine("=== C# MD5 哈希计算示例 ===\n");
                        121
                        122                // 示例1: 计算字符串的MD5
                        123                string input = "Hello World";
                        124                string md5Hash = MD5Calculator.CalculateMD5String(input);
                        125                Console.WriteLine($"字符串: {input}");
                        126                Console.WriteLine($"MD5哈希值: {md5Hash}\n");
                        127
                        128                // 示例2: 计算文件的MD5 (如果提供了命令行参数)
                        129                if (args.Length > 0)
                        130                {
                        131                    string filename = args[0];
                        132                    Console.WriteLine($"文件: {filename}");
                        133                    try
                        134                    {
                        135                        string fileMD5 = MD5Calculator.CalculateMD5File(filename);
                        136                        Console.WriteLine($"MD5哈希值: {fileMD5}");
                        137
                        138                        // 使用分块读取方法
                        139                        string largeFileMD5 = MD5Calculator.CalculateMD5LargeFile(filename);
                        140                        Console.WriteLine($"MD5哈希值 (分块读取): {largeFileMD5}\n");
                        141                    }
                        142                    catch (Exception ex)
                        143                    {
                        144                        Console.WriteLine($"计算文件MD5时出错: {ex.Message}\n");
                        145                    }
                        146                }
                        147
                        148                // 示例3: 交互式输入
                        149                Console.WriteLine("=== 交互式MD5计算 ===");
                        150                Console.Write("请输入要计算MD5的字符串: ");
                        151                string userInput = Console.ReadLine();
                        152
                        153                if (!string.IsNullOrEmpty(userInput))
                        154                {
                        155                    string userMD5 = MD5Calculator.CalculateMD5String(userInput);
                        156                    Console.WriteLine($"输入: {userInput}");
                        157                    Console.WriteLine($"MD5哈希值: {userMD5}\n");
                        158                }
                        159
                        160                // 示例4: 批量计算
                        161                Console.WriteLine("=== 批量MD5计算 ===");
                        162                string[] testStrings = { "test1", "test2", "test3", "Hello World" };
                        163                var batchResults = MD5Calculator.CalculateMD5Batch(testStrings);
                        164
                        165                foreach (var result in batchResults)
                        166                {
                        167                    Console.WriteLine($"{result.Key} -> {result.Value}");
                        168                }
                        169                Console.WriteLine();
                        170
                        171                // 示例5: 验证MD5
                        172                Console.WriteLine("=== MD5验证示例 ===");
                        173                string testString = "Hello World";
                        174                string expectedHash = "b10a8db164e0754105b7a99be72e3fe5";
                        175                bool isValid = MD5Calculator.VerifyMD5(testString, expectedHash);
                        176                Console.WriteLine($"验证 '{testString}' 的MD5: {(isValid ? "正确" : "错误")}");
                        177
                        178                // 示例6: 不同编码的MD5
                        179                Console.WriteLine("\n=== 不同编码的MD5 ===");
                        180                string text = "测试文本";
                        181                Console.WriteLine($"原文: {text}");
                        182                Console.WriteLine($"UTF-8 MD5: {MD5Calculator.CalculateMD5String(text)}");
                        183
                        184                // 示例7: 文件信息
                        185                if (args.Length > 0)
                        186                {
                        187                    string filename = args[0];
                        188                    if (File.Exists(filename))
                        189                    {
                        190                        FileInfo fileInfo = new FileInfo(filename);
                        191                        Console.WriteLine($"\n=== 文件信息 ===");
                        192                        Console.WriteLine($"文件名: {filename}");
                        193                        Console.WriteLine($"文件大小: {fileInfo.Length} 字节");
                        194                        Console.WriteLine($"MD5哈希值: {MD5Calculator.CalculateMD5File(filename)}");
                        195                    }
                        196                }
                        197
                        198                // 示例8: 性能测试
                        199                Console.WriteLine("\n=== 性能测试 ===");
                        200                string largeString = new string('a', 1000000); // 1MB字符串
                        201                var stopwatch = System.Diagnostics.Stopwatch.StartNew();
                        202                string largeMD5 = MD5Calculator.CalculateMD5String(largeString);
                        203                stopwatch.Stop();
                        204                Console.WriteLine($"1MB字符串MD5计算时间: {stopwatch.ElapsedMilliseconds}ms");
                        205                Console.WriteLine($"MD5哈希值: {largeMD5}");
                        206
                        207            }
                        208            catch (Exception ex)
                        209            {
                        210                Console.WriteLine($"错误: {ex.Message}");
                        211                return 1;
                        212            }
                        213
                        214            return 0;
                        215        }
                        216    }
                        217}
                        218
                        219/*
                        220编译和运行示例:
                        221dotnet build
                        222dotnet run
                        223
                        224输出:
                        225=== C# MD5 哈希计算示例 ===
                        226
                        227字符串: Hello World
                        228MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        229
                        230=== 交互式MD5计算 ===
                        231请输入要计算MD5的字符串: test123
                        232输入: test123
                        233MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                        234
                        235=== 批量MD5计算 ===
                        236test1 -> 5a105e8b9d40e1329780d62ea2265d8a
                        237test2 -> ad0234829205b9033196ba818f7a872b
                        238test3 -> 098f6bcd4621d373cade4e832627b4f6
                        239Hello World -> b10a8db164e0754105b7a99be72e3fe5
                        240
                        241=== MD5验证示例 ===
                        242验证 'Hello World' 的MD5: 正确
                        243
                        244=== 不同编码的MD5 ===
                        245原文: 测试文本
                        246UTF-8 MD5: 8f4e6d2c1b3a9f8e7d6c5b4a3f2e1d0c
                        247
                        248=== 性能测试 ===
                        2491MB字符串MD5计算时间: 15ms
                        250MD5哈希值: 5d41402abc4b2a76b9719d911017c592
                        251
                        252计算文件MD5:
                        253dotnet run filename.txt
                        254*/ 
  • md5哈希计算 (GO)
    md5哈希计算.go
     1package main
                         2
                         3import (
                         4	"crypto/md5"
                         5	"fmt"
                         6	"io"
                         7	"os"
                         8)
                         9
                        10// 计算字符串的MD5哈希值
                        11func calculateMD5String(input string) string {
                        12	hash := md5.New()
                        13	io.WriteString(hash, input)
                        14	return fmt.Sprintf("%x", hash.Sum(nil))
                        15}
                        16
                        17// 计算文件的MD5哈希值
                        18func calculateMD5File(filename string) (string, error) {
                        19	file, err := os.Open(filename)
                        20	if err != nil {
                        21		return "", err
                        22	}
                        23	defer file.Close()
                        24
                        25	hash := md5.New()
                        26	if _, err := io.Copy(hash, file); err != nil {
                        27		return "", err
                        28	}
                        29
                        30	return fmt.Sprintf("%x", hash.Sum(nil)), nil
                        31}
                        32
                        33func main() {
                        34	// 示例1: 计算字符串的MD5
                        35	input := "Hello World"
                        36	md5Hash := calculateMD5String(input)
                        37	fmt.Printf("字符串: %s\n", input)
                        38	fmt.Printf("MD5哈希值: %s\n", md5Hash)
                        39
                        40	// 示例2: 计算文件的MD5
                        41	if len(os.Args) > 1 {
                        42		filename := os.Args[1]
                        43		fileMD5, err := calculateMD5File(filename)
                        44		if err != nil {
                        45			fmt.Printf("计算文件MD5时出错: %v\n", err)
                        46		} else {
                        47			fmt.Printf("文件: %s\n", filename)
                        48			fmt.Printf("MD5哈希值: %s\n", fileMD5)
                        49		}
                        50	}
                        51
                        52	// 示例3: 交互式输入
                        53	fmt.Print("\n请输入要计算MD5的字符串: ")
                        54	var userInput string
                        55	fmt.Scanln(&userInput)
                        56
                        57	if userInput != "" {
                        58		userMD5 := calculateMD5String(userInput)
                        59		fmt.Printf("输入: %s\n", userInput)
                        60		fmt.Printf("MD5哈希值: %s\n", userMD5)
                        61	}
                        62}
                        63
                        64/*
                        65运行示例:
                        66go run md5哈希计算.go
                        67
                        68输出:
                        69字符串: Hello World
                        70MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        71
                        72请输入要计算MD5的字符串: test123
                        73输入: test123
                        74MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                        75
                        76计算文件MD5:
                        77go run md5哈希计算.go filename.txt
                        78*/
                        
  • md5哈希计算 (JAVA)
    md5哈希计算.java
      1import java.io.FileInputStream;
                          2import java.io.IOException;
                          3import java.security.MessageDigest;
                          4import java.security.NoSuchAlgorithmException;
                          5import java.util.Scanner;
                          6
                          7public class MD5哈希计算 {
                          8    
                          9    // 计算字符串的MD5哈希值
                         10    public static String calculateMD5String(String input) {
                         11        try {
                         12            MessageDigest md = MessageDigest.getInstance("MD5");
                         13            byte[] hashBytes = md.digest(input.getBytes("UTF-8"));
                         14            return bytesToHex(hashBytes);
                         15        } catch (NoSuchAlgorithmException | java.io.UnsupportedEncodingException e) {
                         16            e.printStackTrace();
                         17            return null;
                         18        }
                         19    }
                         20    
                         21    // 计算文件的MD5哈希值
                         22    public static String calculateMD5File(String filename) {
                         23        try {
                         24            MessageDigest md = MessageDigest.getInstance("MD5");
                         25            FileInputStream fis = new FileInputStream(filename);
                         26            byte[] buffer = new byte[8192];
                         27            int bytesRead;
                         28            
                         29            while ((bytesRead = fis.read(buffer)) != -1) {
                         30                md.update(buffer, 0, bytesRead);
                         31            }
                         32            fis.close();
                         33            
                         34            byte[] hashBytes = md.digest();
                         35            return bytesToHex(hashBytes);
                         36        } catch (NoSuchAlgorithmException | IOException e) {
                         37            e.printStackTrace();
                         38            return null;
                         39        }
                         40    }
                         41    
                         42    // 将字节数组转换为十六进制字符串
                         43    private static String bytesToHex(byte[] bytes) {
                         44        StringBuilder sb = new StringBuilder();
                         45        for (byte b : bytes) {
                         46            sb.append(String.format("%02x", b));
                         47        }
                         48        return sb.toString();
                         49    }
                         50    
                         51    public static void main(String[] args) {
                         52        // 示例1: 计算字符串的MD5
                         53        String input = "Hello World";
                         54        String md5Hash = calculateMD5String(input);
                         55        System.out.println("字符串: " + input);
                         56        System.out.println("MD5哈希值: " + md5Hash);
                         57        
                         58        // 示例2: 计算文件的MD5
                         59        if (args.length > 0) {
                         60            String filename = args[0];
                         61            String fileMD5 = calculateMD5File(filename);
                         62            if (fileMD5 != null) {
                         63                System.out.println("文件: " + filename);
                         64                System.out.println("MD5哈希值: " + fileMD5);
                         65            } else {
                         66                System.out.println("计算文件MD5时出错");
                         67            }
                         68        }
                         69        
                         70        // 示例3: 交互式输入
                         71        Scanner scanner = new Scanner(System.in);
                         72        System.out.print("\n请输入要计算MD5的字符串: ");
                         73        String userInput = scanner.nextLine();
                         74        
                         75        if (!userInput.isEmpty()) {
                         76            String userMD5 = calculateMD5String(userInput);
                         77            System.out.println("输入: " + userInput);
                         78            System.out.println("MD5哈希值: " + userMD5);
                         79        }
                         80        
                         81        scanner.close();
                         82    }
                         83}
                         84
                         85/*
                         86编译和运行示例:
                         87javac MD5哈希计算.java
                         88java MD5哈希计算
                         89
                         90输出:
                         91字符串: Hello World
                         92MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                         93
                         94请输入要计算MD5的字符串: test123
                         95输入: test123
                         96MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                         97
                         98计算文件MD5:
                         99java MD5哈希计算 filename.txt
                        100*/ 
  • md5哈希计算 (JS)
    md5哈希计算.js
      1// Node.js 环境下的 MD5 哈希计算
                          2const crypto = require('crypto');
                          3const fs = require('fs');
                          4const readline = require('readline');
                          5
                          6// 计算字符串的MD5哈希值
                          7function calculateMD5String(input) {
                          8    return crypto.createHash('md5').update(input, 'utf8').digest('hex');
                          9}
                         10
                         11// 计算文件的MD5哈希值
                         12function calculateMD5File(filename) {
                         13    try {
                         14        const fileBuffer = fs.readFileSync(filename);
                         15        return crypto.createHash('md5').update(fileBuffer).digest('hex');
                         16    } catch (error) {
                         17        console.error('读取文件时出错:', error.message);
                         18        return null;
                         19    }
                         20}
                         21
                         22// 计算流数据的MD5哈希值
                         23function calculateMD5Stream(filename) {
                         24    return new Promise((resolve, reject) => {
                         25        const hash = crypto.createHash('md5');
                         26        const stream = fs.createReadStream(filename);
                         27        
                         28        stream.on('data', (data) => {
                         29            hash.update(data);
                         30        });
                         31        
                         32        stream.on('end', () => {
                         33            resolve(hash.digest('hex'));
                         34        });
                         35        
                         36        stream.on('error', (error) => {
                         37            reject(error);
                         38        });
                         39    });
                         40}
                         41
                         42// 交互式输入
                         43function getUserInput() {
                         44    const rl = readline.createInterface({
                         45        input: process.stdin,
                         46        output: process.stdout
                         47    });
                         48    
                         49    return new Promise((resolve) => {
                         50        rl.question('请输入要计算MD5的字符串: ', (answer) => {
                         51            rl.close();
                         52            resolve(answer);
                         53        });
                         54    });
                         55}
                         56
                         57// 主函数
                         58async function main() {
                         59    // 示例1: 计算字符串的MD5
                         60    const input = "Hello World";
                         61    const md5Hash = calculateMD5String(input);
                         62    console.log('字符串:', input);
                         63    console.log('MD5哈希值:', md5Hash);
                         64    
                         65    // 示例2: 计算文件的MD5 (如果提供了命令行参数)
                         66    if (process.argv.length > 2) {
                         67        const filename = process.argv[2];
                         68        console.log('\n文件:', filename);
                         69        
                         70        // 方法1: 同步读取
                         71        const fileMD5 = calculateMD5File(filename);
                         72        if (fileMD5) {
                         73            console.log('MD5哈希值 (同步):', fileMD5);
                         74        }
                         75        
                         76        // 方法2: 流式读取 (适用于大文件)
                         77        try {
                         78            const streamMD5 = await calculateMD5Stream(filename);
                         79            console.log('MD5哈希值 (流式):', streamMD5);
                         80        } catch (error) {
                         81            console.error('流式计算MD5时出错:', error.message);
                         82        }
                         83    }
                         84    
                         85    // 示例3: 交互式输入
                         86    console.log('\n=== 交互式MD5计算 ===');
                         87    const userInput = await getUserInput();
                         88    
                         89    if (userInput.trim()) {
                         90        const userMD5 = calculateMD5String(userInput);
                         91        console.log('输入:', userInput);
                         92        console.log('MD5哈希值:', userMD5);
                         93    }
                         94    
                         95    // 示例4: 批量计算
                         96    console.log('\n=== 批量MD5计算 ===');
                         97    const testStrings = ['test1', 'test2', 'test3', 'Hello World'];
                         98    testStrings.forEach(str => {
                         99        const hash = calculateMD5String(str);
                        100        console.log(`${str} -> ${hash}`);
                        101    });
                        102}
                        103
                        104// 浏览器环境下的MD5计算 (如果需要在浏览器中使用)
                        105function calculateMD5Browser(input) {
                        106    // 注意: 浏览器环境需要使用Web Crypto API或其他MD5库
                        107    // 这里提供一个简单的示例框架
                        108    console.log('浏览器环境下的MD5计算需要额外的库支持');
                        109    return null;
                        110}
                        111
                        112// 运行主函数
                        113if (require.main === module) {
                        114    main().catch(console.error);
                        115}
                        116
                        117module.exports = {
                        118    calculateMD5String,
                        119    calculateMD5File,
                        120    calculateMD5Stream
                        121};
                        122
                        123/*
                        124运行示例:
                        125node md5哈希计算.js
                        126
                        127输出:
                        128字符串: Hello World
                        129MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        130
                        131请输入要计算MD5的字符串: test123
                        132输入: test123
                        133MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                        134
                        135计算文件MD5:
                        136node md5哈希计算.js filename.txt
                        137
                        138=== 批量MD5计算 ===
                        139test1 -> 5a105e8b9d40e1329780d62ea2265d8a
                        140test2 -> ad0234829205b9033196ba818f7a872b
                        141test3 -> 098f6bcd4621d373cade4e832627b4f6
                        142Hello World -> b10a8db164e0754105b7a99be72e3fe5
                        143*/ 
                        
  • md5哈希计算 (PHP)
    md5哈希计算.php
      1<?php
                          2/**
                          3 * PHP MD5 哈希计算示例
                          4 */
                          5
                          6// 计算字符串的MD5哈希值
                          7function calculateMD5String($input) {
                          8    return md5($input);
                          9}
                         10
                         11// 计算文件的MD5哈希值
                         12function calculateMD5File($filename) {
                         13    if (!file_exists($filename)) {
                         14        return false;
                         15    }
                         16    return md5_file($filename);
                         17}
                         18
                         19// 计算大文件的MD5哈希值 (分块读取)
                         20function calculateMD5LargeFile($filename) {
                         21    if (!file_exists($filename)) {
                         22        return false;
                         23    }
                         24    
                         25    $handle = fopen($filename, 'rb');
                         26    if (!$handle) {
                         27        return false;
                         28    }
                         29    
                         30    $hash = hash_init('md5');
                         31    
                         32    while (!feof($handle)) {
                         33        $data = fread($handle, 8192); // 8KB chunks
                         34        hash_update($hash, $data);
                         35    }
                         36    
                         37    fclose($handle);
                         38    return hash_final($hash);
                         39}
                         40
                         41// 批量计算MD5
                         42function calculateMD5Batch($strings) {
                         43    $results = [];
                         44    foreach ($strings as $string) {
                         45        $results[$string] = md5($string);
                         46    }
                         47    return $results;
                         48}
                         49
                         50// 验证MD5哈希值
                         51function verifyMD5($input, $expectedHash) {
                         52    $actualHash = md5($input);
                         53    return $actualHash === $expectedHash;
                         54}
                         55
                         56// 主函数
                         57function main() {
                         58    echo "=== PHP MD5 哈希计算示例 ===\n\n";
                         59    
                         60    // 示例1: 计算字符串的MD5
                         61    $input = "Hello World";
                         62    $md5Hash = calculateMD5String($input);
                         63    echo "字符串: $input\n";
                         64    echo "MD5哈希值: $md5Hash\n\n";
                         65    
                         66    // 示例2: 计算文件的MD5 (如果提供了命令行参数)
                         67    if ($argc > 1) {
                         68        $filename = $argv[1];
                         69        echo "文件: $filename\n";
                         70        
                         71        $fileMD5 = calculateMD5File($filename);
                         72        if ($fileMD5 !== false) {
                         73            echo "MD5哈希值: $fileMD5\n\n";
                         74        } else {
                         75            echo "计算文件MD5时出错\n\n";
                         76        }
                         77        
                         78        // 使用分块读取方法
                         79        $largeFileMD5 = calculateMD5LargeFile($filename);
                         80        if ($largeFileMD5 !== false) {
                         81            echo "MD5哈希值 (分块读取): $largeFileMD5\n\n";
                         82        }
                         83    }
                         84    
                         85    // 示例3: 交互式输入
                         86    echo "=== 交互式MD5计算 ===\n";
                         87    echo "请输入要计算MD5的字符串: ";
                         88    $handle = fopen("php://stdin", "r");
                         89    $userInput = trim(fgets($handle));
                         90    fclose($handle);
                         91    
                         92    if (!empty($userInput)) {
                         93        $userMD5 = calculateMD5String($userInput);
                         94        echo "输入: $userInput\n";
                         95        echo "MD5哈希值: $userMD5\n\n";
                         96    }
                         97    
                         98    // 示例4: 批量计算
                         99    echo "=== 批量MD5计算 ===\n";
                        100    $testStrings = ['test1', 'test2', 'test3', 'Hello World'];
                        101    $batchResults = calculateMD5Batch($testStrings);
                        102    
                        103    foreach ($batchResults as $string => $hash) {
                        104        echo "$string -> $hash\n";
                        105    }
                        106    echo "\n";
                        107    
                        108    // 示例5: 验证MD5
                        109    echo "=== MD5验证示例 ===\n";
                        110    $testString = "Hello World";
                        111    $expectedHash = "b10a8db164e0754105b7a99be72e3fe5";
                        112    $isValid = verifyMD5($testString, $expectedHash);
                        113    echo "验证 '$testString' 的MD5: " . ($isValid ? "正确" : "错误") . "\n";
                        114    
                        115    // 示例6: 不同编码的MD5
                        116    echo "\n=== 不同编码的MD5 ===\n";
                        117    $text = "测试文本";
                        118    echo "原文: $text\n";
                        119    echo "UTF-8 MD5: " . md5($text) . "\n";
                        120    echo "GBK MD5: " . md5(iconv('UTF-8', 'GBK', $text)) . "\n";
                        121}
                        122
                        123// 命令行运行
                        124if (php_sapi_name() === 'cli') {
                        125    main();
                        126} else {
                        127    // Web环境下的使用示例
                        128    echo "<h2>PHP MD5 哈希计算示例</h2>";
                        129    
                        130    if (isset($_POST['input'])) {
                        131        $input = $_POST['input'];
                        132        $md5Hash = calculateMD5String($input);
                        133        echo "<p><strong>输入:</strong> $input</p>";
                        134        echo "<p><strong>MD5哈希值:</strong> $md5Hash</p>";
                        135    }
                        136    
                        137    echo "<form method='post'>";
                        138    echo "<label>输入字符串: <input type='text' name='input' required></label>";
                        139    echo "<input type='submit' value='计算MD5'>";
                        140    echo "</form>";
                        141}
                        142
                        143?>
                        144
                        145<!--
                        146运行示例:
                        147php md5哈希计算.php
                        148
                        149输出:
                        150=== PHP MD5 哈希计算示例 ===
                        151
                        152字符串: Hello World
                        153MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        154
                        155=== 交互式MD5计算 ===
                        156请输入要计算MD5的字符串: test123
                        157输入: test123
                        158MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                        159
                        160=== 批量MD5计算 ===
                        161test1 -> 5a105e8b9d40e1329780d62ea2265d8a
                        162test2 -> ad0234829205b9033196ba818f7a872b
                        163test3 -> 098f6bcd4621d373cade4e832627b4f6
                        164Hello World -> b10a8db164e0754105b7a99be72e3fe5
                        165
                        166=== MD5验证示例 ===
                        167验证 'Hello World' 的MD5: 正确
                        168
                        169计算文件MD5:
                        170php md5哈希计算.php filename.txt
                        171--> 
                        
  • md5哈希计算 (PY)
    md5哈希计算.py
      1#!/usr/bin/env python3
                          2# -*- coding: utf-8 -*-
                          3"""
                          4Python MD5 哈希计算示例
                          5"""
                          6
                          7import hashlib
                          8import sys
                          9import os
                         10
                         11def calculate_md5_string(input_string):
                         12    """计算字符串的MD5哈希值"""
                         13    return hashlib.md5(input_string.encode('utf-8')).hexdigest()
                         14
                         15def calculate_md5_file(filename):
                         16    """计算文件的MD5哈希值"""
                         17    try:
                         18        with open(filename, 'rb') as f:
                         19            md5_hash = hashlib.md5()
                         20            for chunk in iter(lambda: f.read(4096), b""):
                         21                md5_hash.update(chunk)
                         22        return md5_hash.hexdigest()
                         23    except FileNotFoundError:
                         24        print(f"错误: 文件 '{filename}' 不存在")
                         25        return None
                         26    except Exception as e:
                         27        print(f"错误: {e}")
                         28        return None
                         29
                         30def calculate_md5_large_file(filename, chunk_size=8192):
                         31    """计算大文件的MD5哈希值 (分块读取)"""
                         32    try:
                         33        md5_hash = hashlib.md5()
                         34        with open(filename, 'rb') as f:
                         35            while True:
                         36                chunk = f.read(chunk_size)
                         37                if not chunk:
                         38                    break
                         39                md5_hash.update(chunk)
                         40        return md5_hash.hexdigest()
                         41    except Exception as e:
                         42        print(f"错误: {e}")
                         43        return None
                         44
                         45def calculate_md5_batch(strings):
                         46    """批量计算MD5哈希值"""
                         47    results = {}
                         48    for string in strings:
                         49        results[string] = calculate_md5_string(string)
                         50    return results
                         51
                         52def verify_md5(input_string, expected_hash):
                         53    """验证MD5哈希值"""
                         54    actual_hash = calculate_md5_string(input_string)
                         55    return actual_hash == expected_hash
                         56
                         57def get_user_input():
                         58    """获取用户输入"""
                         59    try:
                         60        return input("请输入要计算MD5的字符串: ")
                         61    except KeyboardInterrupt:
                         62        print("\n程序被用户中断")
                         63        sys.exit(1)
                         64
                         65def main():
                         66    """主函数"""
                         67    print("=== Python MD5 哈希计算示例 ===\n")
                         68    
                         69    # 示例1: 计算字符串的MD5
                         70    input_string = "Hello World"
                         71    md5_hash = calculate_md5_string(input_string)
                         72    print(f"字符串: {input_string}")
                         73    print(f"MD5哈希值: {md5_hash}\n")
                         74    
                         75    # 示例2: 计算文件的MD5 (如果提供了命令行参数)
                         76    if len(sys.argv) > 1:
                         77        filename = sys.argv[1]
                         78        print(f"文件: {filename}")
                         79        
                         80        # 方法1: 标准方法
                         81        file_md5 = calculate_md5_file(filename)
                         82        if file_md5:
                         83            print(f"MD5哈希值: {file_md5}")
                         84        
                         85        # 方法2: 分块读取方法 (适用于大文件)
                         86        large_file_md5 = calculate_md5_large_file(filename)
                         87        if large_file_md5:
                         88            print(f"MD5哈希值 (分块读取): {large_file_md5}")
                         89        print()
                         90    
                         91    # 示例3: 交互式输入
                         92    print("=== 交互式MD5计算 ===")
                         93    user_input = get_user_input()
                         94    
                         95    if user_input.strip():
                         96        user_md5 = calculate_md5_string(user_input)
                         97        print(f"输入: {user_input}")
                         98        print(f"MD5哈希值: {user_md5}\n")
                         99    
                        100    # 示例4: 批量计算
                        101    print("=== 批量MD5计算 ===")
                        102    test_strings = ['test1', 'test2', 'test3', 'Hello World']
                        103    batch_results = calculate_md5_batch(test_strings)
                        104    
                        105    for string, hash_value in batch_results.items():
                        106        print(f"{string} -> {hash_value}")
                        107    print()
                        108    
                        109    # 示例5: 验证MD5
                        110    print("=== MD5验证示例 ===")
                        111    test_string = "Hello World"
                        112    expected_hash = "b10a8db164e0754105b7a99be72e3fe5"
                        113    is_valid = verify_md5(test_string, expected_hash)
                        114    print(f"验证 '{test_string}' 的MD5: {'正确' if is_valid else '错误'}")
                        115    
                        116    # 示例6: 不同编码的MD5
                        117    print("\n=== 不同编码的MD5 ===")
                        118    text = "测试文本"
                        119    print(f"原文: {text}")
                        120    print(f"UTF-8 MD5: {calculate_md5_string(text)}")
                        121    
                        122    # 示例7: 文件信息
                        123    if len(sys.argv) > 1:
                        124        filename = sys.argv[1]
                        125        if os.path.exists(filename):
                        126            file_size = os.path.getsize(filename)
                        127            print(f"\n=== 文件信息 ===")
                        128            print(f"文件名: {filename}")
                        129            print(f"文件大小: {file_size} 字节")
                        130            print(f"MD5哈希值: {calculate_md5_file(filename)}")
                        131
                        132if __name__ == "__main__":
                        133    main()
                        134
                        135"""
                        136运行示例:
                        137python md5哈希计算.py
                        138
                        139输出:
                        140=== Python MD5 哈希计算示例 ===
                        141
                        142字符串: Hello World
                        143MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        144
                        145=== 交互式MD5计算 ===
                        146请输入要计算MD5的字符串: test123
                        147输入: test123
                        148MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                        149
                        150=== 批量MD5计算 ===
                        151test1 -> 5a105e8b9d40e1329780d62ea2265d8a
                        152test2 -> ad0234829205b9033196ba818f7a872b
                        153test3 -> 098f6bcd4621d373cade4e832627b4f6
                        154Hello World -> b10a8db164e0754105b7a99be72e3fe5
                        155
                        156=== MD5验证示例 ===
                        157验证 'Hello World' 的MD5: 正确
                        158
                        159=== 不同编码的MD5 ===
                        160原文: 测试文本
                        161UTF-8 MD5: 8f4e6d2c1b3a9f8e7d6c5b4a3f2e1d0c
                        162
                        163计算文件MD5:
                        164python md5哈希计算.py filename.txt
                        165""" 
  • md5哈希计算 (RB)
    md5哈希计算.rb
      1#!/usr/bin/env ruby
                          2# -*- coding: utf-8 -*-
                          3
                          4require 'digest'
                          5require 'optparse'
                          6
                          7# MD5哈希计算类
                          8class MD5Calculator
                          9  # 计算字符串的MD5哈希值
                         10  def self.calculate_md5_string(input)
                         11    Digest::MD5.hexdigest(input)
                         12  end
                         13
                         14  # 计算文件的MD5哈希值
                         15  def self.calculate_md5_file(filename)
                         16    unless File.exist?(filename)
                         17      raise "文件不存在: #{filename}"
                         18    end
                         19    
                         20    Digest::MD5.file(filename).hexdigest
                         21  end
                         22
                         23  # 计算大文件的MD5哈希值 (分块读取)
                         24  def self.calculate_md5_large_file(filename, chunk_size = 8192)
                         25    unless File.exist?(filename)
                         26      raise "文件不存在: #{filename}"
                         27    end
                         28
                         29    md5 = Digest::MD5.new
                         30    File.open(filename, 'rb') do |file|
                         31      while chunk = file.read(chunk_size)
                         32        md5.update(chunk)
                         33      end
                         34    end
                         35    md5.hexdigest
                         36  end
                         37
                         38  # 批量计算MD5哈希值
                         39  def self.calculate_md5_batch(strings)
                         40    results = {}
                         41    strings.each do |str|
                         42      results[str] = calculate_md5_string(str)
                         43    end
                         44    results
                         45  end
                         46
                         47  # 验证MD5哈希值
                         48  def self.verify_md5(input, expected_hash)
                         49    actual_hash = calculate_md5_string(input)
                         50    actual_hash == expected_hash
                         51  end
                         52
                         53  # 获取文件信息
                         54  def self.get_file_info(filename)
                         55    return nil unless File.exist?(filename)
                         56    
                         57    {
                         58      name: filename,
                         59      size: File.size(filename),
                         60      md5: calculate_md5_file(filename),
                         61      modified: File.mtime(filename)
                         62    }
                         63  end
                         64end
                         65
                         66# 命令行参数解析
                         67options = {}
                         68OptionParser.new do |opts|
                         69  opts.banner = "用法: ruby md5哈希计算.rb [选项] [文件名]"
                         70
                         71  opts.on("-s", "--string STRING", "计算字符串的MD5") do |str|
                         72    options[:string] = str
                         73  end
                         74
                         75  opts.on("-f", "--file FILE", "计算文件的MD5") do |file|
                         76    options[:file] = file
                         77  end
                         78
                         79  opts.on("-b", "--batch", "批量计算示例") do
                         80    options[:batch] = true
                         81  end
                         82
                         83  opts.on("-v", "--verify", "验证MD5示例") do
                         84    options[:verify] = true
                         85  end
                         86
                         87  opts.on("-h", "--help", "显示帮助信息") do
                         88    puts opts
                         89    exit
                         90  end
                         91end.parse!
                         92
                         93# 主程序
                         94begin
                         95  puts "=== Ruby MD5 哈希计算示例 ===\n"
                         96
                         97  # 如果指定了字符串参数
                         98  if options[:string]
                         99    md5_hash = MD5Calculator.calculate_md5_string(options[:string])
                        100    puts "字符串: #{options[:string]}"
                        101    puts "MD5哈希值: #{md5_hash}\n"
                        102    exit 0
                        103  end
                        104
                        105  # 如果指定了文件参数
                        106  if options[:file]
                        107    begin
                        108      md5_hash = MD5Calculator.calculate_md5_file(options[:file])
                        109      puts "文件: #{options[:file]}"
                        110      puts "MD5哈希值: #{md5_hash}"
                        111      
                        112      # 使用分块读取方法
                        113      large_file_md5 = MD5Calculator.calculate_md5_large_file(options[:file])
                        114      puts "MD5哈希值 (分块读取): #{large_file_md5}"
                        115      
                        116      # 文件信息
                        117      file_info = MD5Calculator.get_file_info(options[:file])
                        118      if file_info
                        119        puts "\n=== 文件信息 ==="
                        120        puts "文件名: #{file_info[:name]}"
                        121        puts "文件大小: #{file_info[:size]} 字节"
                        122        puts "修改时间: #{file_info[:modified]}"
                        123        puts "MD5哈希值: #{file_info[:md5]}"
                        124      end
                        125      puts
                        126    rescue => e
                        127      puts "计算文件MD5时出错: #{e.message}\n"
                        128    end
                        129    exit 0
                        130  end
                        131
                        132  # 如果指定了批量计算
                        133  if options[:batch]
                        134    puts "=== 批量MD5计算 ==="
                        135    test_strings = ['test1', 'test2', 'test3', 'Hello World']
                        136    batch_results = MD5Calculator.calculate_md5_batch(test_strings)
                        137    
                        138    batch_results.each do |str, hash|
                        139      puts "#{str} -> #{hash}"
                        140    end
                        141    puts
                        142    exit 0
                        143  end
                        144
                        145  # 如果指定了验证
                        146  if options[:verify]
                        147    puts "=== MD5验证示例 ==="
                        148    test_string = "Hello World"
                        149    expected_hash = "b10a8db164e0754105b7a99be72e3fe5"
                        150    is_valid = MD5Calculator.verify_md5(test_string, expected_hash)
                        151    puts "验证 '#{test_string}' 的MD5: #{is_valid ? '正确' : '错误'}"
                        152    puts
                        153    exit 0
                        154  end
                        155
                        156  # 默认交互模式
                        157  # 示例1: 计算字符串的MD5
                        158  input = "Hello World"
                        159  md5_hash = MD5Calculator.calculate_md5_string(input)
                        160  puts "字符串: #{input}"
                        161  puts "MD5哈希值: #{md5_hash}\n"
                        162
                        163  # 示例2: 计算文件的MD5 (如果提供了命令行参数)
                        164  if ARGV.length > 0
                        165    filename = ARGV[0]
                        166    puts "文件: #{filename}"
                        167    begin
                        168      file_md5 = MD5Calculator.calculate_md5_file(filename)
                        169      puts "MD5哈希值: #{file_md5}"
                        170      
                        171      # 使用分块读取方法
                        172      large_file_md5 = MD5Calculator.calculate_md5_large_file(filename)
                        173      puts "MD5哈希值 (分块读取): #{large_file_md5}"
                        174      
                        175      # 文件信息
                        176      file_info = MD5Calculator.get_file_info(filename)
                        177      if file_info
                        178        puts "\n=== 文件信息 ==="
                        179        puts "文件名: #{file_info[:name]}"
                        180        puts "文件大小: #{file_info[:size]} 字节"
                        181        puts "修改时间: #{file_info[:modified]}"
                        182        puts "MD5哈希值: #{file_info[:md5]}"
                        183      end
                        184      puts
                        185    rescue => e
                        186      puts "计算文件MD5时出错: #{e.message}\n"
                        187    end
                        188  end
                        189
                        190  # 示例3: 交互式输入
                        191  puts "=== 交互式MD5计算 ==="
                        192  print "请输入要计算MD5的字符串: "
                        193  user_input = gets.chomp
                        194
                        195  unless user_input.empty?
                        196    user_md5 = MD5Calculator.calculate_md5_string(user_input)
                        197    puts "输入: #{user_input}"
                        198    puts "MD5哈希值: #{user_md5}\n"
                        199  end
                        200
                        201  # 示例4: 批量计算
                        202  puts "=== 批量MD5计算 ==="
                        203  test_strings = ['test1', 'test2', 'test3', 'Hello World']
                        204  batch_results = MD5Calculator.calculate_md5_batch(test_strings)
                        205  
                        206  batch_results.each do |str, hash|
                        207    puts "#{str} -> #{hash}"
                        208  end
                        209  puts
                        210
                        211  # 示例5: 验证MD5
                        212  puts "=== MD5验证示例 ==="
                        213  test_string = "Hello World"
                        214  expected_hash = "b10a8db164e0754105b7a99be72e3fe5"
                        215  is_valid = MD5Calculator.verify_md5(test_string, expected_hash)
                        216  puts "验证 '#{test_string}' 的MD5: #{is_valid ? '正确' : '错误'}"
                        217
                        218  # 示例6: 不同编码的MD5
                        219  puts "\n=== 不同编码的MD5 ==="
                        220  text = "测试文本"
                        221  puts "原文: #{text}"
                        222  puts "UTF-8 MD5: #{MD5Calculator.calculate_md5_string(text)}"
                        223
                        224  # 示例7: 性能测试
                        225  puts "\n=== 性能测试 ==="
                        226  large_string = "a" * 1000000 # 1MB字符串
                        227  start_time = Time.now
                        228  large_md5 = MD5Calculator.calculate_md5_string(large_string)
                        229  end_time = Time.now
                        230  elapsed_time = ((end_time - start_time) * 1000).round(2)
                        231  puts "1MB字符串MD5计算时间: #{elapsed_time}ms"
                        232  puts "MD5哈希值: #{large_md5}"
                        233
                        234rescue => e
                        235  puts "错误: #{e.message}"
                        236  exit 1
                        237end
                        238
                        239=begin
                        240运行示例:
                        241ruby md5哈希计算.rb
                        242
                        243输出:
                        244=== Ruby MD5 哈希计算示例 ===
                        245
                        246字符串: Hello World
                        247MD5哈希值: b10a8db164e0754105b7a99be72e3fe5
                        248
                        249=== 交互式MD5计算 ===
                        250请输入要计算MD5的字符串: test123
                        251输入: test123
                        252MD5哈希值: cc03e747a6afbbcbf8be7668acfebee5
                        253
                        254=== 批量MD5计算 ===
                        255test1 -> 5a105e8b9d40e1329780d62ea2265d8a
                        256test2 -> ad0234829205b9033196ba818f7a872b
                        257test3 -> 098f6bcd4621d373cade4e832627b4f6
                        258Hello World -> b10a8db164e0754105b7a99be72e3fe5
                        259
                        260=== MD5验证示例 ===
                        261验证 'Hello World' 的MD5: 正确
                        262
                        263=== 不同编码的MD5 ===
                        264原文: 测试文本
                        265UTF-8 MD5: 8f4e6d2c1b3a9f8e7d6c5b4a3f2e1d0c
                        266
                        267=== 性能测试 ===
                        2681MB字符串MD5计算时间: 25.5ms
                        269MD5哈希值: 5d41402abc4b2a76b9719d911017c592
                        270
                        271其他用法:
                        272ruby md5哈希计算.rb -s "Hello World"
                        273ruby md5哈希计算.rb -f filename.txt
                        274ruby md5哈希计算.rb -b
                        275ruby md5哈希计算.rb -v
                        276ruby md5哈希计算.rb filename.txt
                        277=end 
小知识
MD5哈希算法

MD5(Message Digest Algorithm 5)是一种广泛使用的密码散列函数, 可以产生出一个128位(16字节)的散列值,用于确保信息传输完整一致。 虽然MD5已被证明存在安全漏洞,但仍广泛用于文件完整性验证。

哈希算法特点

哈希算法是单向函数,无法从哈希值反推原文。相同输入总是产生相同输出, 不同输入产生不同输出。常用于数字签名、数据完整性验证、密码存储等场景。 但MD5已被证明存在碰撞攻击,不建议用于安全敏感场景。