class ArrayTest6
{
public static void main(String[] args)
{
  toHex(60);
}
/*
0 1 2 3 4 5 6 7 8 9  A  B  C  D  E  F  ==十六进制中的元素。
0 1 2 3 4 5 6 7 8 9  10 11 12 13 14 15
查表法：将所有的元素临时存储起来。建立对应关系。
每一次&15后的值作为索引去查建立好的表。就可以找到相应的元素。
这样比 -10+'a'简单的多。
这个表怎么建立呢？
可以通过数据的形式来定义
*/
public static void toHex (int num)
{
  char[] chs = {'0','1','2','3'
      ,'4','5','6','7'
      ,'8','9','A','B'
      ,'C','D','E','F'};
  for (int x=0;x<8 ;x++ )
  {
   int temp = num & 15;
   System.out.println(chs [temp]);
   num = num >>> 15;
  }
}
}

就是自己定义的一个方法名

进行16进制转换

就是将一个十进制整数转换为十六进制
public class TestPrint{
        public static void main(String[] args) {
                int  num = 60; //定义要转换的整数
                //将之转换为16进制 ，直接调用Interger里面的toHexString(int i)静态方法
                // 如果不理解 可以查看api文档
                String str = Integer.toHexString(num);
                System.out.println(str);
                //如果要知道用代码实现可以，看下面toHex()方法
                toHex(num);
        }
        public static void toHex(int num){
                int num1 = num;
                //定义一个对应关系表
                char[] chs = {'0','1','2','3',
                                          '4','5','6','7',
                                          '8','9','A','B',
                                          'C','D','E','F',};
                /*
                 * 一会查表会查到比较的数据，数据一多，就先存储起来，在进行操作
                 * 所以定义一个数组，临时容器
                 */
                char[] arr = new char[8];
                int pos = 0;
                while(num != 0){
                        int temp = num & 15;
                        arr[pos++] = chs[temp];
                        num = num >>> 4;
                }
                System.out.print("十进制：" + num1 + " 转换十六进制为：" );
                for(int i = pos - 1; i >= 0; i--){
                        System.out.print(arr);
                }
                System.out.println();
        }
        
}
输出：
3c
十进制：60 转换十六进制为：3C

就是转成16进制的意思呗

转换为16进制！

将其转为16进制

自己定义的一个方法  功能是通过查表法来完成16进制的转换

toHex()方法，简单说就是，把括号中的数变成十六进制表现形式。

将十进制60转换成16进制 3c

其实这就是自定义的方法名，表示将十进制数据转换成16进制的数，如果自己不写这个方法的方法体，这个方法时没用的

嗯呢，谢谢热心的兄弟姐妹们

就是调用toHex()方法将60转换为十六进制

谢谢你们

toHex();括号内的十进制转换成十六进制。

toHex(60)；就是调用toHex方法把十进制数60转换成16进制数

将括号里面的十进制，转换成16进制。

大西洋 发表于 2015-4-30 12:21
toHex(60);  意思是调用你自己定义的一个叫 toHex() 的方法函数~ 并且传一个参数60到这个方法内部进行运算~ ...

toHex()方法，简单说就是，把括号中的数变成十六进制表现形式。

1. public class ArrayTest6 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                
   
5.                 toHex(60);
   
6.                 //toBin(-6);
   
7.         }
   
8.         /*
   
9.          0 1 2 3 4 5 6 7 8 9  A  B  C  D  E  F   ==十六进制中的元素。
   
10.          0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    
11.          
    
12.          查表法：将所有的元素临时存储起来。建立对应关系。
    
13.          每一次&15后的值作为索引去查建立好的表。就可以找到对应的元素。
    
14.          这样比 -10+'a'简单的多。
    
15.          
    
16.          如何建立此表呢？
    
17.          可以通过数组的形式来定义。
    
18.          
    
19.          发现出结果，但是是反着的。需要正过来，可以通过StringBuffer reverse功能来完成。
    
20.          所以可以使用已经学过的容器：数组 来完成存储。
    
21.          
    
22.          */
    
23.         public static void toHex(int num){
    
24.                 char[] chs={'0','1','2','3',
    
25.                                     '4','5','6','7',
    
26.                                     '8','9','A','B',
    
27.                                     'C','D','E','F',};
    
28.                 //定义一个临时容器
    
29.                 char[] arr=new char[8];
    
30.                 int pos=arr.length;
    
31.                
    
32.                 while(num!=0){
    
33.                         int temp=num & 15;
    
34.                         //System.out.println(chs[temp]);
    
35.                         arr[--pos]=chs[temp];
    
36.                         num=num>>>4;
    
37.                                     
    
38.                 }
    
39.                 //System.out.println("pos="+pos);
    
40.                 //存储数组arr数组遍历。
    
41.                 for(int x=pos;x<arr.length;x++){
    
42.                         System.out.print(arr[x]+",");
    
43.                 }
    
44.         }
    
45.        
    
46.        
    
47.         public static void toBin(int num){
    
48.                 //定义二进制的表。
    
49.                 char[] chs={'0','1'};
    
50.                
    
51.                 //定义一个临时存储容器。
    
52.                 char[] arr=new char[32];
    
53.                
    
54.                 //定义一个操作数组的指针
    
55.                 int pos =arr.length;
    
56.                
    
57.                 while(num!=0){
    
58.                         int temp=num & 1;
    
59.                         arr[--pos]=chs[temp];
    
60.                         num=num>>>1;
    
61.                        
    
62.                 }
    
63.                 for(int x=pos;x<arr.length;x++){
    
64.                         System.out.print(arr[x]);
    
65.                 }
    
66.                
    
67.         }
    
68. }

复制代码

应该是num = num>>>4;  移动四位  num =num>>>15 不对吧。

toHex （）：首先它定义了一个数组，把16进制的数的表示放进去，由于是数组就可以用下标访问。然后由于int 是32位，故他判断8次（每次4位，8次32位）每4位2进制码 &15（1111）就相当于它本身，把值传给temp（自动转换为10进制），用temp作为下标查找之前的数组就可以找到对应的16进制字符。
num = num >>> 15；右移四位后循环继续。

toHex()方法，简单说就是，把括号中的数变成十六进制表现形式。
题目中，你传的是60，那么输出的就是3c，不过，你要么打印，要么传值，你只写个toHex（60），没意义。