Java计算String的SHA-1摘要的十六进制表示形式（java string 16进制）

25-01-23 25

在本文中，您将会了解到关于Java计算String的SHA-1摘要的十六进制表示形式的新资讯，同时我们还将为您解释javastring16进制的相关在本文中，我们将带你探索Java计算String的S

在本文中，您将会了解到关于Java计算String的SHA-1摘要的十六进制表示形式的新资讯，同时我们还将为您解释java string 16进制的相关在本文中，我们将带你探索Java计算String的SHA-1摘要的十六进制表示形式的奥秘，分析java string 16进制的特点，并给出一些关于c – 无符号长十六进制表示、c# – 将float转换为二进制表示形式(使用MemoryStream？)、C#实现十六进制与十进制相互转换以及及不同进制表示、c++ string 中的十六进制数字转十六进制字符的实用技巧。

本文目录一览：

Java计算String的SHA-1摘要的十六进制表示形式（java string 16进制）
c – 无符号长十六进制表示
c# – 将float转换为二进制表示形式(使用MemoryStream？)
C#实现十六进制与十进制相互转换以及及不同进制表示
c++ string 中的十六进制数字转十六进制字符

Java计算String的SHA-1摘要的十六进制表示形式（java string 16进制）

我将用户密码作为sha1哈希存储在数据库中。

不幸的是，我得到了奇怪的答案。

我将字符串存储为：

MessageDigest cript = MessageDigest.getInstance("SHA-1");              cript.reset();              cript.update(userPass.getBytes("utf8"));              this.password = new String(cript.digest());

我想要这样的东西->

aff->“ 0c05aa56405c447e6678b7f3127febde5c3a9238”

而不是

aff->``V @ \ D〜fx ： 8

答案1

小编典典

发生这种情况是因为cript.digest（）返回一个字节数组，您试图将其打印为字符串String。您想将其转换为可打印的十六进制字符串。

简单的解决方案：使用Apache的commons-codec库：

String password = new String(Hex.encodeHex(cript.digest()),                             CharSet.forName("UTF-8"));

c – 无符号长十六进制表示

#include <stdio.h>
#include <string.h>

int main(void) {
    char buf[256] = {};
    unsigned long i=13835058055298940928;
    snprintf(buf,1024,"%lx",i); /* Line 7 */
    printf("%s\n",buf);
    return 0;
}

在第7行中,如果我使用％lux,则snprintf不会进行任何转换,只打印0x13835058055298940928x,而如果我只使用％lx,则会打印预期的十六进制转换.

如何用十六进制表示无符号长整数？

解决方法

格式“％lux”被视为“％lu”(无符号长整数,小数),后跟字母x.

“％x”格式需要一个无符号类型的参数;没有(直接)机制以十六进制格式打印有符号整数.

以十六进制打印无符号长值的格式为“％lx”. (x是十六进制,d是带符号的十进制,u是无符号十进制;其中任何一个都可以用l来限定.)

请注意,值13835058055298940928至少需要64位无符号类型才能存储它而不会溢出. unsigned long类型至少为32位;在某些系统上它是64位,但绝不是全部.如果您希望代码是可移植的,则应使用unsigned long long类型而不是unsigned long类型.以十六进制打印无符号long long值的格式为“％llx”.

为清楚起见,我通常在十六进制输出前面加上0x,因此读者很明显它是一个十六进制数：

printf("0x%llx\n",some_unsigned_long_long_value);

