1148人阅读
int -& String
int i=12345;
String s=&&;
第一种方法：s=i+&&;
第二种方法：s=String.valueOf(i);
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？
String -& int
s=&12345&;
第一种方法：i=Integer.parseInt(s);
第二种方法：i=Integer.valueOf(s).intValue();
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？
以下是答案：
第一种方法：s=i+&&;
//会产生两个String对象
第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象
第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常
第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象
--------------------------------------------------------------------
1如何将字串 String 转换成整数 int?
A. 有两个方法:
1). int i = Integer.parseInt([String]); 或
i = Integer.parseInt([String],[int radix]);
2). int i = Integer.valueOf(my_str).intValue();
注: 字串转成 Double, Float, Long 的方法大同小异.
2 如何将整数 int 转换成字串 String ?
A. 有叁种方法:
1.) String s = String.valueOf(i);
2.) String s = Integer.toString(i);
3.) String s = && +
注: Double, Float, Long 转成字串的方法大同小异.
JAVA数据类型转换
这是一个例子,说的是JAVA中数据数型的转换.供大家学习
import java.sql.D
public class TypeChange {
public TypeChange() {
//change the string type to the int type
public static
int stringToInt(String intstr)
integer = Integer.valueOf(intstr);
return integer.intValue();
//change int type to the string type
public static String intToString(int value)
Integer integer = new Integer(value);
return integer.toString();
//change the string type to the float type
public static
float stringToFloat(String floatstr)
floatee = Float.valueOf(floatstr);
return floatee.floatValue();
//change the float type to the string type
public static String floatToString(float value)
Float floatee = new Float(value);
return floatee.toString();
//change the string type to the sqlDate type
public static java.sql.Date stringToDate(String dateStr)
java.sql.Date.valueOf(dateStr);
//change the sqlDate type to the string type
public static String dateToString(java.sql.Date datee)
return datee.toString();
public static void main(String[] args)
java.sql.D
day = TypeChange.stringToDate(&&);
String strday = TypeChange.dateToString(day);
System.out.println(strday);
JAVA中常用数据类型转换函数
虽然都能在JAVA API中找到，整理一下做个备份。
版权声明：本文为博主原创文章，未经博主允许不得转载。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：12471次
排名：千里之外学技术不能浮躁，当明天太阳升起的时候，牛奶会有的，面包会有的
&&&& Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)，有些地方也翻译为外覆类或数据类型类。 &&&&&&&& 包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示： 包装类对应表
基本数据类型
&&&&&&&& 在这八个类名中，除了Integer和Character类以后，其它六个类的类名和基本数据类型一直，只是类名的第一个字母大写即可。 &&&&&&&& 对于包装类说，这些类的用途主要包含两种： &&&&&&&&&&&&&&&&&& a、作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。 &&&&&&&&&&&&&&&&&& b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。 &&&&&&&& 由于八个包装类的使用比较类似，下面以最常用的Integer类为例子介绍包装类的实际使用。 &&&&&&&& 1、实现int和Integer类之间的转换 在实际转换时，使用Integer类的构造方法和Integer类内部的intValue方法实现这些类型之间的相互转换，实现的代码如下： &&&&&&&&&&&&&&&&&& int n = 10; &&&&&&&&&&&&&&&&&& Integer in = new Integer(100); &&&&&&&&&&&&&&&&&& //将int类型转换为Integer类型 &&&&&&&&&&&&&&&&&& Integer in1 = new Integer(n); &&&&&&&&&&&&&&&&&& //将Integer类型的对象转换为int类型 &&&&&&&&&&&&&&&&&& int m = in.intValue(); &&&&&&&& 2、Integer类内部的常用方法 &&&&&&&& &&&&&&&& 在Integer类内部包含了一些和int操作有关的方法，下面介绍一些比较常用的方法： &&&&&&&&&&&&&&&&&& a、parseInt方法 &&&&&&&&&&&&&&&&&&&&&&&&&&& public static int parseInt(String s) 该方法的作用是将数字字符串转换为int数值。在以后的界面编程中，将字符串转换为对应的int数字是一种比较常见的操作。使用示例如下： &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& String s = ; &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& int n = Integer.parseInt(s); 则int变量n的值是123，该方法实际上实现了字符串和int之间的转换，如果字符串都包含的不是都是数字字符，则程序执行将出现异常。(说明：异常的概念将在下一章进行讲述) 另外一个parseInt方法： &&&&&&&& public static int parseInt(String s, int radix) 则实现将字符串按照参数radix指定的进制转换为int，使用示例如下： &&&&&&&& //将字符串按照十进制转换为int，则结果为120 &&&&&&&& int n = Integer.parseInt(,10);
&&&&&&&& //将字符串按照十六进制转换为int，则结果为18 &&&&&&&& int n = Integer.parseInt(,16); &&&&&&&& //将字符串”ff”按照十六进制转换为int，则结果为255 &&&&&&&& int n = Integer.parseInt(“ff”,16); 这样可以实现更灵活的转换。 &&&&&&&&&&&&&&&&&& b、toString方法 &&&&&&&&&&&&&&&&&&&&&&&&&&& public static String toString(int i) &&&&&&&&&&&&&&&&&&&&&&&&&&& 该方法的作用是将int类型转换为对应的String类型。 &&&&&&&&&&&&&&&&&&&&&&&&&&& 使用示例代码如下： &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& int m = 1000; &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& String s = Integer.toString(m); &&&&&&&&&&&&&&&&&&&&&&&&&&& 则字符串s的值是&#”。 &&&&&&&&&&&&&&&&&&&&&&&&&&& 另外一个toString方法则实现将int值转换为特定进制的字符串： &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public static int parseInt(String s, int radix) &&&&&&&&&&&&&&&&&&&&&&&&&&& 使用示例代码如下： &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& int m = 20; &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& String s = Integer.toString(m); &&&&&&&&&&&&&&&&&&&&&&&&&&& 则字符串s的值是。 &&&&&&&& 其实，JDK自从1.5(5.0)版本以后，就引入了自动拆装箱的语法，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。使用示例代码如下： &&&&&&&&&&&&&&&&&& //int类型会自动转换为Integer类型 &&&&&&&&&&&&&&&&&& int m = 12; &&&&&&&&&&&&&&&&&& Integer in = &&&&&&&&&&&&&&&&&& //Integer类型会自动转换为int类型 &&&&&&&&&&&&&&&&&& int n = &&&&&&&& 所以在实际使用时的类型转换将变得很简单，系统将自动实现对应的转换。
我参与的团队
积分与排名
评论排行榜
阅读排行榜在JAVA中，不用API中的函数，如何将String类型的转换成int类型数据，急急急！
[问题点数：20分，结帖人guoying_]
在JAVA中，不用API中的函数，如何将String类型的转换成int类型数据，急急急！
[问题点数：20分，结帖人guoying_]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
相关推荐：
2010年11月 Java大版内专家分月排行榜第三
2002年10月 Delphi大版内专家分月排行榜第三
2011年1月 Java大版内专家分月排行榜第二
2011年4月 Java大版内专家分月排行榜第二2010年8月 Java大版内专家分月排行榜第二2010年5月 Java大版内专家分月排行榜第二2008年2月 Java大版内专家分月排行榜第二2007年7月 Java大版内专家分月排行榜第二
2011年2月 Java大版内专家分月排行榜第三2010年9月 Java大版内专家分月排行榜第三2008年9月 Java大版内专家分月排行榜第三2008年1月 Java大版内专家分月排行榜第三2007年11月 Java大版内专家分月排行榜第三2007年9月 Java大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。Java byte数据类型详解 -
- ITeye技术网站
博客分类：
public static String bytes2HexString(byte[] b) {
String ret = "";
for (int i = 0; i & b. i++) {
String hex = Integer.toHexString(b[ i ] & 0xFF);
if (hex.length() == 1) {
hex = '0' +
ret += hex.toUpperCase();
上面是将byte[]转化十六进制的字符串,注意这里b[ i ] & 0xFF将一个byte和 0xFF进行了与运算,
然后使用Integer.toHexString取得了十六进制字符串,可以看出b[ i ] & 0xFF运算后得出的仍然是个int,
那么为何要和 0xFF进行与运算呢?直接 Integer.toHexString(b[ i ]);,将byte强转为int不行吗?
答案是不行的.
其原因在于:
1.byte的大小为8bits而int的大小为32bits
2.java的数字类型：正数在计算机中是以原码形式存在的，负数在计算机中是以其补码形式存在的
在这里先温习下计算机基础理论
byte是一个字节保存的，有8个位，即8个0、1。
8位的第一个位是符号位，
也就是说代表的是数字1
代表的就是-1
所以正数最大位，也就是数字127,
负数最大为，也就是数字-128
上面说的是二进制原码，但是在java中采用的是补码的形式，下面介绍下什么是补码
一个数如果是正，则它的反码与原码相同；
一个数如果是负，则符号位为1，其余各位是对原码取反；
2、补码：利用溢出，我们可以将减法变成加法
对于十进制数，从9得到5可用减法：
因为4+6＝10，我们可以将6作为4的补数
改写为加法：
9+6＝15（去掉高位1，也就是减10）得到5.
对于十六进制数，从c到5可用减法：
因为7+9＝16 将9作为7的补数
改写为加法：
c+9＝15（去掉高位1，也就是减16）得到5.
在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为（），进位1被丢弃。
⑴一个数为正，则它的原码、反码、补码相同
⑵一个数为负，补码为：负数的绝对值的反码加1
- 1的原码为
- 1的反码为
- 1的补码为
它在计算机中的存储就是 ，
-10 绝对值10 原码：
再加1后：，此为-10补码，
好的，计算机中的就是代表-10了。
绝对值128的二进制表示： 按位取反
也就是说 -128在计算机中的表示就是
Integer.toHexString的参数是int，如果不进行&0xff，那么当一个byte会转换成int时，
由于int是32位，而byte只有8位这时会进行补位，
例如补码的十进制数为-1转换为int时变为好多1啊，呵呵！
即0xffffffff但是这个数是不对的，这种补位就会造成误差。和0xff相与后，高24比特就会被清0了，结果就对了。
Java中的一个byte，其范围是-128~127的，而Integer.toHexString的参数本来是int，
如果不进行&0xff，那么当一个byte会转换成int时，对于负数，会做位扩展，
举例来说，一个byte的-1（即0xff），会被转换成int的-1（即 0xffffffff），那么转化出的结果就不是我们想要的了。
而0xff默认是整形，所以，一个byte跟0xff相与会先将那个byte转化成整形运算，
这样，结果中的高的24个比特就总会被清0， 于是结果总是我们想要的。
浏览 45344
"即0xffffffff但是这个数是不对的，这种补位就会造成误差。和0xff相与后，高24比特就会被清0了，结果就对了"这句话不懂，无论是“0xffffffff”还是“0xff”，转化为int都表示-1啊，假设byte-1 与oxff相与，转化为整形时，高的24位被清零，那么相与的结果为0x00 00 就是整型255了，也就是byte-1 和int 255 等价？能不能举个例子说明下不对的原因呢？以我的理解，这个方法是要把byte数以16进制形式打印，但是Byte类并不提供直接转化为16进制数的方法，所以要通过Integer类的toHexString方法来实现，故此要先把这个byte数转化为Integer类型，但是如果直接转化为Integer类型的话就会像上文说的那样0xff变成了0xffffffff，这样打印出来明显与初衷不符，所以要使用0xff来做与运算，而0xff是个int型数，它的补码即这个数在JVM中的表现形式为：00 00
，故此与运算后高24位清0，后8位保持原样，所以转化为16进制时仍为0xff。使用这种方法得到的int数的值不再是原值，因为与0xff做按位与运算实际上=*(-255),所以只有当你想要获得一个byte数的二进制或16进制表现形式时，可以使用这种方法。
perfect5085
浏览: 82753 次
来自: 杭州
呃，错了，按位与0xff不等于*(-255)
ftutor 写道&即0xffffffff但是这个数 ...
&即0xffffffff但是这个数是不对的，这种补位 ...
谢谢分享！！10757人阅读
int unsignedByte = signedByte &= 0 ? signedByte :256 + signedB
int temp = intValue % 256;
if ( intValue & 0) {
byteValue = temp & -128 ?256 + temp :
byteValue = temp & 127 ? temp -256 :
float -& byte[]
先用 Float.floatToIntBits(f)转换成int
再通过如下方法转成byte []
int -& byte[]
* 将int类型的数据转换为byte数组
* 原理：将int数据中的四个byte取出，分别存储
* @param n int数据
* @return 生成的byte数组
public static byte[] intToBytes2(int n){
byte[] b = new byte[4];
for(int i = 0;i & 4;i++){
b[i] = (byte)(n && (24 - i * 8));
byte[] -& int
* 将byte数组转换为int数据
* @param b 字节数组
* @return 生成的int数据
public static int byteToInt2(byte[] b){
return (((int)b[0]) && 24) + (((int)b[1]) && 16) + (((int)b[2]) && 8) + b[3];
byte[] -& float
public static float getFloat(byte[] b) {
// 4 bytes
int accum = 0;
for ( int shiftBy = 0; shiftBy & 4; shiftBy++ ) {
accum |= (b[shiftBy] & 0xff) && shiftBy * 8;
return Float.intBitsToFloat(accum);
1.package com.
6. * &li&文件名称: com.born.util.ByteUtil.java&/li&
7. * &li&文件描述: byte转换工具&/li&
8. * &li&版权所有: 版权所有(C)&/li&
9. * &li&公 司: bran&/li&
10. * &li&内容摘要:&/li&
11. * &li&其他说明:&/li&
12. * &li&完成日期：&/li&
13. * &li&修改记录0：无&/li&
14. * &/ul&
16. * @version 1.0
17. * @author 许力多
19.public class ByteUtil {
* 转换short为byte
* @param b
* @param s
需要转换的short
* @param index
public static void putShort(byte b[], short s, int index) {
b[index + 1] = (byte) (s && 8);
b[index + 0] = (byte) (s && 0);
* 通过byte数组取到short
* @param b
* @param index
第几位开始取
public static short getShort(byte[] b, int index) {
return (short) (((b[index + 1] && 8) | b[index + 0] & 0xff));
* 转换int为byte数组
* @param bb
* @param x
* @param index
public static void putInt(byte[] bb, int x, int index) {
bb[index + 3] = (byte) (x && 24);
bb[index + 2] = (byte) (x && 16);
bb[index + 1] = (byte) (x && 8);
bb[index + 0] = (byte) (x && 0);
* 通过byte数组取到int
* @param bb
* @param index
第几位开始
public static int getInt(byte[] bb, int index) {
return (int) ((((bb[index + 3] & 0xff) && 24)
| ((bb[index + 2] & 0xff) && 16)
| ((bb[index + 1] & 0xff) && 8) | ((bb[index + 0] & 0xff) && 0)));
* 转换long型为byte数组
* @param bb
* @param x
* @param index
public static void putLong(byte[] bb, long x, int index) {
bb[index + 7] = (byte) (x && 56);
bb[index + 6] = (byte) (x && 48);
bb[index + 5] = (byte) (x && 40);
bb[index + 4] = (byte) (x && 32);
bb[index + 3] = (byte) (x && 24);
bb[index + 2] = (byte) (x && 16);
bb[index + 1] = (byte) (x && 8);
bb[index + 0] = (byte) (x && 0);
* 通过byte数组取到long
* @param bb
* @param index
public static long getLong(byte[] bb, int index) {
return ((((long) bb[index + 7] & 0xff) && 56)
| (((long) bb[index + 6] & 0xff) && 48)
| (((long) bb[index + 5] & 0xff) && 40)
| (((long) bb[index + 4] & 0xff) && 32)
| (((long) bb[index + 3] & 0xff) && 24)
| (((long) bb[index + 2] & 0xff) && 16)
| (((long) bb[index + 1] & 0xff) && 8) | (((long) bb[index + 0] & 0xff) && 0));
* 字符到字节转换
* @param ch
public static void putChar(byte[] bb, char ch, int index) {
int temp = (int)
// byte[] b = new byte[2];
for (int i = 0; i & 2; i ++ ) {
bb[index + i] = new Integer(temp & 0xff).byteValue(); // 将最高位保存在最低位
temp = temp && 8; // 向右移8位
* 字节到字符转换
* @param b
public static char getChar(byte[] b, int index) {
int s = 0;
if (b[index + 1] & 0)
s += b[index + 1];
s += 256 + b[index + 0];
if (b[index + 0] & 0)
s += b[index + 1];
s += 256 + b[index + 0];
char ch = (char)
* float转换byte
* @param bb
* @param x
* @param index
public static void putFloat(byte[] bb, float x, int index) {
// byte[] b = new byte[4];
int l = Float.floatToIntBits(x);
for (int i = 0; i & 4; i++) {
bb[index + i] = new Integer(l).byteValue();
l = l && 8;
* 通过byte数组取得float
* @param bb
* @param index
public static float getFloat(byte[] b, int index) {
l = b[index + 0];
l |= ((long) b[index + 1] && 8);
l |= ((long) b[index + 2] && 16);
l |= ((long) b[index + 3] && 24);
return Float.intBitsToFloat(l);
* double转换byte
* @param bb
* @param x
* @param index
public static void putDouble(byte[] bb, double x, int index) {
// byte[] b = new byte[8];
long l = Double.doubleToLongBits(x);
for (int i = 0; i & 4; i++) {
bb[index + i] = new Long(l).byteValue();
l = l && 8;
* 通过byte数组取得float
* @param bb
* @param index
public static double getDouble(byte[] b, int index) {
l |= ((long) b[1] && 8);
l |= ((long) b[2] && 16);
l |= ((long) b[3] && 24);
l |= ((long) b[4] && 32);
l |= ((long) b[5] && 40);
l |= ((long) b[6] && 48);
l |= ((long) b[7] && 56);
return Double.longBitsToDouble(l);
在Java中，不存在Unsigned无符号数据类型，但可以轻而易举的完成Unsigned转换。
方案一：如果在Java中进行流(Stream)数据处理，可以用DataInputStream类对Stream中的数据以Unsigned读取。
&&&&&&& Java在这方面提供了支持，可以用java.io.DataInputStream类对象来完成对流内数据的Unsigned读取，该类提供了如下方法：
&&&&&&&& （1）int&& readUnsignedByte()&&& //从流中读取一个0~255(0xFF)的单字节数据，并以int数据类型的数据返回。返回的数据相当于C/C++语言中所谓的“BYTE”。
&&&&&&&&& （2）int readUnsignedShort()&& //从流中读取一个0~65535(0xFFFF)的双字节数据，并以int数据类型的数据返回。返回的数据相当于C/C++语言中所谓的“WORD”，并且是以“低地址低字节”的方式返回的，所以程序员不需要额外的转换。
方案二：利用Java位运算符，完成Unsigned转换。
&&&&&& 正常情况下，Java提供的数据类型是有符号signed类型的，可以通过位运算的方式得到它们相对应的无符号值，参见几个方法中的代码：
&&&&& public int getUnsignedByte (byte data){&&&&& //将data字节型数据转换为0~255 (0xFF 即BYTE)。
&&&&&&&& return data&0x0FF;
&&&&& public int getUnsignedByte (short data){&&&&& //将data字节型数据转换为0~65535 (0xFFFF 即 WORD)。
&&&&&&&&&&& return data&0x0FFFF;
&&&&& }&&&&&&
&&&& public long getUnsignedIntt (int data){&&&& //将int数据转换为0~ (0xFFFFFFFF即DWORD)。
&&&&&&&& return data&0x0FFFFFFFFl;
&&&&&&& 灵活的运用这些技法，根本不存“二进制在Java中得不到全面支持”的论断！
JAVA中int、String的类型转换
int -& String
int i=12345;
String s=&&;
第一种方法：s=i+&&;
第二种方法：s=String.valueOf(i);
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？
String -& int
s=&12345&;
第一种方法：i=Integer.parseInt(s);
第二种方法：i=Integer.valueOf(s).intValue();
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？
以下是答案：
第一种方法：s=i+&&; //会产生两个String对象
第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象
第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常
第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象
--------------------------------------------------------------------
1如何将字串 String 转换成整数 int?
A. 有两个方法:
1). int i = Integer.parseInt([String]); 或
i = Integer.parseInt([String],[int radix]);
2). int i = Integer.valueOf(my_str).intValue();
注: 字串转成 Double, Float, Long 的方法大同小异.
2 如何将整数 int 转换成字串 String ?
A. 有叁种方法:
1.) String s = String.valueOf(i);
2.) String s = Integer.toString(i);
3.) String s = && +
注: Double, Float, Long 转成字串的方法大同小异.
JAVA数据类型转换
这是一个例子,说的是JAVA中数据数型的转换.供大家学习
import java.sql.D
public class TypeChange {
public TypeChange() {
//change the string type to the int type
public static int stringToInt(String intstr)
integer = Integer.valueOf(intstr);
return integer.intValue();
//change int type to the string type
public static String intToString(int value)
Integer integer = new Integer(value);
return integer.toString();
//change the string type to the float type
public static float stringToFloat(String floatstr)
floatee = Float.valueOf(floatstr);
return floatee.floatValue();
//change the float type to the string type
public static String floatToString(float value)
Float floatee = new Float(value);
return floatee.toString();
//change the string type to the sqlDate type
public static java.sql.Date stringToDate(String dateStr)
return java.sql.Date.valueOf(dateStr);
//change the sqlDate type to the string type
public static String dateToString(java.sql.Date datee)
return datee.toString();
public static void main(String[] args)
java.sql.D
day = TypeChange.stringToDate(&&);
String strday = TypeChange.dateToString(day);
System.out.println(strday);
JAVA中常用数据类型转换函数
虽然都能在JAVA API中找到，整理一下做个备份。
http://blog.csdn.net/xiaojianpitt/article/details/2728756
在剖析该问题前请看如下代码
* 从byte数组开始位置取4位得到一个int
* @paramababyte数组
* @return返回int值
public staticint getIntFromByte(byte[] ba)
int sum = 0;
for (int i = 0; i & 4; i++)
int temp = ((int) ba[i]) & 0
temp &&= i * 8;
sum = temp +
public static String bytes2HexString(byte[] b) {
String ret = &&;
for (int i = 0; i & b. i++) {
String hex = Integer.toHexString(b[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' +
ret += hex.toUpperCase();
上面是将byte[]转化十六进制的字符串,注意这里b[ i ]& 0xFF将一个byte和 0xFF进行了与运算,然后使用Integer.toHexString取得了十六进制字符串,可以看出
b[i]& 0xFF运算后得出的仍然是个int,那么为何要和 0xFF进行与运算呢?直接 Integer.toHexString(b[ i ]);,将byte强转为int不行吗?答案是不行的.
其原因在于:
1.byte的大小为8bits而int的大小为32bits，java的二进制采用的是补码形式。
二进制原码表示法
原码表示法是机器数的一种简单的表示法。其符号位用0表示正号，用：表示负号，数值一般用二进制形式表示。设有一数为x，则原码表示可记作［x］原。
例如，X1= ＋<span style="color:#10110
X2= -1001010
其原码记作：
［X1］原=[＋1010110]原=
［X2］原=[－1001010]原=
byte是一个字节保存的，有8个位，8位的第一个位是符号位，也就是说代表的是数1 ，代表的就是-1 所以正数最大位，也就是数字127 负数最大为，也就是数字-127
在原码表示法中，对0有两种表示形式：
［+0］原=
二进制补码表示法
java中采用的是补码的形式，下面介绍下什么是补码和反码；
<span style="color:#、反码：
& && &&&一个数如果是正，则它的反码与原码相同；
& && &&&一个数如果是负，则符号位为1，其余各位是对原码取反；
机器数的反码可由原码得到。如果机器数是正数，则该机器数的反码与原码一样；如果机器数是负数，则该机器数的反码是对它的原码（符号位除外）各位取反而得到的。设有一数X，则X的反码表示记作［X］反。
例如：X1= ＋<span style="color:#10110
X2= 一<span style="color:#01010
[X1]反=［X1］原=
<span style="color:#、补码：
机器数的补码可由原码得到。如果机器数是正数，则该机器数的补码与原码一样；如果机器数是负数，则该机器数的补码是对它的原码（除符号位外）各位取反，并在未位加1而得到的。设有一数X，则X的补码表示记作［X］补。
& & ⑴一个数为正，则它的原码、反码、补码相同
& & ⑵一个数为负，刚符号位为1，其余各位是对原码取反，然后整个数加<span style="color:#
&- 1的原码为& && && && && &
- 1的反码为& && && && && &
& && && && && && && && && && && && && && && && && &+ 1
- 1的补码为& && && && && &
0的原码为& && && && && &&&
0的反码为& && && && && &&&（正零和负零的反码相同）
& && && && && && && && && && && && && && &+1
0的补码为& && && && && &（舍掉打头的1，正零和负零的补码相同）
利用溢出，我们可以将减法变成加法
&对于十进制数，从9得到5可用减法：
& & 9－4＝5& 因为4+6＝10，我们可以将6作为4的补数
& & 改写为加法：
& &&9+(10-4)= 9+6＝15（去掉高位1，也就是减10）得到5.
对于十六进制数，从c到5可用减法：
& &&c－7＝5& & 因为7+9＝16 将9作为7的补数
& & 改写为加法：
& & c+(16-7)=c+9＝15（去掉高位1，也就是减16）得到<span style="color:#.
&在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为（），进位1被丢弃。
Integer.toHexString的参数是int，如果不进行0xff，那么当一个byte会转换成int时，由于int是32位，而byte只有8位,这时会进行填充，如果byte的最高位是0的话，int的前面填充0，例如01000001转化成int就变为
如果byte的最高位是1的话，int的前面填充1例如的十进制数为-1转换为int时变为好多1啊，呵呵！即0xffffffff但是这个数是不对的，这种补位就会造成误差。和0xff相与后，高24比特就会被清0了，结果就对了。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2175136次
积分：24329
积分：24329
排名：第118名
原创：57篇
转载：1369篇
评论：321条
(1)(10)(1)(4)(3)(14)(27)(17)(5)(34)(24)(17)(25)(43)(8)(24)(1)(10)(1)(2)(2)(12)(1)(5)(12)(13)(9)(1)(5)(107)(21)(35)(2)(4)(11)(21)(3)(8)(2)(4)(3)(12)(6)(4)(9)(20)(10)(39)(24)(2)(59)(32)(34)(13)(44)(150)(56)(50)(41)(24)(95)(34)(3)(8)(43)(35)(27)
<a href="/article
