下面的代码实现了该功能，只是sum+=n*(1<<(4*i));怎么理解？

1. String s="ab";
   
2.           //System.out.println(Integer.parseInt(s,16));
   
3.            int sum=0;
   
4.           
   
5.           int len = s.length();
   
6.           for (int i = 0; i < len; i++) {
   
7.                 char c=s.charAt(len-1-i);
   
8.                 int n=Character.digit(c, 16);
   
9.                 //System.out.println(n);
   
10.                 sum+=n*(1<<(4*i));
    
11.           }
    
12.           System.out.println(sum);

复制代码

我现在也学到这里，对于没有基础来说，有点难的感觉

胡永城 发表于 2013-11-28 17:38

嗯嗯，谢谢，明白了

我的上一条回复29行书写错误，是

1. // 1 << (4 * i)  相当于   2的4*i次方/16的i次方

复制代码

石头6004 发表于 2013-11-28 16:53
十六进制数的第0位的权值为16的0次方，第1位的权值为16的1次方，依此类推
所以，在第N（N从0开始）位上 ...

嗯，明白了，太感谢了，一开始就是以为1<<0等于0给晕了。其实是1<<0=1，1<<1=2，1<<2=4...也就是
2^0=1，2^1=2，2^2=4...那么1<<(4*i)也就是16的i次方了

1. String s = "ab";
   
2.                 // System.out.println(Integer.parseInt(s,16));
   
3.                 int sum = 0;
   
4. 
   
5.                 int len = s.length();
   
6.                 for (int i = 0; i < len; i++) {
   
7.                        
   
8.                         //  charAt(int index)方法是一个能够用来检索特定索引下的字符的String实例的方法.
   
9.                         //charAt()方法返回指定索引位置的char值。索引范围为0~length()-1.
   
10.                         //如: str.charAt(0)检索str中的第一个字符,str.charAt(str.length()-1)检索最后一个字符.
    
11.                        
    
12.                         char c = s.charAt(len - 1 - i);
    
13.                        
    
14.                         // 在指定的基数返回字符char的数值。
    
15.                        
    
16.                         int n = Character.digit(c, 16);
    
17.                        
    
18.                         // b = 11 ; a = 10 十六进制转换为十进制，每一位上的值乘以8的n-1次方(n为位数)
    
19.                        
    
20.                         sum += n * (1 << (4 * i));
    
21.                         /**<<位运算符
    
22.                          *
    
23.                          * i=0   4 * i=0   左移0位
    
24.                          * (1)0000 0001  ->  (1)0000 0001
    
25.                          *
    
26.                          * i=1    4 * i=4   左移4位
    
27.                          * (1)0000 0001  ->  (16)0001 0000
    
28.                          *
    
29.                          * 1 << (4 * i)  相当于   2*（2的4*i次方/16的i次方）
    
30.                          *
    
31.                          * n * (1 << (4 * i));   n*(16的i次方)
    
32.                          */
    
33.                 }
    
34.                 System.out.println(sum);

复制代码

十六进制数的第0位的权值为16的0次方，第1位的权值为16的1次方，依此类推
所以，在第N（N从0开始）位上，如果是是数 X，就表示X * 16的N次方。
例如：
将十六进数 F2转换成10进制：

2 * 16^0 + F * 16^1=  2 + 240 = 240

1. package cn.itcast;
   
2. 
   
3. public class Test {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 // TODO Auto-generated method stub
   
7.                 String s="ab";
   
8.         //System.out.println(Integer.parseInt(s,16));
   
9.          int sum=0;
   
10.         
    
11.         int len = s.length();
    
12.         for (int i = 0; i < len; i++) {
    
13.               char c=s.charAt(len-1-i);                //返回指定索引处的Char值
    
14.               int n=Character.digit(c, 16);        //返回使用指定基数的字符 c 的数值。
    
15.               System.out.println(n);
    
16.               sum+=n*(1<<(4*i));
    
17. //            这句代码是为了将每一次循环所得的c的数值进行进制转换，并且依次累计叠加
    
18.         }
    
19.         System.out.println(sum);
    
20.         }
    
21. }
    
22. //十六进制转成十进制的原理是：将数字进行左移位4位；
    
23. //根据8 4 2 1 码进行转换！

复制代码

石头6004 发表于 2013-11-28 16:20
sum+=n*(1

我不是想问这个，我这是想问这个语句在整个代码中是什么意思，为什么要这么做，十六进制转成十进制的原理是什么

sum+=n*(1<<(4*i))
a<<b;是将a左移b位！
这段代码，就是sum = sum + n * 将1左移（4*i）位的结果