随手笔记，有空再修饰下文字

十进制转十六进制

第一种：直接遍历
 public static void toHex2(int num)
 { 
  for (int x=0;x<8 ;x++ )
  {
  System.out.print(num & 15);
  num = num >>>4;
  }
 }

第二种：十六进制包含十六个元素，0-9，a-f，所以我们可以定义一个字符串数组，通过计算&15后所对应的值用遍历打印出来
 public static void toHex2(int num)
 { 
  char [] chs={‘0′,’1′,’2′,’3′,’4′,’5’,
        ‘6’,’7′,’8′,’9′,’a’,’b’,
        ‘c’,’d’,’e’,’f’};//定义数组，因为数组与角标的对等关系，所以可以通过计算&15后的值之间取出与之对应的字符串内容

  for (int x=0;x<8 ;x++ )//最多8次循环
  {
  int temp = num & 15;//定义一个临时变量，存储当前&15的值
   System.out.print(chs[temp]);//打印出计算后的值所对应数组里的元素
  num = num >>>4;
  }
 }
第三种：定义一个arr数组用来存储已转成字符数组的数据，并通过遍历打印出来
 public static void toHex2(int num)
 { 
  char [] chs={‘0′,’1′,’2′,’3′,’4′,’5’,
     ‘6’,’7′,’8′,’9′,’a’,’b’,
     ‘c’,’d’,’e’,’f’};
  char [] arr=new char [8];//定义一个arr数组用于存储计算后的值
  // 0 0 0 0 0 0 0 0 0
  for(int x=0;x<8;x++)
  {
   int temp = num & 15;//把计算的值存入数组arr
   arr[x]=chs[temp];
   num = num>>>4;
  }
  
  for (int x=0;x<arr.length;x++ )
  {
   System.out.print(arr[x]);
  }
第四步：继续优化，因为所打印出来的结果是反的，所以可以通过倒着打印来实现效果
 public static void toHex2(int num)
 { 
  char [] chs={‘0′,’1′,’2′,’3′,’4′,’5’,
     ‘6’,’7′,’8′,’9′,’a’,’b’,
     ‘c’,’d’,’e’,’f’};
  char [] arr=new char [8];//定义一个arr数组用于存储计算后的值
  // 0 0 0 0 0 0 0 0 0
  for(int x=0;x<8;x++)
  {
   int temp = num & 15;//把计算的值存入数组arr
   arr[x]=chs[temp];
   num = num>>>4;
  }
  
  for (int x=arr.length-1;x>=0;x–)
  {
   System.out.print(arr[x]);
  }

 }
第五步：发现会打印一些多出的0，有没有一种方法可以只打印出需要计算的值呢？
 0000 0000 0000 0000 0000 0000 0011 1100   (num)->60
&0000 0000 0000 0000 0000 0000 0000 1111   ->&15
————————————————
 0000 0000 0000 0000 0000 0000 0000 1100  (temp)->12->c

 0000 0000 0000 0000 0000 0000 0000 0011 | (num)1100 >>>4 右移四位继续&15
&0000 0000 0000 0000 0000 0000 0000 1111   ->&15
————————————————
 0000 0000 0000 0000 0000 0000 0000 0011   (temp)->3

 因为与0 &计算都为0，所以之前打印出的0对我们并没有用，也就是无效，那么可以定一个判断条件
 就是我们只需要计算有效位并打印出来即可。所以只要计算后的数的值(num)不为0，我们就循环计算，直到计算到0，则停止
 
public static void toHex2(int num)
 { 
  char [] chs={‘0′,’1′,’2′,’3′,’4′,’5’,
        ‘6’,’7′,’8′,’9′,’a’,’b’,
        ‘c’,’d’,’e’,’f’};
  char [] arr=new char [8];//定义一个arr数组用于存储计算后的值
  
  int pos =0;//定义一个指针，从0角标开始存储数据
  while (num!=0)
  {
   int temp=num&15;
   arr[pos++]=chs[temp];//每计算一次把值存储到POS对应角标
   num = num >>>4;
  }
  
  for (int x=arr.length-1;x>=0;x–)
  {
   System.out.print(arr[x]+”,”);
  }

 }
第六步：发现打印的时候，把所有角标打印出来了，而我们只需要有效位的角标，此时2个有效位
  for (int x=arr.length-1;x>=0;x–)
  {
   System.out.print(arr[x]+”,”);
  }
那我们可以通过POS，只打印我们想要指向的内容
//如果是for(int x=0;x<pos;x++)的话，打印出是c3，因为是从0角标位存储，而数据存储到第二个元素，但角标是1
所以只需要<pos即可，但考虑到需要打印的是3c才符合我们的要求，所以我们继续倒打，但此时pos值是存储到第二个元素，角标是1，所以需要POS-1
简单来说，当判断条件的时候，Pos的意思是数组元素个数，当为初始化值的时候，POS为数组角标
  for (int x=pos-1;x>=0;x–)
  {
   System.out.print(arr[x]+”,”);
  }
第七步：for循环里，一般不喜欢反过来写，那么有什么办法可以按照正常遍历的方法写出来呢
public static void toHex2(int num)
 { 
  char [] chs={‘0′,’1′,’2′,’3′,’4′,’5’,
       ‘6’,’7′,’8′,’9′,’a’,’b’,
       ‘c’,’d’,’e’,’f’};
  char [] arr=new char [8];//定义一个arr数组用于存储计算后的值
  
  int pos=arr.length-1;//定义一个角标指针，直接指向最后一个角标
  while (num!=0)
  {  
   
   int temp=num&15;
   arr[pos–]=chs[temp];//从最后一个角标开始存
   num = num >>>4;
  }
  
  for(int x=pos+1;x<arr.length;x++)//此时POS指的是最后一个角标，所以我们要从它前一个角标开始打印，POS+1
  {
   System.out.print(arr[x]+”,”);
  }

 }
第八步：for(int x=pos+1;x<arr.length;x++)pos+1,不容易理解，继续优化，更加美观
 public static void toHex2(int num)
 { 
  char [] chs={‘0′,’1′,’2′,’3′,’4′,’5’,
       ‘6’,’7′,’8′,’9′,’a’,’b’,
       ‘c’,’d’,’e’,’f’};
  char [] arr=new char [8];//定义一个arr数组用于存储计算后的值
  
  int pos=arr.length;//此处定义的是POS值为该数组的元素个数
  while (num!=0)
  {  
   
   int temp=num&15;
   arr[–pos]=chs[temp];//获取计算值前POS-1 变成最后一个指标
   num = num >>>4;
  }
  
  for(int x=pos;x<arr.length;x++)//for (int x=pos-1;x>=0;x–)
  {
   System.out.print(arr[x]+”,”);
  }

 }