今天学10进制转化成16进制，60=3C，可惜用函数写出来显示为0000 003C，怎么把前面多余的0去掉。
我的思考是遇见0就打印空("")，可惜又想到如果是0003 000C，我这种方法肯定错了。
那可怎么办？

1.可以设置一个判断，当第一次读到非0字符时开始显示，这样前面的0就可以省略，中间的0也可以保存；
2.推荐给楼主一个10转16进制非常方便的方法，采用位运算，下面是我编的这种方法的代码

1. import java.util.Scanner;
   
2. public class ToShiLiu {
   
3.         public static void main(String args[])
   
4.         {
   
5.                 Scanner sc=new Scanner(System.in);
   
6.                 while(sc.hasNext())
   
7.                 {
   
8.                         int a=sc.nextInt();
   
9.                         char[] c={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
   
10.                         StringBuffer sb=new StringBuffer("");
    
11.                         boolean flag=true;
    
12.                         if(a==0){
    
13.                                 System.out.println(a);flag=false;
    
14.                         }
    
15.                         while(a>0&&flag)
    
16.                         {
    
17.                                 String str=sb.toString();
    
18.                                 sb=new StringBuffer("");
    
19.                                 int t=a&15;
    
20.                                 a=a>>>4;
    
21.                                 sb.append(c[t]).append(str);
    
22.                         }
    
23.                         System.out.println(sb.toString());
    
24.                 }
    
25.         }
    
26. }

复制代码

燿陚√揚葳 发表于 2014-7-3 17:07
第一种方式可以定义一个容器，然后进行判断
这里要注意一下判断的条件就可以了
代码如下：

:handshake谢谢，第一种方法更适合我现在的水平。
毕老师那节课，上到最后忘记将怎么去掉前面的0，就结束了。

lz是把转换后的每一位数字存到数组里的么？这样的话，输出的时候从数组尾部开始循环，从第一个不是0的数字开始输出：

1. i = arr.length - 1;
   
2. while(i >= 0 && arr[i] == 0)i--;
   
3. for(j = i; j >=0; j--)
   
4.     System.out.println(arr[j]);
   

复制代码

第一种方式可以定义一个容器，然后进行判断
这里要注意一下判断的条件就可以了
代码如下：

1. 
   
2. <P>public class Demo {
   
3. public static void toHex(int num){
   
4.   StringBuffer sb=new StringBuffer();
   
5.   for(int x=0;x<8;x++){
   
6.    
   
7.    int temp=num&15;
   
8.    //这里要注意判断条件，如果只是temp为0的话那么比如十六进制10A，打印出来就成了1A了
   
9.    if(num==0&&temp==0){
   
10.     num=num>>>4;
    
11.     continue;//满足条件的话就不执行本次循环后的语句，继续本次循环
    
12.    }
    
13.    if(temp>9)
    
14.     sb.append((char)(temp-10+'A'));
    
15.    else
    
16.     sb.append(temp);
    
17.    num=num>>>4;
    
18.   }
    
19.   System.out.println(sb.reverse());
    
20. }
    
21. public static void main(String[] args) {
    
22.   toHex(266);
    
23. }
    
24. }</P>

复制代码

还有第二种就是毕老师视屏中讲的查表法
代码如下：

1. package com.fki;
   
2. /*查表法
   
3. * 0 1 2 3 4 5 6 7 8 9 A B C D E F
   
4. * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
   
5. * 1.将所有的元素临时储存起来，建立对应关系每一次&15的值作为索引去查建立好的表，就可以找对应的元素。
   
6. * 这样比-10+‘A’简单得多
   
7. * 这个表可以通过数据的形式来定义
   
8. *
   
9. * 结果出来是反着的，可以通过StringBuffer reverse来完成
   
10. * 使用数组来完成储存
    
11. *
    
12. */
    
13. 
    
14. public class Good {
    
15. public static void toHex(int num){
    
16. char[] chs={'0','1','2','3'
    
17. ,'4','5','6','7'
    
18. ,'8','9','A','B'
    
19. ,'C','D','E','F'};
    
20. //定义一个临时容器
    
21. char[] arr=new char[8];
    
22. int pos=arr.length;
    
23. while(num!=0){ //注意是num！=0，而不是temp，num为零说明这个数就为零了
    
24. int temp=num&15;
    
25. arr[--pos]=chs[temp];//先完成递减再做存储，如果是pos--则是先存储再做减减
    
26. num=num>>>4;
    
27. }
    
28. System.out.println("pos="+pos);
    
29. for(int x=pos;x<arr.length;x++){
    
30. System.out.print(arr[x]);
    
31. }
    
32. }
    
33. 
    
34. 
    
35. public static void main(String[] args) {
    
36. toHex(60);
    
37. }
    
38. 
    
39. }

复制代码

用 &和位移 的方式进行判断