<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&php字符串与byte字节数组转化类示例 - php类库 - PHP粉丝网
当前位置： &转:Java中String与byte[]的转换 - fuzhaoyang - 博客园
String s = "fs123fdsa";//String变量 byte b[] = s.getBytes();//String转换为byte[] String t = new String(b);//bytep[]转换为String
做JAVA经常会碰到中文乱码问题，还有各种编码的问题，特别是String类的内容需要重新编码的问题。要解决这些问题，必须了解清楚JAVA对于字符串是怎么处理的。
1. &字符&是由数字来表示的
先来重新了解一下计算机是如何处理&字符&的，这个原理是大家必须记住的，特别是在用JAVA写程序的时候，万万不可模糊。我们知道，计算机把任何东西都用数字来表示，&字符&也不例外。比如我们要显示一个阿拉伯数字&3&，在我们的PC里，其实并不是仅仅用一个数字3来代表我们要写的&3&，而是以十六进制的0x33来代表，包括放在内存或者是写到文件里，其实都是写着0x33的，不信你可以编辑一个文本文件，写一个&3&，然后用ultraEdit看他的原始码。&
2. 一切&字符&都必定用数字+编码表表示。&这时候，有一个问题：为什么一定要用0x33来代表&3&呢？而不用0x43来代表呢？或者是直接用0x03来代替？其实用什么来代表都可以，只不过大家都习惯了用ASCII编码表（是美国国家信息交换表）来确定各字符应该是用什么数字代表的。同样，为了表示中国字，我国也指定了中文的编码表，其中最广泛使用的是GB2312。比如中文的&当&字，就是用0xB5, 0xB1这两个八位的数字来表示的。所以如果显示字符的程序不知道一列数字到底是按什么编码表编码的，他也无法去判断到底这些是什么文字。如果随便用一个不对的编码表来处理这些数字，处理出来的字符很可能完全是错的。比如在英文系统上，没有GB2312编码表，送给他一个0xB5,0xB1，他就傻傻的当作ASCII来处理（操作系统通常都有自己默认的编码表），结果显示出来就是两个奇怪的符号，因为这两个字在ASCII表里就是那两个符号。同样在繁体中文系统里，他的编码表是BIG5，显示出来也是一个奇怪的中文，不是&当&字。&
3. UNICODE让全世界都说一种语言&看完上面的文字，是否觉得，世界有那么多语言，每个都有自己的一套编码表，很麻烦呢？就算是中文，也有两套流行的编码表，一个是GB2312，一个是BIG5。要使用不同中文的编码的字符时，还要转来转去，的确很麻烦。不光这个，如果想要写一篇包含很多过国文字的文章，就麻烦了，必须要让处理这个文章的程序知道，哪个字是什么编码标准的。如果你想要在文章里找一个字，也必须指定你要找的是哪种编码的哪个字。否则，你要找一个0xB5,0xB1的中文&当&字，很可能把同样数字表示的日文、波兰文这些不相干的字一起给你找出来，够麻烦的吧！&所以人们想，不如大家都用同一个编码标准吧，各种文字都在编码表里有一席之地，处理文字的程序只需要都按这个编码表来处理就可以了。不过要一个编码表里包含所有的文字，这张表就大了，本来英文字+数字一共只有128个以内。但加上中文后，忽然就多了数万个，所以存放一个字符需要的大小也大了很多。现在UNICODE规定了一个字符必须由2个8位数字来表示，想想，8x8x8x8x = 65536 ，是多大的一个数字啊！所以全世界的文字才能都包含进去。当然拉，也有人说中国字可能都不止6万个拉，还要包括别的文字，但人家外国人觉得你们中国人常用的也没那么多，所以就这么定了，我们也没办法。需要注意的是GB2312和UNICODE虽然都是用两个8位数来代表一个中文字，但具体的规格可不一样，比如0xB5,0xB1在UNICODE里面可不是&当&字，而是另外一国的文字来的。
4. C是如何简洁的处理字符的&
我们来谈谈C的字符串。C语言诞生在JAVA之前，C语言的基本数据类型是没有字符串这个类型的，它只有char[]。也就是C把字符顺序放入一个字节数组就完了。而且C也不管放在数组里的是什么文字，也不管那些字是按什么编码标准的。而且他的char的大小也不一定是8位数字，有时候是16位也可能，这要看具体的机器和操作系统。所以写程序的人必须要知道正在处理的char[]的内容到底是按什么编码表表示的字符串，要知道如果比较两国文字是否相同，可是没任何意义的哦！&
5. JAVA是是如何处理字符的。&世界总会进步的，JAVA就是一个例子。JAVA终于有了String类了，它是解决字符问题的最好工具。在JAVA里，一个基本的要点是：String类对象是不需要指定编码表的！为什么它会自己知道一堆数字各代表什么字符呢？就是因为String里的字符信息是用UNICODE编码存放的。而JAVA为了表示字符（注意是单个字符），也有char这个数据类型，而且他的大小是固定2个8位16进制数字长度，也就是0~65535罗。为的就是对应UNICODE里面的一个字符。大家如果想取一个String里的按UNICODE数字，可以用getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 方法取得一个char[]，这个char[]里就是表示String字符的，按UNICODE编码表编码的数字。&可惜现在绝大多数的系统和程序都不是按UNICODE来处理字符，而JAVA程序总是要和别的程序和系统交换数据的，所以在接收一个字符，或者是发送一个字符的时候，就必须要留意当前系统和UNICODE的关系了。比如你从网络或者文件接受到一数字：0xB5,0xB1，JAVA程序并不知道这两个字到底是中文呢？还是日文，或者英文。你如果不指明这个两个数字的编码表，JAVA就会按当前系统默认的编码表来处理。如果这两个数字是从中文WIN98发出去的，JAVA程序又是在英文LINUX上运行的，那就出现了所谓的乱码问题了。也就是JAVA按英文的编码表ASCII来处理这两个数字，当通过new String({0xB5,0xB1})得到的String的时候，这个String代表的已经不是中文的&当&字，而是两个英文的奇怪字符了。不过如果你知道这两个数字一定是中文的话，就可以指定用new String({0xB5,0xB1},"GB2312")来处理，这时候新建立的String才真的是一个&当&字。当然拉，如果你要把一个&当&字的JAVA的String显示在中文WIN98上，必须把这个字输出成两个8位数字：0xB5,0xB1，不管是写成文件还是输出到浏览器上，都必须是0xB5,0xB1。如何把&当&字用GB2312输出？String.getBytes("GB2312")就可以拉！所以有一点要记住：和外界交换任何信息都是以byte[]来进行的！。你可以留意一下JAVA大多数的I/O类，都有以byte[]作为参数和返回值的方法。不过，也有很多写的比较糊涂的程序，没有提供byte[]交换信息的方法，害的不同文字平台的程序员很头疼。Servlet的HttpRequest.getParameter()就是这样。好在有的JSP/SERVLET容易还提供先指定编码表的方法，才能比较简单的解决这个问题。&
6. 网上关于JAVA中文问题的一些错误处理方法。&一个是最常见的，不管什么内容，都用new String(...,"ISO-8859-1")来建立字符串，然后使用的时候按默认的编码格式（通常在服务器上都是英文系统）输出字符串。这样其实你使用的String并不是按UNICODE来代表真正的字符，而是强行把BYTE数组复制到String的char[]里，一旦你的运行环境改变，你就被迫要修改一大堆的代码。而且也无法在同一个字符串里处理几种不同编码的文字。&另一个是把一种编码格式的字符串，比如是GB2312，转换成另一种格式的字符串，比如UTF-8，然后不指明是UTF-8编码，而直接用new String(...)来建立String，这样放在String里面的字符也是无法确定的，它在不同的系统上代表不同的字符。如果要求别人用&UTF-8格式&的String来交换信息的时候，其实已经破坏了JAVA为了兼容各种语言所做的规定。这种错误的本质思想是还按写C语言的方式，把字符串纯粹当作可以自己自由编码的存储器使用，而忽略了JAVA字符串只有一种编码格式。如果真的想自由编码，用byte[]或者char[]就完全了解决问题的了。&
以上，除了是解决JAVA中文问题的基础知识外，也是多年前应该掌握的计算机基础知识。温故而知新，以期共勉。android byte字节数组转换十六进制字符串（物联网开发总结）
android byte字节数组转换十六进制字符串（物联网开发总结）
WiFi模块物联网开发
想起前段时间的物联网的外包开发，经常遇到通过wifi接受的数据，要通过转换成十六进制字符串，或者最后又是十进制数据。都是根据双方的协议来开发的。那么我发送过去的数据也需要，经过特殊转换成byte字节发过去，硬件那边收到不至于乱码的数据。
1、硬件调试发给android这边是十六进制数据
原始数据：68 38 38 68 A 72 78 55 34 12 43 23 01 07 Y 00 00 00 0C 13 78 56 34 12 0C 3B 78 34 12 0C 26 78 56 34 12 0B 59 45 23 00 02 FD 17 00 CS 16
android读到数据是byte字节数组
DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
byte readBuffer[] = new byte[64];
int count = 0;
count = dis.read(readBuffer);
} catch (IOException e) {
} readBuffer收到数据是这样的：104, 56, 56, 104, 0, 114, 120, 85, 52, 18, 67, 35, 1, 7, 0, 0, 0, 0, 12, 19, 120, 86, 52, 18, 12, 59, 120, 52, 18, 12, 38, 120, 86, 52, 18, 11, 89, 69, 35, 0, 2, -3, 23, 0, 0, 22
那么要根据这些数据转换成十六进制的字符串，如果你直接转换成String字符串那肯定乱码了。因为硬件调试发给android这边是十六进制数据。
readBuffer字节数组转后数据十六进制是这样的：68 , 38 , 38 , 68 , 00 , 72 , 78 , 55 , 34 , 12 , 43 , 23 , 01 , 07 , 00 , 00 , 00 , 00 , 0C , 13 , 78 , 56 , 34 , 12 , 0C , 3B , 78 , 34 , 12 , 0C , 26 , 78 , 56 , 34 , 12 , 0B , 59 , 45 , 23 , 00
, 02 , FD , 17 , 00 , 00 , 16
可以看出跟硬件发的是不是一样了。这里面不是十六进制Y，CS就用00填充了。
当然这些都是根据双方收发数据来解析，处理的。
2、android端发给硬件那边
android的原始数据是这个的：68 04 04 68 35 FD 50 00 A0 16，也是十六进制的字符串
需要做的就是十六进制的字符串转换成byte数组
转换代码：
private String mstrRestartSend = &FE FE 68 04 04 68 53 FD 50 00 A0 16&;
private byte[] mRestart =
mRestart = StringUtil.HexCommandtoByte(mstrRestartSend.getBytes());
public class StringUtil {
十六进制的字符串转换成byte数组
public static byte[] HexCommandtoByte(byte[] data) {
if (data == null) {
int nLength = data.
String strTemString = new String(data, 0, nLength);
String[] strings = strTemString.split(& &);
nLength = strings.
data = new byte[nLength];
for (int i = 0; i & nL i++) {
if (strings[i].length() != 2) {
data[i] = 00;
data[i] = (byte)Integer.parseInt(strings[i], 16);
} catch (Exception e) {
data[i] = 00;
}那么这样发过去就不会错误或者乱码。
很多初学者，特别是在物联网方面弄不清楚这个基本数据交流的转换。
3、写了demo测试转换数据转换
下载地址：
4、网上收集较全面的java底层数据转换
Java中二进制、十进制、十六进制及ASCII码与String及字节数组与十六进制字符串之间的转换
public class DigitalTrans {
* 数字字符串转ASCII码字符串
* @param String
* @return ASCII字符串
public static String StringToAsciiString(String content) {
String result = &&;
int max = content.length();
for (int i = 0; i & i++) {
char c = content.charAt(i);
String b = Integer.toHexString(c);
result = result +
* 十六进制转字符串
* @param hexString
十六进制字符串
* @param encodeType
编码类型4：Unicode，2：普通编码
* @return 字符串
public static String hexStringToString(String hexString, int encodeType) {
String result = &&;
int max = hexString.length() / encodeT
for (int i = 0; i & i++) {
char c = (char) DigitalTrans.hexStringToAlgorism(hexString
.substring(i * encodeType, (i + 1) * encodeType));
* 十六进制字符串装十进制
* @param hex
十六进制字符串
* @return 十进制数值
public static int hexStringToAlgorism(String hex) {
hex = hex.toUpperCase();
int max = hex.length();
int result = 0;
for (int i = i & 0; i--) {
char c = hex.charAt(i - 1);
int algorism = 0;
if (c &= '0' && c &= '9') {
algorism = c - '0';
algorism = c - 55;
result += Math.pow(16, max - i) *
* 十六转二进制
* @param hex
十六进制字符串
* @return 二进制字符串
public static String hexStringToBinary(String hex) {
hex = hex.toUpperCase();
String result = &&;
int max = hex.length();
for (int i = 0; i & i++) {
char c = hex.charAt(i);
switch (c) {
case '0':
result += &0000&;
case '1':
result += &0001&;
case '2':
result += &0010&;
case '3':
result += &0011&;
case '4':
result += &0100&;
case '5':
result += &0101&;
case '6':
result += &0110&;
case '7':
result += &0111&;
case '8':
result += &1000&;
case '9':
result += &1001&;
case 'A':
result += &1010&;
case 'B':
result += &1011&;
case 'C':
result += &1100&;
case 'D':
result += &1101&;
case 'E':
result += &1110&;
case 'F':
result += &1111&;
* ASCII码字符串转数字字符串
* @param String
ASCII字符串
* @return 字符串
public static String AsciiStringToString(String content) {
String result = &&;
int length = content.length() / 2;
for (int i = 0; i & i++) {
String c = content.substring(i * 2, i * 2 + 2);
int a = hexStringToAlgorism(c);
char b = (char)
String d = String.valueOf(b);
* 将十进制转换为指定长度的十六进制字符串
* @param algorism
int 十进制数字
* @param maxLength
int 转换后的十六进制字符串长度
* @return String 转换后的十六进制字符串
public static String algorismToHEXString(int algorism, int maxLength) {
String result = &&;
result = Integer.toHexString(algorism);
if (result.length() % 2 == 1) {
result = &0& +
return patchHexString(result.toUpperCase(), maxLength);
* 字节数组转为普通字符串（ASCII对应的字符）
* @param bytearray
* @return String
public static String bytetoString(byte[] bytearray) {
String result = &&;
int length = bytearray.
for (int i = 0; i & i++) {
temp = (char) bytearray[i];
* 二进制字符串转十进制
* @param binary
二进制字符串
* @return 十进制数值
public static int binaryToAlgorism(String binary) {
int max = binary.length();
int result = 0;
for (int i = i & 0; i--) {
char c = binary.charAt(i - 1);
int algorism = c - '0';
result += Math.pow(2, max - i) *
* 十进制转换为十六进制字符串
* @param algorism
int 十进制的数字
* @return String 对应的十六进制字符串
public static String algorismToHEXString(int algorism) {
String result = &&;
result = Integer.toHexString(algorism);
if (result.length() % 2 == 1) {
result = &0& +
result = result.toUpperCase();
* HEX字符串前补0，主要用于长度位数不足。
* @param str
String 需要补充长度的十六进制字符串
* @param maxLength
int 补充后十六进制字符串的长度
* @return 补充结果
static public String patchHexString(String str, int maxLength) {
String temp = &&;
for (int i = 0; i & maxLength - str.length(); i++) {
temp = &0& +
str = (temp + str).substring(0, maxLength);
* 将一个字符串转换为int
* @param s
String 要转换的字符串
* @param defaultInt
int 如果出现异常,默认返回的数字
* @param radix
int 要转换的字符串是什么进制的,如16 8 10.
* @return int 转换后的数字
public static int parseToInt(String s, int defaultInt, int radix) {
int i = 0;
i = Integer.parseInt(s, radix);
} catch (NumberFormatException ex) {
i = defaultI
* 将一个十进制形式的数字字符串转换为int
* @param s
String 要转换的字符串
* @param defaultInt
int 如果出现异常,默认返回的数字
* @return int 转换后的数字
public static int parseToInt(String s, int defaultInt) {
int i = 0;
i = Integer.parseInt(s);
} catch (NumberFormatException ex) {
i = defaultI
* 十六进制字符串转为Byte数组,每两个十六进制字符转为一个Byte
* @param hex
十六进制字符串
* @return byte 转换结果
public static byte[] hexStringToByte(String hex) {
int max = hex.length() / 2;
byte[] bytes = new byte[max];
String binarys = DigitalTrans.hexStringToBinary(hex);
for (int i = 0; i & i++) {
bytes[i] = (byte) DigitalTrans.binaryToAlgorism(binarys.substring(
i * 8 + 1, (i + 1) * 8));
if (binarys.charAt(8 * i) == '1') {
bytes[i] = (byte) (0 - bytes[i]);
* 十六进制串转化为byte数组
* @return the array of byte
public static final byte[] hex2byte(String hex)
throws IllegalArgumentException {
if (hex.length() % 2 != 0) {
throw new IllegalArgumentException();
char[] arr = hex.toCharArray();
byte[] b = new byte[hex.length() / 2];
for (int i = 0, j = 0, l = hex.length(); i & i++, j++) {
String swap = && + arr[i++] + arr[i];
int byteint = Integer.parseInt(swap, 16) & 0xFF;
b[j] = new Integer(byteint).byteValue();
* 字节数组转换为十六进制字符串
* @param b
byte[] 需要转换的字节数组
* @return String 十六进制字符串
public static final String byte2hex(byte b[]) {
if (b == null) {
throw new IllegalArgumentException(
&Argument b ( byte array ) is null! &);
String hs = &&;
String stmp = &&;
for (int n = 0; n & b. n++) {
stmp = Integer.toHexString(b[n] & 0xff);
if (stmp.length() == 1) {
hs = hs + &0& +
return hs.toUpperCase();
我的热门文章
即使是一小步也想与你分享
