用户提供需要转换的数据和该数据的进制，以及要转换的进制
    例如，用户提供了一个十进制数：10，要求将此数据以二进制形式转换，则通过进制转换器转换的最终结果应该：1010。
    提示：此进制转换器可以在 2-36 进制之间对数据进行任意转换。各进制中对应的数字如下表：

    进制转换器 - 图1

    1. package com.structure;
    3. import org.junit.Assert;
    4. import org.junit.Test;
    6. public class NumberSystemChange {
    8.     /** 定义一个顺序栈结构：数组 + 栈顶指针 */
    9.     char[] data;
    10.     int s_top = -1;
    12.     public String numberSystemChange(String numberSrc,int srcSystem,int newSystem){
    13.         // 先转换为10进制
    14.         int tenNumber = toTenSystem(numberSrc,srcSystem);
    16.         // 通过计算对数，来求得大致的长度 以 newSystem为底，求numberSrc的对数然后加一
    17.         int length = (int) (Math.log(tenNumber)/Math.log(newSystem)) +1;
    18.         System.out.println("长度："+length);
    19.         data = new char[length];
    20.         toNewSystem(tenNumber,newSystem);
    21.         return toSystem();
    22.     }
    24.     private void toNewSystem(int tenNumber,int newSystem){
    25.         // 再求各位上的进制值，然后压入栈中（从低位开始计算）
    26.         while (tenNumber/newSystem>0) {
    27.             push(tenNumber%newSystem);
    28.             tenNumber/=newSystem;
    29.         }
    30.         push(tenNumber%newSystem);
    31.     }
    33.     private String toSystem(){
    34.         StringBuilder sb = new StringBuilder();
    35.         for(;s_top>-1;s_top--){
    36.             sb.append(data[s_top]);
    37.         }
    38.         return sb.toString();
    39.     }
    41.     /** 倒转 */
    42.     private void inverted(){
    43.         if(s_top<1){
    44.             return;
    45.         }
    46.         for(int i = 0;i<=s_top/2;i++){
    47.             char temp = data[i];
    48.             data[i] = data[s_top-i];
    49.             data[s_top-i] = temp;
    50.         }
    51.     }
    53.     private void push(int number){
    54.         if(number > 9){
    55.             data[++s_top] = (char)(number+55);
    56.         }else{
    57.             data[++s_top] = (char)(number+48);
    58.         }
    59.     }
    61.     /** 转换为10进制 */
    62.     public int toTenSystem(String numberSrc,int srcSystem){
    63.         char[] srcdata = numberSrc.toCharArray();
    64.         int length = srcdata.length;
    65.         int tenSystem_data = 0;
    66.         for(int i = length-1;i>=0;i--){
    67.             int temp ;
    68.             // 转换小写字母为10进制  a的ascII码对应97 要对应 10
    69.             if(srcdata[i] >= 97){
    70.                 temp = srcdata[i] - 87;
    71.             }
    72.             // 转换大写字母为10进制  A 要对应 10
    73.             else if(srcdata[i] >= 65 ){
    74.                 temp = srcdata[i]-55;
    76.             }
    77.             // 验证数字 1要对应1 1的ASCII码对应49
    78.             else{
    79.                 temp = srcdata[i]-48;
    80.             }
    81.             tenSystem_data += temp*Math.pow(srcSystem,length-1-i);
    82.         }
    83.         return tenSystem_data;
    84.     }
    86.     @Test
    87.     public void testAscII(){
    88.         char a = 'a';
    89.         char A = 'A';
    90.         char c = '1';
    91.         // 97
    92.         System.out.println((int)a);
    93.         // 65
    94.         System.out.println((int)A);
    95.         // 49
    96.         System.out.println((int)c);
    97.     }
    99.     @Test
    100.     public void testToten(){
    101.         NumberSystemChange nsc = new NumberSystemChange();
    102.         String number1 = "A";
    103.         int tenNumber1 = nsc.toTenSystem(number1,16);
    104.         Assert.assertEquals(tenNumber1,10);
    106.         number1 = "a";
    107.         tenNumber1 = nsc.toTenSystem(number1,16);
    108.         Assert.assertEquals(tenNumber1,10);
    110.         number1 = "1101";
    111.         tenNumber1 = nsc.toTenSystem(number1,2);
    112.         Assert.assertEquals(tenNumber1,13);
    113.     }
    115.     @Test
    116.     public void testSystemChange(){
    117.         NumberSystemChange nsc = new NumberSystemChange();
    118.         System.out.println(nsc.numberSystemChange("16",10,16));
    120.         NumberSystemChange nsc2 = new NumberSystemChange();
    121.         System.out.println(nsc2.numberSystemChange("11A1",12,16));
    123.         NumberSystemChange nsc3 = new NumberSystemChange();
    124.         System.out.println(nsc3.numberSystemChange("11A1",13,16));
    126.         NumberSystemChange nsc4 = new NumberSystemChange();
    127.         System.out.println(nsc4.numberSystemChange("AAAAEEEAAAEEE",16,10));
    129.     }
    131.     @Test
    132.     public void testlog(){
    133.         System.out.println((int) (Math.log(5)/Math.log(2)) +1);
    134.         System.out.println((int) (Math.log(8)/Math.log(10)) +1);
    135.         System.out.println((int) (Math.log(10)/Math.log(10)) +1);
    136.         System.out.println((int) (Math.log(16)/Math.log(10)) +1);
    137.         System.out.println((int) (Math.log(100)/Math.log(2)) +1);
    138.         System.out.println((int) (Math.log(1000)/Math.log(2)) +1);
    139.         System.out.println((int) (Math.log(1024)/Math.log(2)) +1);
    140.     }
    142. }