(您可以使用％#llx获得相同的结果,但我发现写出0x比记住#flag的含义更容易.)

c# – 将float转换为二进制表示形式(使用MemoryStream？)

我想将给定的float转换为其二进制表示.我试图将浮点值写入MemoryStream,逐字节读取此MemoryStream并将字节转换为二进制表示形式.但每次尝试都失败了.

>“无法读取封闭的流”(但我只关闭了作者)
>出于测试目的,我只是编写了一个整数(我认为大小为4个字节),当我没有刷新StreamWriter时,MemoryStream的长度为0,而当我这样做时,则为1.

我确信有一种更好的方法可以将浮点数转换为二进制数,但我还想了解一下MemoryStream类.

解决方法

您可以使用 BitConverter.GetBytes(float)或使用包装MemoryStream的BinaryWriter并使用 BinaryWriter.Write(float).目前尚不清楚您之前使用MemoryStream做了什么,但您不想使用StreamWriter – 这是用于文本的.

C#实现十六进制与十进制相互转换以及及不同进制表示

前言

在程序中，十六进制的表示形式通常为字符串；而十进制则为数字整型（本质的内存存储都是01二进制）。数字的进制表示一般使用的不多，通常最大的需求是进制之间的相互转换。C#中提供了内置的转换方法，同时，我们也可以依据不同进制之间的规则自己实现进制之间的转换。

C#中数字的进制表示形式

对于进制的表示，编程语言基本上都提供了特殊前缀表示不同进制的数字，一般0x/0X表示16进制、0o/0O表示8进制、0b/0B表示2进制，十进制数字则没有特殊前缀，直接输入数字即可。

C#中没有对8进制数字的直接表示形式。对于这个几乎用不到的历史遗留的进制，编程中很少会使用。通常比较常用的是2进制和16进制。

比如，下面举例的不同进制的数字表示形式：

// 16进制表示
var hexadecimal = 0xaf2;
Console.WriteLine(hexadecimal); // 2802

// 2进制表示
var binary = 0b1011110000;
Console.WriteLine(binary);  // 752

// 10进制
var decimal_ = 910;
Console.WriteLine(decimal_); // 910

十六进制转十进制

十六进制到十进制的转换可以通过下面的步骤实现：

从十六进制数字的最右侧（个位）开始获取每一位的数字
获取的数字乘以16^n，n从0开始
将相乘后的结果相加到最终值
以等值的十进制对应十六进制，比如 A或a作为10，B或b作为11

代码实现十六进制转十进制

下面的代码使用上面介绍的算法，实现将十六进制字符串转换为十进制数字，通过遍历十六进制的字符得到最后的值。

使用正则验证传入的是否是合格的16进制字符串。

/// <summary>
/// Hex十六进制数字转十进制
/// </summary>
/// <param name="hex"></param>
/// <returns></returns>
public static int HexToDecimal(string hex)
{
   if (!Regex.Match(hex, "^[0-9A-F]$", RegexOptions.IgnoreCase).Success)
   {
       throw new Exception("不是十六进制数字");
   }

   var decimalValue = 0;

   var hexUp = hex.ToUpper();
   // 从最后一位到第一位循环获取每位的值，并乘以基数的n-1次方
   for (int i = hexUp.Length-1; i >= 0; i--)
   {
       int currV = 0;
       switch (hexUp[i])
       {
           case ''A'':
               currV = 10;
               break;
           case ''B'':
               currV = 11;
               break;
           case ''C'':
               currV = 12;
               break;
           case ''D'':
               currV = 13;
               break;
           case ''E'':
               currV = 14;
               break;
           case ''F'':
               currV = 15;
               break;
           case ''0'':
               currV = 0;
               break;
           case ''1'':
               currV = 1;
               break;
           case ''2'':
               currV = 2;
               break;
           case ''3'':
               currV = 3;
               break;
           case ''4'':
               currV = 4;
               break;
           case ''5'':
               currV = 5;
               break;
           case ''6'':
               currV = 6;
               break;
           case ''7'':
               currV = 7;
               break;
           case ''8'':
               currV = 8;
               break;
           case ''9'':
               currV = 9;
               break;
           default:
               break;
       }

       for (int n = 0; n < hexUp.Length - 1 -i; n++)
       {
           currV *= 16;
       }
       decimalValue += currV;
   }
   return decimalValue;
}

基本逻辑和介绍的一致。

参考文章中给出了更加清晰的逻辑处理，和介绍的处理算法完全逻辑一致，尤其Multiplier的使用，比较巧妙，推荐。代码如下：

/// <summary>
/// 另一种16进制转10进制的处理方式，Multiplier参与*16的循环很巧妙，对Multiplier的处理很推荐，逻辑统一
/// </summary>
/// <param name="HexaDecimalString"></param>
/// <returns></returns>
public static int HexaToDecimal(string HexaDecimalString)
{
   int Decimal = 0;
   int Multiplier = 1;

   for (int i = HexaDecimalString.Length - 1; i >= 0; i--)
   {
       Decimal += HexaToDecimal(HexaDecimalString[i]) * Multiplier;
       Multiplier *= 16;
   }
   return Decimal;
}

static int HexaToDecimal(char c)
{
   switch (c)
   {
       case ''0'':
           return 0;
       case ''1'':
           return 1;
       case ''2'':
           return 2;
       case ''3'':
           return 3;
       case ''4'':
           return 4;
       case ''5'':
           return 5;
       case ''6'':
           return 6;
       case ''7'':
           return 7;
       case ''8'':
           return 8;
       case ''9'':
           return 9;
       case ''A'':
       case ''a'':
           return 10;
       case ''B'':
       case ''b'':
           return 11;
       case ''C'':
       case ''c'':
           return 12;
       case ''D'':
       case ''d'':
           return 13;
       case ''E'':
       case ''e'':
           return 14;
       case ''F'':
       case ''f'':
           return 15;
   }
   return -1;
}

C#内置方法16转10进制

Convert.ToInt32()

Convert.ToInt32的第二个参数可以指定进制数，从而转为32位的10进制int整型。

Convert.ToInt32(hexStr,16)

同理，可以根据需要，将2进制、8进制的字符串转换为10进制的int类型。

int.Parse()和int.TryParse

int.Parse(hexStr,System.Globalization.NumberStyles.HexNumber) 第二个参数指定当前为HexNumber数字，实现16转10进制。

int.TryParse同理。

十进制转十六进制

代码实现十进制转十六进制

实现步骤对应上面16转10进制的过程，代码如下：

/// <summary>
/// 十进制数字转十六进制
/// </summary>
/// <param name="dec">十进制数字</param>
/// <param name="lower">16进制结果是否为小写，默认false</param>
/// <returns></returns>
public static string DecimalToHex(int dec, bool lower = false)
{
   var hexBuilder = new StringBuilder();
   while (dec != 0)
   {
       var currV = dec % 16;

       char currHex;
       switch (currV)
       {
           case 0:
               currHex = ''0'';
               break;
           case 1:
               currHex = ''1'';
               break;
           case 2:
               currHex = ''2'';
               break;
           case 3:
               currHex = ''3'';
               break;
           case 4:
               currHex = ''4'';
               break;
           case 5:
               currHex = ''5'';
               break;
           case 6:
               currHex = ''6'';
               break;
           case 7:
               currHex = ''7'';
               break;
           case 8:
               currHex = ''8'';
               break;
           case 9:
               currHex = ''9'';
               break;
           case 10:
               currHex = ''A'';
               break;
           case 11:
               currHex = ''B'';
               break;
           case 12:
               currHex = ''C'';
               break;
           case 13:
               currHex = ''D'';
               break;
           case 14:
               currHex = ''E'';
               break;
           case 15:
               currHex = ''F'';
               break;
           default:
               currHex = ''-'';
               break;
       }
       // 从个位即最右边开始往前获取16进制值
       hexBuilder.Insert(0, currHex);

       dec /= 16;
   }

   return lower ? hexBuilder.ToString().ToLower() : hexBuilder.ToString();
}

C#内置方法10转16进制

Convert.ToString() 转换数字为不同的进制

Convert.ToString(dec, 16)的第二个参数可以指定要换为的字符串的进制数。

它转换的结构是小写表示的16进制，且个位数时为单数，即如果是5，其结果为"5"，如果是F，其结果为"F"。

.ToString()方法

dec.ToString("X2") 或 dec.ToString("X") 将整型转为16进制。

X2表示个位是两位的16进制，比如5表示为"05"，F表示为"0F"。在用Hex格式表示二进制时很常用，2位16进制FF正好表示8位一个字节。
X表示16进制格式。

dec.ToString("x2") 或 dec.ToString("x") 中使用小写x，则转换为对应的小写的16进制字符串，比如15转换为"f"或"0f"。【X对应为大写】。

string.Format()

与.ToString()方法同样的格式化要求。

string.Format("{0:X2}", dec) 或 string.Format("{0:X}",dec) 将整型转为16进制。

Convert.ToString()实现将数字转换为特定进制的字符串

将decimal_2分别转换为16进制、8进制、2进制的字符串

var decimal_2 = 15;
Console.WriteLine($"{decimal_2}的16进制表示{Convert.ToString(decimal_2, 16)}");
Console.WriteLine($"{decimal_2}的8进制表示{Convert.ToString(decimal_2, 8)}");
Console.WriteLine($"{decimal_2}的2进制表示{Convert.ToString(decimal_2, 2)}");
// 15的16进制表示f
// 15的8进制表示17
// 15的2进制表示1111

实现进制转换的Winform程序

新建一个简单的Winform项目HEXAndDECInterConvert，窗体添加从16进制的TextBox输入框转为10进制TextBox输出框、从10进制的TextBox输入框转为16进制TextBox输出框。

在输入框的TextChanged中，分别完成进制的转换

hexFromTxt.TextChanged += HexFromTxt_TextChanged;
decFromTxt.TextChanged += DecFromTxt_TextChanged;

// .......

        private void DecFromTxt_TextChanged(object sender, EventArgs e)
        {
            var decStr = decFromTxt.Text.Trim();
            if (!int.TryParse(decStr, out int dec))
            {
                // 不是数字或者不能正确的转为数字则清空
                decFromTxt.Text =hexToTxt.Text = "";
                return;
            }

            var hex1 = HexDecConvert.DecimalToHex(dec);
            hexToTxt.Text = hex1;

            var tmp = Convert.ToString(dec, 16); // ab..f等为小写表示
            // X2表示两位的16进制，比如5表示为05
            // X表示16进制格式
            var tmp2 = dec.ToString("X2");
            var tmp3 = string.Format("{0:X2}", dec);

        }

        private void HexFromTxt_TextChanged(object sender, EventArgs e)
        {
            var hex = hexFromTxt.Text.Trim();
            var dec1 = HexDecConvert.HexToDecimal(hex);
            var dec2 = HexDecConvert.HexaToDecimal(hex);
            decToTxt.Text = dec1.ToString();
            decToTxt2.Text = dec2.ToString();

        }

效果如下：

参考

4 ways in C# to convert a hexadecimal value to Decimal

总结

到此这篇关于C#实现十六进制与十进制相互转换以及及不同进制表示的文章就介绍到这了,更多相关C#十六进制与十进制相互转换内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

您可能感兴趣的文章:

整理C# 二进制，十进制，十六进制互转
C#十六进制字符串转十进制int的方法
C# 进制转换的实现（二进制、十六进制、十进制互转）
c#实现16进制和字符串之间转换的代码
C# 16进制与字符串、字节数组之间的转换

c++ string 中的十六进制数字转十六进制字符

问题描述

在做透传控制时，设备控制指令需要编写在xml文件中，由于摄像头控制指令一般都是十六进制，所以从xml文件中读取后会变成string字符串，实际的使用过程中需要转换一下，把两个字节的字符转成1个字节的十六进制。

例如 std::string str="1A023B4D",没有任何分隔符，如何获取这个十六进制字符串。然后转换成unsigned char 的数组。

转化后如下：

unsigned char tmp[512]={0};
tmp[0] = 0x1A
tmp[1] = 0x02
...

##代码

static unsigned int hex_char_to_dec(char c)
{
	if (''0'' <= c && c <= ''9'')
	{
		return (c - ''0'');
	}
	else if (''a'' <= c && c <= ''f'')
	{
		return (c - ''a'' + 10);
	}
	else if (''A'' <= c && c <= ''F'')
	{
		return (c - ''A'' + 10);
	}
	else
	{
		return -1;
	}
}

static unsigned int str_to_hex(const unsigned char *str)
{
	return (str[1] == ''\0'') ? hex_char_to_dec(str[0]) : hex_char_to_dec(str[0])*16 + hex_char_to_dec(str[1]);
}

int  strhex_parse_hex(std::string in,unsigned char *out)
{
	unsigned char hex_str[512] = { 0 };
	unsigned char tmp[2] = { 0 };
	unsigned int len = in.size() / 2;
	for (int i = 0; i < len; i++)
	{
		int idx = i * 2;
		tmp[0] = in.at(idx);
		tmp[1] = in.at(idx+1);
		out[i] = (unsigned char)str_to_hex(tmp);
	}
	return len;
}
int main(int argc,char **argv)
{
	std::string str = "11121301";
    unsigned char buffer[512] = {0};
    int len = strhex_parse_hex(str, buffer);
    for(int i = 0; i < len; i++)
    {
    	printf("%02X", buffer[i]);
    }
    printf("\n");
	return 0;
}

关于Java计算String的SHA-1摘要的十六进制表示形式和java string 16进制的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于c – 无符号长十六进制表示、c# – 将float转换为二进制表示形式(使用MemoryStream？)、C#实现十六进制与十进制相互转换以及及不同进制表示、c++ string 中的十六进制数字转十六进制字符等相关内容，可以在本站寻找。

本文标签：