Java 基本数据类型 && 位运算

---

1. Java基本数据类型

　　1.1 数据类型示意图

类型	字节数	范围
byte	1	-128~127
short	2	-32768~32767
int	4	-231~231-1
long	8	-263~263-1
float	4
double	8
bolean	1
char	2

　　(ps:  byte、char、short在运算时会自动提升到 int 类型)

　　1.2 隐式转换&显式转换

　　隐式类型转换：从存储范围小的类型到存储范围大的类型转换。

　　显示类型转换：强制类型转换，从存储范围大的类型到存储范围小的类型转换。

---

2. 位运算

　　2.1 位运算符

运算符	说明
&	与
|	或
^	异或
~	取反
<<	左移
>>	右移
>>>	无符号右移

　　【&&与&的区别】

　　&&存在短路，&通过位运算完成，无短路操作

　　2.2 原码、反码、补码

　　【原码】

　　符号位加上数字的二进制表示，第一位为符号位（0为正数，1为负数）

　　byte 类型的 +7 和 -7 的原码如下

　　+7：00000111

　　-7： 10000111

　　【反码】

　　正数的反码与原码相同，负数的反码符号位不变，其余位数取反。

　　byte 类型的 +7 和 -7 的反码如下

　　+7：00000111

　　-7： 11111000

　　【补码】

　　正数的原码、反码、补码相同，负数的反码为原码取反加1

　　byte 类型的 +7 和 -7 的补码如下

　　+7：00000111

　　-7： 11111001

　　2.3 把 long 数据转换成字节数组相互转换

 /**
  * 1. 把long数据转换成字节数组
  * 2. 把字节数组数据转换成long
  */
 public class TransDataType {
     //把long数据转换成字节数组
     public static byte[] long2Bytes(long lon) {
         byte[] bytes = new byte[8];
         for (int i = 0; i < 8; i++) {
             bytes[i] = (byte) (lon >> (56 - 8 * i));
         }
         return bytes;
     }

     //把字节数组数据转换成long
     public static long bytes2Long(byte[] bytes) {
         long val = 0;
         for (int i = 0; i < 8; i++) {
             long lon = ((long) bytes[i] & 0xff) << (56 - 8 * i);
             val += lon;
         }
         return val;
     }

     public static void main(String[] args) {
         byte[] bytes = long2Bytes(-1275555);
         for (int i = 0; i < bytes.length; i++) {
             System.out.println(bytes[i]);
         }

         System.out.println("==============================================");

         long l = bytes2Long(bytes);
         System.out.println(l);
     }
 }

　　2.4 将 byte 变换成无符号的整数(0 ~ 255 , 正数不变)

 /**
  * 将byte变换成无符号的整数(0 ~ 255 , 正数不变)
  */
 public class TransByte2Int {
     public static int bytes2Int(byte by){
         int a = by&0xff;
         return a;
     }

     public static void main(String[] args) {
         int i = bytes2Int((byte) -128);
         System.out.println(i);
     }
 }

　　2.5 定义函数，取出整数内存中的存储形态对应的16进制字符串与2进制字符串

 /**
  * 定义函数，取出整数内存中的存储形态对应的16进制字符串
  * 定义函数，取出整数内存中的存储形态对应的2进制字符串
  */
 public class TransInt2String {
     //定义函数，取出整数内存中的存储形态对应的16进制字符串
     public static String int2HexString(int in) {

         StringBuilder builder = new StringBuilder();
         char[] chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
         for (int i = 0; i < 8; i++) {
             char c = chars[in >> (i * 4) & 0x0f];
             builder.insert(0, c);
         }
         return builder.toString();
     }

     //定义函数，取出整数内存中的存储形态对应的2进制字符串
     public static String int2BinString(int in) {

         StringBuilder builder = new StringBuilder();
         char[] chars = {'0', '1'};
         byte[] bytes = new byte[8];
         for (int i = 0; i < 32; i++) {
             builder.append(chars[in >> (31 - i) & 0x01]);
         }
         return builder.toString();
     }

     public static void main(String[] args) {

         System.out.println("==============================================");
         String s1 = int2HexString(100);
         System.out.println(s1);

         System.out.println("==============================================");
         String s2 = int2BinString(100);
         System.out.println(s2);
     }
 }

　　2.6 有5亿整数(非负)，去重计算不同整数的个数，300M内存

 package com.share.java.test;

 import org.junit.Test;

 /**
  * 有5亿整数(非负)，去重计算不同整数的个数，300M内存
  * int的最大值为Integer.MAX_VALUE (2147483647/8/1024/1024=255)
  * 一个byte有8位，定义长度为 Integer.MAX_VALUE/8 +1 的byte数组
  * 每一位都表示一个数
  * 遍历int数组
  * 通过 整数/8 确定行，用过 整数%8 确定列
  * 通过得到的行数和列数确定的位置，判断该位置是否存在1
  * 若不存在，将该位置设置为1，count加1
  */
 public class TestCalc {

     @Test
     public void testCountUnique() {
         int[] arr = {0, 1, 2, 3, 4, 1, 2, Integer.MAX_VALUE};
         System.out.println(countUnique(arr));
     }

     /**
      * 去重统计整数个数
      */
     public static int countUnique(int[] arr) {
         //计算行数
         int rows = Integer.MAX_VALUE / 8 + 1;

         //初始化字节数组
         byte[] bytes = new byte[rows];

         //计数器
         int count = 0;
         //
         for (int i : arr) {
             //定位行数
             int row = i / 8;
             //定位列数
             int col = i % 8;
             //
             int r = (byte) (bytes[row] & (1 << col));
             if (r == 0) {
                 count++;
                 bytes[row] = (byte) (bytes[row] | (1 << col));
             }
         }
         return count;
     }
 }

---