主要内容
1. 十进制二进制互转
2. 二进制的位运算
3.JDK 内置的进制转换
4.JAVA 中的进制
十进制二进制互转
57 111001
二进制的位运算: 优点: 特定情况下, 计算方便, 被支持面广泛
按位与 & (两位全位 1, 结果才为 1)
0 与 0=0;0 与 1=0;1 与 0=0; 1 与 1=1;
例: 51 与 5
- 00110011
- ---------------
- 00000101
- =00000001
- =1
位运算的特殊用法:
* 清零, 取一个数中的指定位
按位或 | (只要有一个位位 1, 结果就为 1)
0|0=0; 0|1=1; 1|0=1; 1|1=1;
例: 51|5 =
- 00110011
- ---------------
- 00000101
- =00110111 = 55
或运算的特殊用法:
常用来对一个数据的某些位置 1;
异或运算 (两个相应位为异, 则该结果为 1, 否则为 0)
0 0=0; 0 1=1; 1 0=1; 1 1=0;
例: 51 5=
- 00110011
- ---------------
- 00000101
- =00110110=54
特殊用法:
* 使特定位翻转
* 与 0 异或保留原值
* 取反运算(对一个二进制数按位取反, 即将 0 变为 1,1 变为 0)
利用与 0 异或, 两个变量交换值的方法:
两个变量交换值的方法有:
1. 借助第三个变量
C=A; A=B; B=C;
2. 利用加减法
C=A+B; B=C-B; A=C-B;
3. 用位异或运算实现 (效率最高)
A=AB; B =AB; A=AB;
左移运算<< (将一个运算对象的各二进制位全部左移若干位, 左边的二进制位丢弃, 右边补 0)
2<<1= 4
右移运算>>(将一个运算对象的各二进制位全部右移若干位, 正数左补 0, 负数左补 1, 右边丢弃)
无符号右移
负数以其正值的补码形式表示
原码: 一个正数按照绝对值大小转换成的二进制称为原码
反码
补码: 反码加 1 称为补码
JDK 内置的进制转换:
JAVA 中的进制:
平时开发, 进制转换和位操作用的并不多, 因为 JAVA 处理的是高层
在跨平台中用的较多, 文件读写, 数据通信等
基本数据类型:
int 数据类: 1 字节 = 8bit
- byte(8bit,-128~127)
- short(16bit)
- int(32bit)
- long(64bit)
float: 单精度 32bit , 双精度 64bit
bolean:true 1bit,false 1bit
char:unicode 字符 16 位
对应的包装类: Integer......
在 JAVA 里面除去基本数据类型的其它类型都是引用数据类型, String 是一个类, 所以 String 不是基本类型而是引用类型
数据类型转换为字节:
- int (8143)
- 8143(00000000,00000000,00011111,11001111)=byte[]={-49,31,0,0}
第一个字节(低端) 8143>>0*8&0xff=(11001111)=207 或有符号 - 49
第二个字节(低端) 8143>>1*8&0xff=(00001111)=31
第三个字节(低端) 8143>>2*8&0xff=(00000000)=0
第四个字节(低端) 8143>>3*8&0xff=(00000000)=0
byte 转 int 的时候为什么非要先 & 0xff 计算出来才是正确答案?
首先, JAVA 中的二进制采用的是补码形式, 并非原码或反码, 这 3 个概念要搞清楚;
其次, byte 占 8 位, int 占 32 位, 将 byte 强制转换为 int 型时, 如果没有做 & 0xff 运算, 且 byte 对应的值为负数的话, 就会对高位 3 个字节进行补位, 这样就有可能出现补位误差的错误
举例来说, byte 型的 - 1, 其二进制 (补码) 为 11111111(即 0xff), 转换成 int 型, 值也应该为 - 1, 但经过补位后, 得到的二进制为 11111111111111111111111111111111(即 0xffffffff), 这就不是 - 1 了, 对吧?
而 0xff 默认是 int 型, 所以, 一个 byte 跟 0xff 相与, 会先将那个 byte 转化成 int 型运算, 这样, 结果中的高位 3 个字节就总会被清 0, 于是结果就是我们想要的了~
字符串转化为字节数据 :
String s; byte[] bs = s.getBytes();
字节数组转化为字符串:
- String s = new Stirng(bs);
- String s = new String(bs,encode);//encode 指编码方式 "gb2312,utf-8"
- public class Convert {
- /**
- * <<左移运算<<右移运算<<<无符号右移
- */
- // int 转 Byte[]
- public static byte[] int2Bytes(int id) {
- byte[] arr = new byte[4];
- arr[0] = (byte)((int)(id >> 0 * 8) & 0xff);
- arr[1] = (byte)((int)(id >> 1 * 8) & 0xff);
- arr[2] = (byte)((int)(id >> 2 * 8) & 0xff);
- arr[3] = (byte)((int)(id >> 3 * 8) & 0xff);
- return arr;
- }
- // Byte[]转 int
- public static int Bytes2int(byte[] arr) {
- int rs0 = (int)((arr[0] & 0xff) << 0 * 8);
- int rs1 = (int)((arr[1] & 0xff) << 1 * 8);
- int rs2 = (int)((arr[2] & 0xff) << 2 * 8);
- int rs3 = (int)((arr[3] & 0xff) << 3 * 8);
- return rs0 + rs1 + rs2 + rs3;
- }
- // long 转化为 byte[]
- public static byte[] long4Bytes(long id) {
- byte[] arr = new byte[8];
- for (int i = 0; i < arr.length; i++) {
- arr[i] = (byte)((int)(id >> i * 8) & 0xff);
- }
- return arr;
- }
- /**
- * byte[]转化为 long 型和转化 int 型一样, 只是 long 是 64bit, 而 int 是 32bit
- */
- public static void main(String[] args) {
- byte[] arr = Convert.int2Bytes(8143);
- System.out.println(arr[0] + "\n" + arr[1] + "\n" + arr[2] + "\n" + arr[3]);
- int rs = Convert.Bytes2int(arr);
- System.out.println(rs);
- byte[] arr2 = Convert.long4Bytes(20);
- for (byte b: arr2) {
- System.out.println(b);
- }
- // 字符串与字节数组:
- String describle = "我是字符串";
- byte[] barr = describle.getBytes();
- String des = new String(barr);
- System.out.println(des);
- }
- }
- View Code
来源: http://www.bubuko.com/infodetail-2495955.html