JavaSE_数组_十进制转其他进制

查表法

package uncommitted;
public class WeekTest {
public static void main(String[] args) {
// 查表法练习!
String week=method(41);
System.out.println(week);
}
public static String method(int i) {
// 用查表法根据数字查星期几!
// 增强健壮性检查
if(i>7||i<0){
return "wrong number";
}
String[] arr={"","星期1","星期2","星期3","星期4","星期5","星期6","星期天"};
return arr[i];
}
}


NumberTransfer1

package uncommitted;
public class NumberTransfer {
public static void main(String[] args) {
// 进制转换
toHex(60);
}
private static void toHex_4(int num) {
// 查表法3终极版本_2
if(num==0){
System.out.println("0");
return;
}
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] cha=new char[8];
//因为前面说过,int是四字节,
//1字节有8个二进制位,所以共计32个二进制位!
//转成16进制是4位一取,所以最多要取8次!
int pos=cha.length-1;//从数组最后面开始存!
while(num!=0){
int temp=num&15;//15就是二进制里1111
//根据索引查出十六进制中对应的字符!
cha[pos--]=arr[temp];
//四位一取
num=num>>>4;
}
//因为是pos--,所以下标多减了一次,要加回来!
pos=pos+1;
for (int i = pos; i <cha.length; i++) {//打印数组的有效位!
System.out.print(cha[i]);
}
//传入60,对应的结果是3C

}
private static void toHex_3(int num) {
// 查表法3终极版本_1
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] cha=new char[8];
//因为前面说过,int是四字节,1字节有8个二进制位,
//所以共计32个2进制位!转成16进制是4位一取,所以最多要取8次!
int pos=0;//操作数组就会乃至指针!
while(num!=0){
int temp=num&15;//15就是二进制里1111
cha[pos]=arr[temp];
pos++;
num=num>>>4;//四位一取
}
for (int i = pos-1; i >=0; i--) {//打印新数组的有效位,从后面往前打印!
System.out.print(cha[i]);
}
//传入60,对应的结果是3C
}

private static void toHex_2(int num) {
// 查表法2 需要改进
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] cha=new char[8];
//因为前面说过,int是四字节,1字节有8个二进制位,
//所以共计32个2进制位!转成16进制是4位一取,所以最多要取8次!
int pos=0;//操作数组就会乃至指针!
while(num!=0){
int temp=num&15;//15就是二进制里1111
cha[pos]=arr[temp];
pos++;
num=num>>>4;
}
for (int i = 0; i < pos; i++) {//打印数组的有效位!
System.out.print(cha[i]);
}
//传入60,对应的结果却是C3 还需要改进,逆序~
}

private static void toHex_1(int num) {
//查表法1
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
for (int i = 0; i < 8; i++) {
if(num==0){
break;
}
int temp=num&15;
System.out.print(arr[temp]);
//直接打印是:倒着的,要先存起来,再逆序输出~
num=num>>>4;
}
}
public static void toHex(int num){
// int是4个字节,1个字节有8个二进制位,共有32个二进制位
// 转16进制是4位一取,所以最多要移动8次
for (int i = 0; i < 8; i++) {
int temp=num&15;
if(temp==0)
continue;
if (temp>9) {
System.out.print((char)(temp-10+'A'));
} else {
System.out.print(temp);
}
num=num>>>4;
}
}
}

NumberTransfer2

package uncommitted;
public class NumberTransfer2 {
public static void main(String[] args) {
// 最牛X的进制转换函数
toHex(60);
toBinary(6);
toBinary('帅');
toOctal(60);
System.out.println(Integer.toBinaryString(-6));
System.out.println(Integer.toBinaryString('帅'));
System.out.println(Integer.toHexString(15));
System.out.println(Integer.toOctalString(60));
// int -6的二进制表示:1111-1111 1111-1111 1111-1111 1111-1010
}
public static void toHex(int num){
transfer(num, 16, 4);//16进制,要与上15,四位一移
}
public static void toBinary(int num){
transfer(num, 2, 1);//2进制,要与上1,一位一移
}
public static void toOctal(int num){
transfer(num, 8, 3);//8进制,要与上7,三位一移
}
private static void transfer(int num,int base,int offset) {
int source=num;
if(num==0){
System.out.println("0");
return;
}
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] cha=new char[32];//因为前面说过,int是四字节,1字节有
//8个二进制位,所以共计32个2进制位!
int pos=cha.length;//从数组最后面开始存!
while(num!=0){
int temp=num&(base-1);//15就是二进制里1111
cha[--pos]=arr[temp];
num=num>>>offset;
}
System.out.print(source+"对应的"+base+"进制数是: ");
for (int i = pos; i <cha.length; i++) {//打印数组的有效位!
System.out.print(cha[i]);
}
System.out.println();
}

private static void transfer_toHex(int num) {
if(num==0){
System.out.println("0");
return;
}
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] cha=new char[8];
//因为前面说过,int是四字节,1字节有8个二进制位,
//所以共计32个2进制位!转成16进制是4位一取,所以最多要取8次!
int pos=cha.length;//从数组最后面开始存!
while(num!=0){
int temp=num&15;//15就是二进制里1111
cha[--pos]=arr[temp];
num=num>>>4;
}
for (int i = pos; i <cha.length; i++) {//打印数组的有效位!
System.out.print(cha[i]);
}
}
}

NumberTransfer3

package uncommitted;
public class NumberTransfer3 {
public static void main(String[] args) {
transfer(60,8);
System.out.println(Integer.toBinaryString(-6));
System.out.println(Integer.toBinaryString('帅'));
System.out.println(Integer.toHexString(15));
System.out.println(Integer.toOctalString(60));
}
public static void transfer(int num,int base) {
int source=num;
if(num==0){
System.out.println("0");
return;
}
int offset;
switch (base) {
case 16://16进制,要与上15,四位一移
offset=4;
break;
case 8://8进制,要与上7,三位一移
offset=3;
break;
case 2://2进制,要与上1,一位一移
offset=1;
break;
default:
offset=1;
break;
}
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] cha=new char[32];
//因为前面说过,int是四字节,1字节有8个二进制位,
//所以共计32个2进制位!转成16进制是4位一取,所以最多要取8次!
int pos=cha.length;//从数组最后面开始存!
while(num!=0){
int temp=num&(base-1);//15就是二进制里1111
cha[--pos]=arr[temp];
num=num>>>offset;
}
System.out.print(source+"对应的"+base+"进制数是: ");
for (int i = pos; i <cha.length; i++) {//打印数组的有效位!
System.out.print(cha[i]);
}
System.out.println();
}
private static void transfer_toHex(int num) {
if(num==0){
System.out.println("0");
return;
}
char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] cha=new char[8];
//因为前面说过,int是四字节,1字节有8个二进制位,
//所以共计32个2进制位!转成16进制是4位一取,所以最多要取8次!
int pos=cha.length;//从数组最后面开始存!
while(num!=0){
int temp=num&15;//15就是二进制里1111
cha[--pos]=arr[temp];
num=num>>>4;
}
for (int i = pos; i <cha.length; i++) {//打印数组的有效位!
System.out.print(cha[i]);
}
}
}