16进制是什么意思
1.各种进制
2进制，就是用2个数字来表示进制
8进制，就是用8个数字来表示进制
10进制，就是用10个数字来表示进制
16进制，就是用16个数字来表示进制


进制是什么意思

进制，就是满则进1。多少进制就是满几进1。




代码示例
public class PrintStreamSample {
	/**
	 * 入口函数
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(0x61); //输出97                          注：1.十六进制(0x61：6*16^1 + 1*16^0=97)——》十进制(97)  2.该方法会把整型97转换为字符串97（见jdk源码），然后再输出97
		
		System.out.write(0x61);   //输出a           注：1.十六进制(0x61：6*16^1 + 1*16^0=97)——》十进制(97)——》在ASCII字符编码里，数字97表示字符'a'
		System.out.flush();
	}

}











参考：0x16进制

CPU卡、M1、ID卡，在一卡通平台通常做法是使用扇区的前4字节的10进制做为卡号，但实际扇区存储的都是16进制字符串。所以项目中就有对10进制和16进制转换的要求。

推荐工具：在线进制转换《http://tool.oschina.net/hexconvert/ 》

一、16进制转10进制



var id = Convert.ToInt32("28de1212", 16);

//id 685642258

var id = Convert.ToInt64("28de1212", 16);

//id 685642258

二、10进制转16进制



var str16 = id.ToString("x8");

//str16 "28de1212"

 

转载博客： URLhttps://www.cnblogs.com/hitfredrick/p/6403003.html

C#中二进制、十进制和十六进制互相转换的方法

二进制在C#中无法直接表示，我们一般用0和1的字符串来表示一个数的二进制形式。比如4的二进制为“100”。下面介绍C#里面用于进制转换的方法。

十进制转换为二进制（int-->string）

System.Convert.ToString(d, 2);// d为int类型 以4为例，输出为100



十六进制转换为二进制（int-->string）

System.Convert.ToString(d, 2);// d为int类型 以0X14为例，输出为10100



上面ToString函数的第二个参数表示目标数字系统的基数。

二进制转换为十进制（string-->int）

System.Convert.ToInt32(s, 2);// d为string类型 以“1010”为例，输出为10



十六进制转换为十进制（string-->int、int-->int）

方法一：

System.Convert.ToString(0xa,10);// 以0XA为例，输出为10



或者

System.Convert.ToInt32("0x41", 16);//以"0x41"为例，输出为65



方法二：

System.Int32.Parse(s, System.Globalization.NumberStyles.HexNumber);//s为string类型，以“41”为例，输出为65

注意这里的s中不能带有“0X”或者“0x”，区别于上面的方法。

二进制转换为十六进制（string-->int）

先转换为十进制，在转换为十六进制

string.Format("{0:X}",System.Convert.ToInt32(s, 2));// s为string类型 以“1010”为例，输出为A



十进制转换为十六进制

十进制转换为十六进制不需要特殊的方法，只要对输出格式进行控制一下就可以。



或者使用string.Format("{0：x}", dec)方法进行控制，也可以用s.ToString("X")方式进行控制。

 

除了数制转换之外，数据类型的转换也比较重要。对于基本数据类型，byte、char、int、string以及它们的数组形式的转换虽然简单，但是比较基础的知识。网上也有很多详解，用到的时候自行查阅即可。

 

 

 

 

 

为什么要使用进制数

数据在计算机中的表示，最终以二进制的形式存在 , 就是各种 <黑客帝国>电影中那些 0101010… 的数字 ; 

我们操作计算机 , 实际 就是 使用 程序 和 软件 在 计算机上 各种读写数据,  

如果我们直接操作二进制的话 , 面对这么长的数进行思考或操作，没有人会喜欢。

C，C++ 语言 没有提供在代码直接写二进制数的方法。 

用16进制或8进制可以解决这个问题。 

因为，进制越大，数的表达长度也就越短。

之所以 使用 16或8进制，而不其它的，诸如9或20进制 .

是因为2、8、16，分别是2的1次方、3次方、4次方。这一点使得三种进制之间可以非常直接地互相转换 ; 

8进制或16进制 既 缩短了二进制数，还能 保持了二进制数的表达特点。转换还方便 .

进制的介绍


  
进制 : 是计算机中数据的一种表示方法。 N进制的数可以用0~(N-1) 的数表示, 超过9的用字母A-F 表示 .



10进制



  
先说 我们最 熟悉的 10进制 , 就是 用 0~9 的数表示 , 逢 10 进 1 .



16进制



  
如果是 16 进制 , 它就是 由 0-9，A-F组成， 与10进制的对应关系是：0-9 对应 0-9；A-F对应10-15； 

  字母不区分大小写。



2进制 和 8进制



  
2进制  由 0-1组成
  
  
8进制  由 0-7组成




进制的转换公式


二进制转换十进制 


八进制转换十进制 


十六进制转换十进制 




如何快速的进行 2进制,10进制,16进制 的 相互转换


先记住二进制 的8421



  
首先我们来看一个二进制数：1111，它是多少呢？ 

  你可能还要这样计算：1×2º+1×2¹+1×2²+1×2³=1×1+1×2+1×4+1×8=15。
  
  
我们必须直接记住1111每一位的权值，并且是从高位往低位记，：8、4、2、1。 即，最高位的权值为2³=8，然后依次是 2²=4，2¹=2，2º=1。
  
  
记住8 4 2 1，对于任意一个4位的二进制数，我们都可以很快算出它对应的10进制值。



接下来我们练习 通过 8421 的方式 进行 快速的计算 , 2,10,16进制的转换


1111 = 8 + 4 + 2 + 1 = 15 =F 

1110 = 8 + 4 + 2 + 0 = 14= E 

1101 = 8 + 4 + 0 + 1 = 13= D 

1100 = 8 + 4 + 0 + 0 = 12 =C 

1011 = 8 + 0 + 2 + 1 = 11= B 

1010 = 8 + 0 + 2 + 0 = 10 =A 

1001 = 8 + 0 + 0 + 1 =9 =9 

…… 

0001 = 0 + 0 + 0 + 1 = 1= 1 

0000 = 0 + 0 + 0 + 0 = 0= 0


二进制数要转换为十六进制


二进制数要转换为十六进制，就是以4位一段，分别转换为十六进制。 

如（上行为二制数，下面为对应的十六进制）： 

1111 1101 ， 1010 0101 ， 1001 1011 

F D ， A 5 ， 9 B


16进制数转换为二进制数


反过来，当我们看到 FD时，如何迅速将此16进制数转换为二进制数呢？ 

先转换F： 

看到F，我们需知道它是15（可能你还不熟悉A～F这五个数），然后15如何用8421凑呢？应该是8 + 4 + 2 + 1，所以四位全为1 ：1111。 

接着转换D 

看到D，知道它是13，13如何用8421凑呢？应该是：8 + 4 + 1，即：1101。 

所以，FD转换为二进制数，为：1111 1101


十进制数转换成2进制


由于十六进制转换成二进制相当直接，所以，我们需要将一个十进制数转换成2进制数时，也可以先转换成16进制，然后再转换成2进制。 

比如，十进制数 1234转换成二制数，如果要一直除以2，直接得到2进制数，需要计算较多次数。所以我们可以先除以16，得到16进制数： 

被除数 计算过程 商 余数 

1234 1234/16 77 2 

77 77/16 4 13 (D) 

4 4/16 0 4 

结果16进制为：4D2 

然后我们可直接写出4D2的二进制形式： 

0100 

1101 

0010 

其中对映关系为： 

0100 – 4 

1101 – D 

0010 – 2


二进制数转换成10进制数


同样，如果一个二进制数很长，我们需要将它转换成10进制数时，除了前面学过的方法是，我们还可以先将这个二进制转换成16进制，然后再转换为10进制。 

下面举例一个int类型的二进制数：




  
01101101
  
11100101
  
10101111
  
00011011





我们按四位一组转换为16进制：6D E5 AF 1B 

十进制转十六进制 

采余数定理分解，例如将487710转成十六进制：

487710÷16=30481….14(E) 

30481÷16=1905….1 

1905÷16=119….1 

119÷16=7….7 

7÷16=0….7 

这样就计到487710（10）=7711E（16）

1、Java10进制转16进制

/** 卡号位数：8 */
    public static byte CARD_NUM_BIT = 8;

/**
     * isBlank 
     * 
     * @param value
     * @return true: blank; false: not blank
     */
    private static boolean isBlank(String value) {
        if (value == null || "".equals(value.trim())) {
            return true;
        }
        return false;
    }

/**
     * 10进制转16进制，并补齐卡号位数
     * 
     * @param str
     * @return
     */
    public static String toHexStr(String str) {
        String result = "";
        String regex = "^\\d{1,}$";
        if (!isBlank(str)) {
            str = str.trim();
            if (str.matches(regex)) {
                String hexStr = Long.toHexString(Long.parseLong(str.trim())).toUpperCase();
                if (hexStr.length() < CARD_NUM_BIT) {
                    hexStr = org.apache.commons.lang3.StringUtils.leftPad(hexStr, CARD_NUM_BIT, '0');
                }
                result = hexStr;
            } else if (isHex(str)) {
                if (str.length() < CARD_NUM_BIT) {
                    str = org.apache.commons.lang3.StringUtils.leftPad(str, CARD_NUM_BIT, '0');
                }
                result = str;
            }
        }
        return result;
    }


 

2、Java16进制转10进制

/**
     * isBlank 
     * 
     * @param value
     * @return true: blank; false: not blank
     */
    private static boolean isBlank(String value) {
        if (value == null || "".equals(value.trim())) {
            return true;
        }
        return false;
    }

/**
     * 判断是否是16进制数
     * 
     * @param strHex
     * @return
     */
    public static boolean isHex(String strHex) {
        int i = 0;
        if (strHex.length() > 2) {
            if (strHex.charAt(0) == '0' && (strHex.charAt(1) == 'X' || strHex.charAt(1) == 'x')) {
                i = 2;
            }
        }
        for (; i < strHex.length(); ++i) {
            char ch = strHex.charAt(i);
            if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f'))
                continue;
            return false;
        }
        return true;
    }

/**
     * 计算16进制对应的数值
     * 
     * @param ch
     * @return
     * @throws Exception
     */
    private static int getHex(char ch) throws Exception {
        if (ch >= '0' && ch <= '9')
            return (int) (ch - '0');
        if (ch >= 'a' && ch <= 'f')
            return (int) (ch - 'a' + 10);
        if (ch >= 'A' && ch <= 'F')
            return (int) (ch - 'A' + 10);
        throw new Exception("error param");
    }

/**
     * 计算幂
     * 
     * @param nValue
     * @param nCount
     * @return
     * @throws Exception
     */
    private static long getPower(int nValue, int nCount) throws Exception {
        if (nCount < 0)
            throw new Exception("nCount can't small than 1!");
        if (nCount == 0)
            return 1;
        long nSum = 1;
        for (int i = 0; i < nCount; ++i) {
            nSum = nSum * nValue;
        }
        return nSum;
    }

/**
     * 16进制转10进制，对16进制数的每一位数乘以其对应的16的幂，相加。
     * @param strHex 待转换的字符串
     * @param force 是否强制按16进制转换，纯数字也可能是16进制，true则将纯数字按16进制处理
     * @return
     */
    public static long hexToLong(String strHex, boolean force) {
        long nResult = 0;
        String regex = "^\\d{1,}$";
        if (!isBlank(strHex)) {
            strHex = strHex.trim();
        } else {
            return nResult;
        }
        if (!force && strHex.matches(regex)) {
            return Long.parseLong(strHex);
        }
        if (!isHex(strHex)) {
            return nResult;
        }
        String str = strHex.toUpperCase();
        if (str.length() > 2) {
            if (str.charAt(0) == '0' && str.charAt(1) == 'X') {
                str = str.substring(2);
            }
        }
        int nLen = str.length();
        for (int i = 0; i < nLen; ++i) {
            char ch = str.charAt(nLen - i - 1);
            try {
                nResult += (getHex(ch) * getPower(16, i));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return nResult;
    }

/**
     * 16进制转10进制
     * @param strHex
     * @return
     */
    public static long hexToLong(String strHex) {
        return hexToLong(strHex, false);
    }