go语言字节到十六进制 go16进制转10进制

字节、bit、16进制

二进制8位：xxxxxxxx ，范围：00000000－11111111，表示0到255。

创新互联长期为上1000+客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为宁化企业提供专业的成都网站建设、做网站，宁化网站改版等技术服务。拥有10余年丰富建站经验和众多成功案例,为您定制开发。

一位16进制数（0-F），用二进制表示是xxxx，范围：0000 - 1111，表示：0到16。

16进制要表示1个字节，需要到255，此时就还需要第二位，0x3E。

所以：1个字节＝2个16进制字符，一个16进制位＝0.5个字节。

十六进制 是计算机中数据的一种表示方法。它的规则是“逢十六进一”。

注意：对于任何一个数，我们可以用不同的进位制来表示。比如:十进数57(10),可以用二进制表示为11001(2),也可以用五进制表示为212(5)，也可以用八进制表示为71(8)、用 十六进制 表示为39(16),它们所代表的数值都是一一样的。

按位与,  | 按位或 ,  ^ 按位异或

AND (位与)  OR ( 位或| )  XOR ( 位异或^ )

1 1 = 1，     1 | 1 = 1，     1 ^ 1 = 0

1 0 = 0，     1 | 0 = 1，     1 ^ 0 = 1

0 1 = 0，     0 | 1 = 1，     0 ^ 1 = 1

0 0 = 0，     0 | 0 = 0，     0 ^ 0 = 0

说明：一个字节8位，所以long类型32位，这里要求取出前13位,中间8位,后11位。

public void getSplitId(long id) {

Integer deviedId;

//前13位

Integer areaId = (int) (id 19);

//中间8位

deviedId = (int) ((id 11) 0xff);

//后11位

Integer channelId = (int) (id 0x00001fff);

}

例如:10010011

取前三位：(10010011 0xE0) 5 或者 (10010011 5) 0x07 

取后三位：10010011 0x07

/**

* 判断byte第几位是否为1

* @param b  byte

* @param pos 第几位：从低位0开始（判断最高位，则pos为7）

* @return

*/

