【阳哥专栏】技术分活动第8期 - 黑马程序员技术交流社区

import java.util.*;
class Transition
{
public static void main(String[] args)
{
//x:表示初始的进制数。y:表示转换成的进制数。
int x, y;
int num; //num：表示用户输入的数据转换为int类型的值。
boolean flag = true; // flag:用于控制用户是否要进行下一轮数据的转换。
while(flag)
{
flag = false;
System.out.println("请输入您输入的数据是几进制的：如：2,8,10或是16：");
x = input();
x = judge(x);
System.out.println("请输入您想要转换进制的数：");
num = input(x);
System.out.println("请输入您想要将数据转换成几进制：如：2,8,10或16");
y = input();
y = judge(y);
zhuanHuan(num,x,y);
System.out.println("您是否想进行下一次数据转换？是请输入:yes,否则输入:no");
flag = goOn();
}
}
//goOn():根据用户输入yes或no改变flag的值。
public static boolean goOn()
{
Scanner s = new Scanner(System.in);
String str = s.next();
if(str.equals("yes")) return true;
else if(str.equals("no")) return false;
else
{
System.out.println("您输入的格式不正确，请输入yes或者是no。");
goOn();
}
}
//input():用于接收用户输入的进制数。
public static int input()
{
Scanner s = new Scanner(System.in);
String str = s.next();
int temp = Integer.parseInt(str);
return temp;
}
//judge():用于判断进制输入是否正确。
public static int judge(int n)
{
switch(n)
{
case 2: return n;
case 8: return n;
case 10: return n;
case 16: return n;
default:
{
System.out.println("您输入的进制不正确，您只能输入2,8,10或者16。请重新输入：");
n = input();
n = judge(n);
return n;
}
}
}
//input(int x):用于接收用户输入的数据,并将它转换为十进制数。
public static int input(int x)
{
Scanner s = new Scanner(System.in);
String str = s.next();
int temp = 0;
try
{
temp = Integer.parseInt(str,x);
}
catch (NumberFormatException e)
{
System.out.println("您输入的数据格式不正确，请输入正确的数据格式：");
temp = input(x);
}
return temp;
}
//zhuanHuan方法：根据要转换成的进制数去调用相应的转换函数。
public static void zhuanHuan(int num, int x, int y)
{
switch(y)
{
case 2: toBin(num,x); break;
case 8: toOct(num,x); break;
case 10:
{
System.out.println(num+"的十进制形式是：" +num);
break;
}
case 16: toHex(num,x); break;
}
}
//下面这三个方法分别转换成相应的进制。
public static void toBin(int num,int x)
{
System.out.print("您输入的"+x+"进制数的二进制形式是：");
trans(num,1,1);
}
public static void toOct(int num,int x)
{
System.out.print("您输入的"+x+"进制数的八进制形式是：");
trans(num,7,3);
}
public static void toHex(int num,int x)
{
System.out.print("您输入的"+x+"进制数的十六进制形式是：");
trans(num,15,4);
}
//trans()：上边三个进制转换函数调用这个方法就可以完成进制的转换。
public static void trans(int num, int base, int offset)
{
if(num == 0)
{
System.out.println(0);
return;
}
char[] chs = {'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while(num != 0)
{
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
for(int i = pos; i < arr.length; i++)
{
System.out.print(arr[i]);
}
System.out.println();
System.out.println();
}
}

复制代码

package cn.itcast.main;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* @see 请用java编写代码实现如下功能：①让用户选择输入的数据格式（二进制、八进制、十进制、十六进制，输入错误时请给予友好提示）②让用户输入数据③让用户选择要转换成的进制单位④输出结果，并重复第①步。
* 使用六个步骤完成:
* 1.让用户选择输入的数据格式（二进制、八进制、十进制、十六进制，输入错误时请给予友好提示）
* 2.让用户输入数据
* 3.让用户选择要转换成的进制单位
* 4.进制转换
* 5.输出结果
* 6.循环
* @author weid
*
*/
public class Main
{
/*
* 主函数:循环输入
*/
//使用公用静态输入流
static BufferedReader sysin=new BufferedReader(new InputStreamReader(System.in));
//主函数
public static void main(String[] args) throws IOException
{
//循环
while(true)
{
convertNum();
}
}
//实现基本转化步骤
private static void convertNum() throws IOException
{
//让用户选择输入的数据格式（二进制、八进制、十进制、十六进制，输入错误时请给予友好提示）
int radixin=chooseRadix("输入");
//让用户输入数据
int num=inputNum(radixin);
//让用户选择要转换成的进制单位
int radixout=chooseRadix("输出");
//进制转换
String ans=convert(num,radixout);
//输出结果
System.out.println("结果为: "+ans);
System.out.println();
}
//选择进制
private static int chooseRadix(String form) throws IOException
{
String s;
System.out.println("请选择"+form+"数据格式:1.二进制;2.八进制;3.十进制;4.十六进制");
s=sysin.readLine();
while(!(s.equals("1")||s.equals("2")||s.equals("3")||s.equals("4")))
{
System.out.println("您输入的有误:请输入1,2,3,4中的一个");
System.out.println("请选择"+form+"数据格式:1.二进制;2.八进制;3.十进制;4.十六进制");
s=sysin.readLine();
}
switch (Integer.parseInt(s))
{
case 1:
return 2;
case 2:
return 8;
case 3:
return 10;
case 4:
return 16;
default:
return chooseRadix(s);
}
}
//输入要转换的数字
private static int inputNum(int radix) throws IOException
{
String s;
int num=0;
boolean flag=true;
System.out.println("请输入要转换的数字");
while(flag)
{
try
{
s=sysin.readLine();
num=Integer.parseInt(s, radix);
flag=false;
} catch (Exception e)
{
System.out.println("输入有误请重新输入:");// TODO: handle exception
}
}
return num;
}
//进制转换
private static String convert(int num, int radixout)
{
switch(radixout)
{
case 2:
return Integer.toBinaryString(num);
case 8:
return Integer.toOctalString(num);
case 10:
return Integer.toString(num);
case 16:
return Integer.toHexString(num);
default:
return null;
}
}
}

复制代码

import java.util.Scanner;
public class AryConvert {
public static void main(String... args) {
// test();
// testBig();
AryConvertor convertor = new AryConvertor();
convertor.setSupportBigNumber(true);// 支持大数转换
Scanner scanner = new Scanner(System.in);
while (true) {
System.out
.println("enter source format: b(inary), o(ctonary), d(ecimal), h(exadecimal), or ex(it) to exit.");
int sourceFormat = getFormat(scanner);
System.out
.println("enter source number you want to convert, or ex(it) to exit.");
String number = getNumber(scanner);
System.out
.println("enter destination format: b(inary), o(ctonary), d(ecimal), h(exadecimal), or ex(it) to exit.");
int destFormat = getFormat(scanner);
convertor.setM(sourceFormat);
convertor.setN(destFormat);
try {
System.out.println("the converted number: "
+ convertor.convertToString(number));
System.out.println();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
private static String getNumber(Scanner scanner) {
String number = "";
while (scanner.hasNextLine()) {
number = scanner.nextLine();
if("ex".compareToIgnoreCase(number) == 0)
System.exit(0);
if(!number.matches("[0-9a-f-A-Z]+"))
System.out.println("you entered a wrong number. please input again.");
else {
return number;
}
}
return number;
}
private static int getFormat(Scanner scanner) {
int format = 0;
while (scanner.hasNextLine()) {
String enter = scanner.nextLine();
if("b".compareToIgnoreCase(enter) == 0)
return 2;
else if("o".compareToIgnoreCase(enter) == 0)
return 8;
else if("d".compareToIgnoreCase(enter) == 0)
return 10;
else if("h".compareToIgnoreCase(enter) == 0)
return 16;
else if ("ex".compareToIgnoreCase(enter) == 0)
System.exit(0);
else
System.out.println("you entered a wrong format. please input again.");
}
return format;
}
private static void test() {
AryConvertor convertor = new AryConvertor();
// 转二进制测试
System.out.println("10->2:" + "5845->" + convertor.convertToString("5845"));// 10->2
convertor.setM(8);
System.out.println("8->2:" + "5745->" + convertor.convertToString("5745"));// 8->2
convertor.setM(16);
System.out.println("16->2:" + "12ef3a->" + convertor.convertToString("12ef3a"));// 16->2
// 转八进制
convertor.setN(8);
System.out.println("10->8:" + "5845->" + convertor.convertToString("5845"));// 10->8
convertor.setM(2);
System.out.println("2->8:" + "1011011010101->" + convertor.convertToString("1011011010101"));// 2->8
convertor.setM(16);
System.out.println("16->8:" + "12ef3a->" + convertor.convertToString("12ef3a"));// 16->8
// 转十进制
convertor.setN(10);
convertor.setM(8);
System.out.println("8->10:" + "13325->" + convertor.convertToString("13325"));// 8->10
convertor.setM(2);
System.out.println("2->10:" + "1011011010101->" + convertor.convertToString("1011011010101"));// 2->10
convertor.setM(16);
System.out.println("16->10:" + "12ef3a->" + convertor.convertToString("12ef3a"));// 16->10
// 转十六进制
convertor.setN(16);
convertor.setM(8);
System.out.println("8->16:" + "13375->" + convertor.convertToString("13375"));// 8->16
convertor.setM(2);
System.out.println("2->16:" + "1011011010101->" + convertor.convertToString("1011011010101"));// 2->16
convertor.setM(10);
System.out.println("10->16:" + "1240890->" + convertor.convertToString("1240890"));// 10->16
System.out.println();
}
private static void testBig(){
AryConvertor convertor = new AryConvertor();
convertor.setSupportBigNumber(true);
// 转二进制测试
System.out.println("10->2:" + "5845->" + convertor.convertToString("5845"));// 10->2
convertor.setM(8);
System.out.println("8->2:" + "5745->" + convertor.convertToString("5745"));// 8->2
convertor.setM(16);
System.out.println("16->2:" + "12ef3a->" + convertor.convertToString("12ef3a"));// 16->2
// 转八进制
convertor.setN(8);
System.out.println("10->8:" + "5845->" + convertor.convertToString("5845"));// 10->8
convertor.setM(2);
System.out.println("2->8:" + "1011011010101->" + convertor.convertToString("1011011010101"));// 2->8
convertor.setM(16);
System.out.println("16->8:" + "12ef3a->" + convertor.convertToString("12ef3a"));// 16->8
// 转十进制
convertor.setN(10);
convertor.setM(8);
System.out.println("8->10:" + "13325->" + convertor.convertToString("13325"));// 8->10
convertor.setM(2);
System.out.println("2->10:" + "1011011010101->" + convertor.convertToString("1011011010101"));// 2->10
convertor.setM(16);
System.out.println("16->10:" + "12ef3a->" + convertor.convertToString("12ef3a"));// 16->10
// 转十六进制
convertor.setN(16);
convertor.setM(8);
System.out.println("8->16:" + "13375->" + convertor.convertToString("13375"));// 8->16
convertor.setM(2);
System.out.println("2->16:" + "1011011010101->" + convertor.convertToString("1011011010101"));// 2->16
convertor.setM(10);
System.out.println("10->16:" + "1240890->" + convertor.convertToString("1240890"));// 10->16
System.out.println();
}
}
class AryConvertor{
private int M = 10; // 原始数据进制，默认为十进制
private int N = 2; // 转换数据进制，默认为二进制
private boolean supportBigNumber = false;//是否支持大数,默认不支持
private String bigNumberQuotient; // 转换大数时临时存储的商数
public void setM(int M){ this.M = M;}
public void setN(int N){ this.N = N;}
public void setSupportBigNumber(boolean supportBigNumber){this.supportBigNumber = supportBigNumber;}
public AryConvertor(){}
public AryConvertor(int M, int N){
this.M = M;
this.N = N;
}
public String convertToString(String number) {
boolean legal = true;
if(this.M == 2){
legal = number.matches("[0-1]+");
}else if (this.M == 8) {
legal = number.matches("[0-7]+");
}else if (this.M == 10) {
legal = number.matches("[0-9]+");
}else if (this.M == 16) {
legal = number.matches("[0-9a-fA-F]+");
}
if(!legal)
throw new NumberFormatException("argument number: " + number + " is Illegal");
if (this.M == this.N) // 如果进制相同，不转换直接返回
return number;
return supportBigNumber ? convertBig(number) : convert(number);
}
/**
* 进制转换，不支持大数
* @param number
* @return
*/
private String convert(String number) {
int tmp = 0;
for (int i = 0; i < number.length(); i++) {
tmp = tmp * M + getNumFromChar(number.charAt(i));
}
int remainder = 0;// 余数
int quotient = tmp; // 商
StringBuffer result = new StringBuffer();
do {
remainder = quotient % N;
result.insert(0, getCharFromNum(remainder));
quotient = quotient / N;
} while (quotient != 0);
return result.toString();
}
/**
* 进制转换，支持大数
* @param bigNum
* @return
*/
private String convertBig(String bigNum) {
bigNumberQuotient = bigNum;
StringBuffer result = new StringBuffer();
while (bigNumberQuotient.length() > 0) {
int remainder = getRemainderFromBigNum(bigNumberQuotient);
result.insert(0, getCharFromNum(remainder));
}
return result.toString();
}
/**
* 从一个大数字符串中获取除以N的余数
* @param bigNum
* @return
*/
private int getRemainderFromBigNum(String bigNum) {
// StringBuffer dividend = new StringBuffer(bigNum);// 字符串形式的被除数
StringBuffer quotient = new StringBuffer();
int remainder = 0;
for (int i = 0; i < bigNum.length(); i++) {
int tmp = getNumFromChar(bigNum.charAt(i));
remainder = remainder * M + tmp;
quotient.append(getCharFromNum(remainder / N));
remainder = remainder % N;
}
while (quotient.length() > 0 && quotient.charAt(0) == '0') {
quotient.deleteCharAt(0);
}
bigNumberQuotient = quotient.toString();
return remainder;
}
/***
* 根据传进来的字符串1-9，a-z，A-Z转换成对应的十进制数
* @param cnum
* @return
*/
private static int getNumFromChar(char cnum) {
if(cnum >= '0' && cnum <= '9')
return cnum - '0';
else if (cnum >= 'a' && cnum <= 'f')
return cnum - 'a' + 10;
else if (cnum >= 'A' && cnum <= 'F')
return cnum - 'A' + 10;
else
throw new NumberFormatException("argument cnum: " + cnum + " is Illegal");
}
/**
* 根据传进来的数字0-15转换成相应的字符表示
* @param num
* @return
*/
private static char getCharFromNum(int num) {
if(num >= 0 && num <= 9)
return (char)(num + '0');
else if (num >= 10 && num <= 15)
return (char)(num - 10 + 'a');
else
throw new IllegalArgumentException("argument num: " + num + " is Illegal");
}
}

复制代码

package com.itheima;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Test2 extends JFrame implements ActionListener {
JTextField txtDec;
JTextField txtBin;
JTextField txtOct;
JTextField txtHex;
public Test2(){
super("十进制整数转换");
txtDec = new JTextField(15);
txtBin = new JTextField(15);
txtOct = new JTextField(15);
txtHex = new JTextField(15);
txtBin.setEditable(false);
txtOct.setEditable(false);
txtHex.setEditable(false);
this.setLayout(new FlowLayout());
this.add(new JLabel(" 十进制"));
this.add(txtDec);
this.add(new JLabel(" 二进制"));
this.add(txtBin);
this.add(new JLabel(" 八进制"));
this.add(txtOct);
this.add(new JLabel("十六进制"));
this.add(txtHex);
txtDec.addActionListener(this);
this.setSize(250, 150);
this.setResizable(false);
this.setVisible(true);
}
public static void main(String[] args) {
new Test2();
}
public void actionPerformed(ActionEvent e) {
JTextField txt = (JTextField)e.getSource();
if(txt.getText() == null || txt.getText().trim().equals("")){
JOptionPane.showMessageDialog(this, "十进制数不能为空");
return;
}
int num;
try{
num = Integer.parseInt(txt.getText());
if(num < 0){
num *= -1;
txtBin.setText("-" + Convert.format(num, 2));
txtOct.setText("-" + Convert.format(num, 8));
txtHex.setText("-" + Convert.format(num, 16));
}
else{
txtBin.setText(Convert.format(num, 2));
txtOct.setText(Convert.format(num, 8));
txtHex.setText(Convert.format(num, 16));
}
}
catch(Exception ex){
JOptionPane.showMessageDialog(this, "十进制数错误");
return;
}
}
}
class Convert{
private static String[] bins = {"0", "1"};
private static String[] octs = {"0", "1", "2", "3", "4", "5", "6", "7"};
private static String[] hexs = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
public static String format(int num, int r){
StringBuffer buff = new StringBuffer();
if(r == 2){
while(num > 0){
buff.append(bins[num%r]);
num /= r;
}
}
else if(r == 8){
while(num > 0){
buff.append(octs[num%r]);
num /= r;
}
}
else if(r == 16){
while(num > 0){
buff.append(hexs[num%r]);
num /= r;
}
}
buff.reverse();
return buff.toString();
}
}

复制代码