Java_数组之进制转换

  1 1，使用数组 
  2 /*
  3 进制转换 使用数组
  4 
  5 定义一个功能，打印一个十进制数转对应16进制表现形式
  6 */
  7 
  8 class ArrayTest4 
  9 {
 10     public static void main(String[] args) 
 11     {
 12         toHex(60);
 13     }
 14     /*
 15     定义一个功能，打印一个十进制数转对应16进制表现形式
 16 
 17     0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
 18     0  1  2  3  4  5  6  7  8  9   A  B   C  D  E  F
 19     48 49 50 51 52 53 54 55 56 57 65 66 67 68 69 70
 20 
 21 
 22 
 23 
 24     什么时候使用数组？
 25     当同一类型的元素较多时，就是用数组这个容器对数据进行存储
 26 
 27     */
 28     public static void toHex(int num)
 29     {
 30         //定义一个char类型的数组，用于存储每次获取到的十六进制值
 31         char[] chs=new char[8];
 32         int pos =chs.length;
 33         while(num!=0)
 34         {
 35             pos--;
 36             int temp =num & 15;
 37             if (temp>9)
 38             {
 39                 chs[pos]=(char)(temp-10+'A');
 40             }
 41             else
 42                 chs[pos]=(char)(temp-0+'0');
 43             num = num >>> 4;
 44         }
 45         System.out.println("pos="+pos);
 46         //打印数组内容
 47         for (int x=pos;x<pos ;x++ )
 48         {
 49             System.out.print(chs[x]);
 50             //  \u0000  空字符值
 51         }
 52     }
 53 }
 54 
 55 
 56 
 57 
 58 2，查表法
 59 /*
 60 进制转换  查表法
 61 
 62 定义一个功能，打印一个十进制数转对应16进制表现形式
 63 */
 64 
 65 class ArrayTest5
 66 {
 67     public static void main(String[] args) 
 68     {
 69         toHex2(60);
 70     }
 71     /*
 72     定义一个功能，打印一个十进制数转对应16进制表现形式
 73 
 74     10进制    0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
 75     16进制    0  1  2  3  4  5  6  7  8  9   A  B   C  D  E  F
 76     num-10+'A'的动作不太容易想到
 77     我们可以换另一种想法
 78     我们发现，十六进制中一共有16个元素
 79     而且没通过&15获取的数字都在15之内，都有对应的十六进制元素
 80     
 81     而且元素对应的数组，正好有规律，而且符合了数组这种容器的特点---角标
 82     
 83     那么就可以将十六进制的元素都存储到数组中
 84     将每次&15的结果作为角标去查这个数组，就可以获取到十六进制的对应的元素；
 85     
 86     这就是传说中的查表法；
 87     
 88     什么时候使用查表法呢？
 89     当元素很多，而且这些元素与数字有对应关系，而且这些数字都有角标的规律
 90     这时，优先想到查表法。
 91 
 92 二进制表 48 49 50 51 52 53 54 55 56 57 65 66 67 68 69 70
 93 
 94 
 95 
 96 
 97     什么时候使用数组？
 98     当同一类型的元素较多时，就是用数组这个容器对数据进行存储
 99 
100     */
101 
102 
103     public static void toHex2(int num)
104     {
105         //定义一个十六进制的元素的表
106         char[] arr={'0','1','2','3',
107                    '4','5','6','7',
108                    '8','9','A','B',
109                    'C','D','E','F'};
110         
111         //定义一个char类型的数组，用于存储每次获取到的十六进制值
112         char[] chs=new char[8];
113         int pos =chs.length;
114         while(num!=0)
115         {
116             int temp =num & 15;
117             chs[--pos]=arr[temp];
118             num = num >>> 4;
119         }
120         System.out.println("pos="+pos);
121         //打印数组内容
122         for (int x=pos;x<chs.length ;x++ )
123         {
124             System.out.print(chs[x]);
125             //  \u0000  空字符值
126         }
127     }
128 }
129  
130 
131 
132 
133 3 三种进制转换
134 
135 class ArrayTest6 
136 {
137     public static void main(String[] args) 
138     {
139         toBin(6);
140         toHex(26);
141         toOctal(60);
142 
143         System.out.println(Integer.toBinaryString(-6));//开发写这个
144 
145 
146         
147     }
148     //十进制--->二进制
149     public static void toBin(int num)
150     {
151         trans(num,1,1);
152     }
153 
154     //十进制--->八进制
155 
156     public static void toOctal(int num)
157     {
158         trans(num,7,3);
159     }
160 
161     //十进制--->十六进制
162 
163     public static void toHex(int num)
164     {
165         trans(num,15,4);
166     }
167 
168     public static void trans(int num,int base,int offset)
169     {
170         if (num=0)
171         {
172             System.out.println("0");
173         }
174         //定义一个十六进制的元素的表
175         char[] arr={'0','1','2','3',
176                    '4','5','6','7',
177                    '8','9','A','B',
178                    'C','D','E','F'};
179         
180         //定义一个char类型的数组，用于存储每次获取到的十六进制值
181         char[] chs=new char[32];
182         int pos =chs.length;
183         while(num!=0)
184         {
185             int temp =num & base;
186             chs[--pos]=arr[temp];
187             num = num >>> offset;
188         }
189         System.out.println("pos="+pos);
190         //打印数组内容
191         for (int x=pos;x<chs.length ;x++ )
192         {
193             System.out.print(chs[x]);
194             //  \u0000  空字符值
195         }
196     }
197 }

 

转载于:https://www.cnblogs.com/Wll-Fss/p/7759916.html