public static boolean bytePositionOn1(byte b, int pos) {

if( (b(0x1

return true;

     }else {

return false;

   }

}

求助，golang怎样二进制转十六进制和十六进制转二进制

//二进制转十六进制func btox(b string) string { base, _ := strconv.ParseInt(b, 2, 10) return strconv.FormatInt(base, 16)}//十六进制转二进制func xtob(x string) string { base, _ := strconv.ParseInt(x, 16, 10) return strconv.Format...

字节集转换成16进制的写法

易语言参考代码如下：

.版本 2

.子程序 _按钮1_被单击

.局部变量 a, 字节集

.局部变量 i, 整数型

.局部变量 b, 整数型

.局部变量 c, 文本型

编辑框1.内容 ＝ “”

a ＝ 到字节集 (“333333?钇悙”)

.计次循环首 (取字节集长度 (a), i)

b ＝ 取字节集数据 (a, #整数型, i)

c ＝ 取文本右边 (取十六进制文本 (b), 2)

编辑框1.加入文本 (c ＋ “，”)

.计次循环尾 ()

go的uint64转换成java的哪种类型

Golang 和java/c不同，Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中数据类型不能自动转换。

基本语法

表达式T（v））将值v 转换为类型T

T∶就是数据类型，比如int32，int64，float32等等

v∶ 就是需要转换的变量

var i int = 100

var b float64 = float64(i)

var c int64 = int64(b)

fmt.Printf("b=%f,c=%d",b,c)

b=100.000000,c=100

登录后复制

细节说明

1）Go中，数据类型的转换可以是从表示范围小-表示范围大，也可以范围大一范围小

2） 被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化!

3） 在转换中，比如将 int64 转成int8，编译时不会报错，只是转换的结果是按溢出处理，和

我们希望的结果不一样。（在转换的时候需要注意范围）

var a int64 = 10000000

var b int8 = int8(a)

fmt.Printf("%d",b)

-128

登录后复制

可以看到在转换的时候，一定要保证转换大数据要是对方可以接受的范围。

n1类型是int32，那么➕20整个就是int32类型，可是n2是int64，这样就会编译错误。

题二n4是12 + 127溢出超过了范围，运行的时候按照溢出处理。n3是直接编译不通过，128已经超过了int8类型的范围

基本数据类型和string的转换

字符串格式化

Go语言用于控制文本输出常用的标准库是fmt

fmt中主要用于输出的函数有:

Print: 输出到控制台,不接受任何格式化操作

Println: 输出到控制台并换行

Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出别的类型）

Sprintf：格式化并返回一个字符串而不带任何输出

Fprintf：来格式化并输出到 io.Writers 而不是 os.Stdout

整数类型

格 式 描 述

%b 整型以二进制方式显示

%o 整型以八进制方式显示

%d 整型以十进制方式显示

%x 整型以十六进制方式显示

%X 整型以十六进制、字母大写方式显示

%c 相应Unicode码点所表示的字符

%U Unicode 字符, Unicode格式：123，等同于 "U+007B"

浮点数

格 式 描 述

%e 科学计数法，例如 -1234.456e+78

%E 科学计数法，例如 -1234.456E+78

%f 有小数点而无指数，例如 123.456

%g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出

%G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出

布尔

格 式 描 述

%t true 或 false

字符串

格 式 描 述

%s 字符串或切片的无解译字节

%q 双引号围绕的字符串，由Go语法安全地转义

%x 十六进制，小写字母，每字节两个字符

%X 十六进制，大写字母，每字节两个字符

指针

格 式 描 述

%p 十六进制表示，前缀 0x

var num1 int64 = 99

var num2 float64 = 23.99

var b bool = true

var mychar byte = 'h'

str1 := fmt.Sprintf("%d",num1)

str2 := fmt.Sprintf("%f",num2)

bool1 := fmt.Sprintf("%t",b)

mychar1 := fmt.Sprintf("%c",mychar)

fmt.Printf("%T,%T,%T,str1=%v,str2=%v,bool1=%v,mychar1=%v",str1,bool1,str2,str1,str2,bool1,mychar1)

string,string,string,string,str1=99,str2=23.990000,bool1=true,mychar1=h

登录后复制



使用strconv包 基本类型 - string类型

num1 := 99

str1 := strconv.FormatInt(int64(num1),10)

fmt.Printf("%T,%v",str1,str1)

num2 := 99.99

str2 := strconv.FormatFloat(num2,'f',10,64)

fmt.Printf("%T,%v\n",str2,str2)

登录后复制

strconv包提供了字符串与简单数据类型之间的类型转换功能，可以将简单类型转换为字符串，也可以将字符串转换为其它简单类型

string和int转换

int转string的方法是: Itoa()

str := strconv.Itoa(100)

fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)

登录后复制

2.string转int的方法是:

i, err := strconv.Atoi("100")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

并不是所有string都能转化为int, 所以可能会报错:

i, err := strconv.Atoi("100x")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

使用strconv包 string转其他类型

strconv包提供的Parse类函数用于将字符串转化为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint() 由于字符串转换为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。

1.转bool

b, err := strconv.ParseBool("true")

fmt.Println(b, err)

登录后复制

2.转float

f1, err := strconv.ParseFloat("3.1", 32)

fmt.Println(f1, err)

f2, err := strconv.ParseFloat("3.1", 64)

fmt.Println(f2, err)

登录后复制

由于浮点数的小数部分 并不是所有小数都能在计算机中精确的表示, 这就造成了浮点数精度问题, 比如下面

var n float64 = 0

for i := 0; i 1000; i++ {

n += .01

}

fmt.Println(n)

关于浮点数精度问题: c计算机不都是0101吗，你有想过计算机是怎么表示的小数吗, 简单理解就是:

将其整数部分与小树部分分开, 比如5.25

对于整数部分 5 ，我们使用"不断除以2取余数"的方法，得到 101

对于小数部分 .25 ，我们使用"不断乘以2取整数"的方法，得到 .01

听说有一个包可以解决这个问题: github.com/shopspring/decimal

3.转int

func ParseInt(s string, base int, bitSize int) (i int64, err error)

base: 进制，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析

bitSize: 多少位，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8

fmt.Println(bInt8(-1)) // 0000 0001(原码) - 1111 1110(反码) - 1111 1111

// Parse 二进制字符串

i, err := strconv.ParseInt("11111111", 2, 16)

fmt.Println(i, err)

// Parse 十进制字符串

i, err = strconv.ParseInt("255", 10, 16)

fmt.Println(i, err)

// Parse 十六进制字符串

i, err = strconv.ParseInt("4E2D", 16, 16)

fmt.Println(i, err)

4.转uint

func ParseUint(s string, base int, bitSize int) (uint64, error)

用法和转int一样, 只是转换后的数据类型是uint64

u, err := strconv.ParseUint("11111111", 2, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("255", 10, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("4E2D", 16, 16)

fmt.Println(u, err)

其他类型转string

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

fmt.Println(strconv.FormatBool(true))

// 问题又来了

fmt.Println(strconv.FormatInt(255, 2))

fmt.Println(strconv.FormatInt(255, 10))

fmt.Println(strconv.FormatInt(255, 16))

fmt.Println(strconv.FormatUint(255, 2))

fmt.Println(strconv.FormatUint(255, 10))

fmt.Println(strconv.FormatUint(255, 16))

fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。

prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

如何将字节转化成16进制

16进制与字符串、字节数组之间的转换

在串口通讯过程中，经常要用到 16进制与字符串、字节数组之间的转换

/// summary

/// 字符串转16进制字节数组

/// /summary

/// param name="hexString"/param

/// returns/returns

private static byte[] strToToHexByte(string hexString)

{

hexString = hexString.Replace(" ", "");

if ((hexString.Length % 2) != 0)

hexString += " ";

byte[] returnBytes = new byte[hexString.Length / 2];

for (int i = 0; i returnBytes.Length; i++)

returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);

return returnBytes;

}

字节数组转16进制字符串

/// summary

/// 字节数组转16进制字符串

/// /summary

/// param name="bytes"/param

/// returns/returns

public static string byteToHexStr(byte[] bytes)

{

string returnStr = "";

if (bytes != null)

{

for (int i = 0; i bytes.Length; i++)

{

returnStr += bytes[i].ToString("X2");

}

}

return returnStr;

}

从汉字转换到16进制

/// summary

/// 从汉字转换到16进制

/// /summary

/// param name="s"/param

/// param name="charset"编码,如"utf-8","gb2312"/param

/// param name="fenge"是否每字符用逗号分隔/param

/// returns/returns

public static string ToHex(string s, string charset, bool fenge)

{

if ((s.Length % 2) != 0)

{

s += " ";//空格

//throw new ArgumentException("s is not valid chinese string!");

}

System.Text.Encoding chs = System.Text.Encoding.GetEncoding(charset);

byte[] bytes = chs.GetBytes(s);

string str = "";

for (int i = 0; i bytes.Length; i++)

{

str += string.Format("{0:X}", bytes[i]);

if (fenge (i != bytes.Length - 1))

{

str += string.

一个字节可以用多少位的十六进制表示？

一个字节占8位，16进制一个符号占4位，所以一个字节可以用两个16进制符号表示，比如35h。

最常用的字节是八位的字节，即它包含八位的二进制数。十六进制一般用数字0到9和字母A到F（或a~f）表示，其中:A~F表示10~15，这些称作十六进制数字。十六进制数转换成二进制数：把每一个十六进制数转换成4位的二进制数，就得到一个二进制数。

扩展资料：

十进制转十六进制

采余数定理分解，例如将487710转成十六进制：

4877÷16=304....13(D)

304÷16=19....0

19÷16=1....3

1÷16=0....1

这样就计到487710=130D16

参考资料来源：百度百科-十六进制

网页题目：go语言字节到十六进制 go16进制转10进制
URL地址：http://mswzjz.cn/article/hpjdho.html