Java_数组之进制转换

1，使用数组 
/*
进制转换 使用数组

定义一个功能，打印一个十进制数转对应16进制表现形式
*/

class ArrayTest4 
{
    public static void main(String[] args) 
    {
        toHex(60);
    }
    /*
    定义一个功能，打印一个十进制数转对应16进制表现形式

    0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
    0  1  2  3  4  5  6  7  8  9   A  B   C  D  E  F
    48 49 50 51 52 53 54 55 56 57 65 66 67 68 69 70




    什么时候使用数组？
    当同一类型的元素较多时，就是用数组这个容器对数据进行存储

    */
    public static void toHex(int num)
    {
        //定义一个char类型的数组，用于存储每次获取到的十六进制值
        char[] chs=new char[8];
        int pos =chs.length;
        while(num!=0)
        {
            pos--;
            int temp =num & 15;
            if (temp>9)
            {
                chs[pos]=(char)(temp-10+'A');
            }
            else
                chs[pos]=(char)(temp-0+'0');
            num = num >>> 4;
        }
        System.out.println("pos="+pos);
        //打印数组内容
        for (int x=pos;x<pos ;x++ )
        {
            System.out.print(chs[x]);
            //  u0000  空字符值
        }
    }
}




2，查表法
/*
进制转换  查表法

定义一个功能，打印一个十进制数转对应16进制表现形式
*/

class ArrayTest5
{
    public static void main(String[] args) 
    {
        toHex2(60);
    }
    /*
    定义一个功能，打印一个十进制数转对应16进制表现形式

    10进制    0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
    16进制    0  1  2  3  4  5  6  7  8  9   A  B   C  D  E  F
    num-10+'A'的动作不太容易想到
    我们可以换另一种想法
    我们发现，十六进制中一共有16个元素
    而且没通过&15获取的数字都在15之内，都有对应的十六进制元素
    
    而且元素对应的数组，正好有规律，而且符合了数组这种容器的特点---角标
    
    那么就可以将十六进制的元素都存储到数组中
    将每次&15的结果作为角标去查这个数组，就可以获取到十六进制的对应的元素；
    
    这就是传说中的查表法；
    
    什么时候使用查表法呢？
    当元素很多，而且这些元素与数字有对应关系，而且这些数字都有角标的规律
    这时，优先想到查表法。

二进制表 48 49 50 51 52 53 54 55 56 57 65 66 67 68 69 70




    什么时候使用数组？
    当同一类型的元素较多时，就是用数组这个容器对数据进行存储

    */


    public static void toHex2(int num)
    {
        //定义一个十六进制的元素的表
        char[] arr={'0','1','2','3',
                   '4','5','6','7',
                   '8','9','A','B',
                   'C','D','E','F'};
        
        //定义一个char类型的数组，用于存储每次获取到的十六进制值
        char[] chs=new char[8];
        int pos =chs.length;
        while(num!=0)
        {
            int temp =num & 15;
            chs[--pos]=arr[temp];
            num = num >>> 4;
        }
        System.out.println("pos="+pos);
        //打印数组内容
        for (int x=pos;x<chs.length ;x++ )
        {
            System.out.print(chs[x]);
            //  u0000  空字符值
        }
    }
}
 



3 三种进制转换

class ArrayTest6 
{
    public static void main(String[] args) 
    {
        toBin(6);
        toHex(26);
        toOctal(60);

        System.out.println(Integer.toBinaryString(-6));//开发写这个


        
    }
    //十进制--->二进制
    public static void toBin(int num)
    {
        trans(num,1,1);
    }

    //十进制--->八进制

    public static void toOctal(int num)
    {
        trans(num,7,3);
    }

    //十进制--->十六进制

    public static void toHex(int num)
    {
        trans(num,15,4);
    }

    public static void trans(int num,int base,int offset)
    {
        if (num=0)
        {
            System.out.println("0");
        }
        //定义一个十六进制的元素的表
        char[] arr={'0','1','2','3',
                   '4','5','6','7',
                   '8','9','A','B',
                   'C','D','E','F'};
        
        //定义一个char类型的数组，用于存储每次获取到的十六进制值
        char[] chs=new char[32];
        int pos =chs.length;
        while(num!=0)
        {
            int temp =num & base;
            chs[--pos]=arr[temp];
            num = num >>> offset;
        }
        System.out.println("pos="+pos);
        //打印数组内容
        for (int x=pos;x<chs.length ;x++ )
        {
            System.out.print(chs[x]);
            //  u0000  空字符值
        }
    }
}