VerySource

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
楼主: daike1017

一道java笔试题,以为很简单,结果半天都没写对!请大虾给出个正确解答

  [复制链接]

0

主题

1

帖子

2.00

积分

新手上路

Rank: 1

积分
2.00
发表于 2020-7-22 14:15:01 | 显示全部楼层
用C++实现了一下,感觉主要还是在零的处理上:
多个零相邻的情况有好几种,最重要的是要处理好这几个零在万位和亿位周围的情况。
回复

使用道具 举报

0

主题

3

帖子

4.00

积分

新手上路

Rank: 1

积分
4.00
发表于 2020-7-22 18:30:01 | 显示全部楼层
累~
不管那么多了~看你们那么辛苦~收下了
回复

使用道具 举报

1

主题

6

帖子

6.00

积分

新手上路

Rank: 1

积分
6.00
发表于 2020-7-22 21:45:01 | 显示全部楼层
其实实现的原理很简单,开始也想错了!
就是以八位为区分,超过八位后只不过增加了个亿罢了,在八位以前都是一样的,所以程序实现就是以八位为节点,先算出每个八位的数值,再不是第一个八位(从右边数),每增加一个八位就增加一个亿字就可以了!
具体实现如下:(以下是DELPHI实现)
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Buttons, ExtCtrls;

type
  TForm1 = class(TForm)
    LedtNum: TLabeledEdit;
    BitBtn1: TBitBtn;
    ComboBox1: TComboBox;
    memo: TMemo;
    procedure BitBtn1Click(Sender: TObject);
  private
    { Private declarations }
    procedure ConvertNumber(value: string);
  public
    { Public declarations }
  end;

const
  ROWMAX = 2; //最大的编号
  COLMAX = 3;

  U_NUM: array[0..9] of string = ('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖');
  U_LEV: array[0..ROWMAX, 0..COLMAX] of string = (('', '拾', '佰', '仟'),
                                                  ('', '', '', '萬'),
                                                  ('', '', '', '亿')
                                                 );
  {
   其实实现的原理很简单,开始也想错了!
   就是以八位为区分,超过八位后只不过增加了个亿罢了,在八位以前都是一样的,
   所以程序实现就是以八位为节点,先算出每个八位的数值,再不是第一个八位(从右边数),
   每增加一个八位就增加一个亿字就可以了!
具体实现如下:
  }


var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.BitBtn1Click(Sender: TObject);
begin
  ConvertNumber(LedtNum.Text);
end;

procedure TForm1.ConvertNumber(value: string);
var
  i, i2, i3: integer;
  tmpD, tmpM: integer;//整数部分及小数部分
  tmpStrs: array of string;
  tmpLst: TStringList;
  tmpStr, tmpStr1: string;

  function getStr(aValue: string): string;
  var
    tmpS2: string;
  begin
    result := '';
    i := length(aValue);
    while i>0 do
    begin
      i2 := length(aValue)-i+1;
      if aValue[i] <>'0' then
      begin
        tmpD := (i2-1) div 4;
        tmpM := (i2-1) mod 4;

        tmpS2 := '';
        if tmpD > 0 then
        begin
          if (tmpD>0) and (tmpD<=2) then
          begin
            if AnsiPos(U_LEV[tmpD, COLMAX], result)>0 then
              tmpS2 := U_LEV[0, tmpM]
            else
              tmpS2 := U_LEV[0, tmpM]+U_LEV[tmpD, COLMAX];
          end;
          result := aValue[i]+tmpS2+result;
        end else begin
          result := aValue[i]+U_LEV[tmpD, tmpM]+result;
        end;

      end else result := aValue[i]+result;

      dec(i);
    end;
  end;

begin
  tmpLst := TStringList.Create;
  try
    while (length(value) > 0) do
    begin
      if length(value)< 8 then
      begin
        tmpLst.Add(value);
        break;
      end else begin
        tmplst.Add(copy(value, length(value)-8+1, 8));
        value := copy(value, 1, length(value)-8);
      end;
    end;

    setLength(tmpStrs, tmpLst.Count);

    for i3 := 0 to tmpLst.Count-1 do
    begin
      tmpStrs[i3] := getStr(tmpLst.Strings[i3]);
      for i := 1 to i3 do
        tmpStrs[i3] := tmpStrs[i3]+'亿';
    end;

    for i3 := high(tmpStrs) downto low(tmpStrs) do
      tmpStr := tmpStr+tmpStrs[i3];

    while (AnsiPos('00', tmpStr)>0) do
    begin
      tmpStr := StringReplace(tmpStr, '00', '0', [rfReplaceAll]);
    end;

    tmpStr := StringReplace(tmpStr, '0亿', '亿', [rfReplaceAll]);

    tmpStr1 := tmpStr;
    for i3 := 1 to length(tmpStr) do
    begin
      if tmpStr[i3] in ['0'..'9'] then
      begin
        tmpStr1 := StringReplace(tmpStr1, tmpStr[i3], U_NUM[strToInt(tmpStr[i3])], [rfReplaceAll]);
      end;
    end;

    memo.Text := tmpStr1;
    combobox1.Items := tmpLst;

  finally
    tmpLst.Free;
  end;

end;

end.
回复

使用道具 举报

1

主题

6

帖子

6.00

积分

新手上路

Rank: 1

积分
6.00
发表于 2020-7-22 23:45:01 | 显示全部楼层
回1213ct:
你所说的不是主要问题,只要在处理时对输入的数字预处理一下就可以了!
回复

使用道具 举报

1

主题

6

帖子

6.00

积分

新手上路

Rank: 1

积分
6.00
发表于 2020-7-23 01:15:01 | 显示全部楼层
还有负数一样,预处理一下就可以了,呵呵!
程序中没有处理,请楼主自行处理吧!
回复

使用道具 举报

0

主题

1

帖子

2.00

积分

新手上路

Rank: 1

积分
2.00
发表于 2020-7-23 11:15:01 | 显示全部楼层
欢迎测试并指正错误!


public class DigitToChinese
{
        public static final String CHINESE_NUMBER="零壹贰叁肆伍陆柒捌玖";
        private static final String CARRY_UNITS[]={"","拾","佰","仟"};
        private static final String CARRY_UNITS_BIG[]={"","万","亿","兆","硕","京"};
        public String convert(String digit){
                return convert(toIntArray(digit));
               
        }

        private int [] toIntArray(String digit){
                char [] chars = digit.toCharArray();
                int [] toReturn = new int[digit.length()];
                for(int i=0;i<toReturn.length;i++){
                        toReturn[i] = (chars[i]-'0');
                        if(toReturn[i]<0||(chars[i]-'0')>9)
                                throw new NumberFormatException("数字字符串格式不正确");
                }
                return toReturn;
        }

        private String convert(int [] digit){
                StringBuffer out = new StringBuffer();
                int maxLen=CARRY_UNITS.length*(CARRY_UNITS_BIG.length-1);
                int offset = 0;
                boolean outZero = false;
                for(int i=0;i<maxLen&&(i+offset)<digit.length;i++){
                        int curDigit = digit.length-(i+offset+1);
                        if(i%CARRY_UNITS.length==0&&shouldOutBigUnit(digit,curDigit)) {
                                out.append(CARRY_UNITS_BIG[i/CARRY_UNITS.length]);
                                outZero=false;
                        }
                        if(digit[digit.length-(i+offset+1)]!=0){
                                out.append(CARRY_UNITS[i%CARRY_UNITS.length]);
                                out.append(CHINESE_NUMBER.charAt(digit[curDigit]));
                                outZero = true;
                        }else{
                                if(outZero){
                                        out.append(CHINESE_NUMBER.charAt(0));
                                        outZero=false;
                                }
                        }
                        if(i==maxLen-1&&digit.length>maxLen){
                                i=-1;
                                offset+=maxLen;
                                if(shouldOutBigUnit(digit,digit.length-(offset+1)))
                                        out.append(CARRY_UNITS_BIG[CARRY_UNITS_BIG.length-1]);
                        }
                }
                return reverse(out).toString();
        }
       
        public boolean shouldOutBigUnit(int [] digit,int p){
                for(int i=0;i<CARRY_UNITS.length&&(p-i)>=0;i++){
                        if(digit[p-i]!=0)
                                return true;
                }
                return false;
        }
       
        private StringBuffer reverse(StringBuffer sb){
                int len = sb.length();
                for(int i=0;i<len/2;i++){
                        char a = sb.charAt(i);
                        sb.setCharAt(i, sb.charAt(len-i-1));
                        sb.setCharAt(len-i-1, a);
                }
                return sb;
        }

        public static void main(String[] args) {
                DigitToChinese dtc = new DigitToChinese();
                dtc.convert("100564100515140122");
        }
}
回复

使用道具 举报

0

主题

11

帖子

10.00

积分

新手上路

Rank: 1

积分
10.00
发表于 2020-7-23 22:30:01 | 显示全部楼层
import java.util.Hashtable;
import java.util.Vector;
class Converter {
        // 中国的计数是四位一个单位的处理方式 例如 1 5487 4584 对应的单位是 亿 万 默认
        // 每四位的一个单元中,处理方式是一样的,当前能够处理的最大绝对值位数是UNIT_NAME.length * 4
        private final static String[] UNIT_NAME = {"亿", "萬", ""};
        private final static String[] SUB_UNIT_NAME = {"仟", "佰", "拾"};
        private final static String[] NUMBER_NAME = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        private static Hashtable<Integer, String> nums = new Hashtable<Integer, String>();
        static {
                for (int i = 0; i < NUMBER_NAME.length; i++) {
                        nums.put(i, NUMBER_NAME[i]);
                }
        }
        public static String convert(long value) throws TooBigNumberException {
                boolean isMinus = value < 0;
                if (isMinus) {
                        value = Math.abs(value);
                }
                String result = "";
                String valueString = String.valueOf(value);
                char[] chars = valueString.toCharArray();
                if (chars.length > UNIT_NAME.length * 4) {
                        throw new TooBigNumberException();
                } else {
                        // 当前可以处理,进行四段分割,每部分进行相同的处理,再添加各自段的单位
                        String[] segments = splitValue2Segments(chars, 4);
                        for (int i = 0; i < segments.length; i++) {
                                System.out.println("Segment " + i + " :" + segments[i]);
                        }
                        for (int i = 0, j = UNIT_NAME.length - segments.length; i < segments.length; i++) {
                                result += translate(segments[i]) + UNIT_NAME[j++];
                        }
                }
                if (isMinus) {
                        result = "负" + result;
                }
                return result;
        }
        /**
         * 将一个最多四个数的片段转换为自然语言表示方式 每一段由最多四为组成,最大数为9999
         *
         * @param value
         * @return
         */
        private static String translate(String value) {
                String result = "";
                int intValue = Integer.parseInt(value);
                int thousandBit = intValue / 1000;
                int hundredBit = (intValue - thousandBit * 1000) / 100;
                int tenthBit = (intValue - thousandBit * 1000 - hundredBit * 100) / 10;
                int oneBit = intValue - thousandBit * 1000 - hundredBit * 100 - tenthBit * 10;
                if (thousandBit > 0) {
                        result += nums.get(thousandBit) + "仟";
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                result += nums.get(tenthBit) + "拾";
                                result += nums.get(oneBit);
                        } else {
                                result += "零";
                                result += nums.get(tenthBit) + "拾";
                                result += nums.get(oneBit);
                        }
                } else {
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                result += nums.get(tenthBit) + "拾";
                                result += nums.get(oneBit);
                        } else {
                                if (tenthBit > 0) {
                                        result += nums.get(tenthBit) + "拾";
                                        result += nums.get(oneBit);
                                } else {
                                        result += nums.get(oneBit);
                                }
                        }
                }
                // System.out.println("Translate " + value + " To :" + result);
                return result;
        }
        public static void main(String[] args) {
                try {
                        System.out.println(convert(-3423555));
                } catch (TooBigNumberException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        /**
         * 把字符数组分割为指定段数
         *
         * @param chars
         * @return
         */
        public static String[] splitValue2Segments(char[] chars, int segments) {
                int count = 0;
                Vector<String> v = new Vector<String>();
                StringBuffer sb = new StringBuffer();
                for (int i = chars.length - 1; i >= 0; i--) {
                        if (count >= segments) {
                                v.add(sb.toString());
                                sb = new StringBuffer();
                                count = 0;
                        }
                        sb.insert(0, chars[i]);
                        count++;
                }
                if (sb.length() > 0) {
                        v.add(sb.toString());
                }
                String[] result = new String[v.size()];
                for (int i = v.size() - 1, j = 0; i >= 0; i--) {
                        result[j++] = v.elementAt(i);
                }
                return result;
        }
}
class TooBigNumberException extends Exception {
        public String toString() {
                return "数值过大,当前系统无法处理。";
        }
}
回复

使用道具 举报

0

主题

4

帖子

4.00

积分

新手上路

Rank: 1

积分
4.00
发表于 2020-7-24 08:45:01 | 显示全部楼层
还在讨论呀。其实主要就是有几点要注意:
1)一般情况下,正确地对应中文和数字的叫法,这主要是根据“拾佰仟万”以后应该再叫“拾佰仟”万,“亿”以后应该重复“拾佰仟万”亿来确定,所以,我们给出完整的单位序列应该是“拾佰仟万拾佰仟亿拾佰仟万”(由于整形的位数限制,到这里就够了);
2)出现0的情况,习惯上就应该有一个,而且只有一个零就够了,比如:1003应该叫做一千零三
3)当在万和亿以上的数字,如果出现0,应该加上万和亿的单位,如:10030叫一万零三叁拾,1003000040叫做一拾亿零叁佰万零四拾
4)特殊的,如果有1000000001应叫一拾亿零一,中间不要有万的情况出现
所以,个人觉得前面我给出的程序是对的,基本解决了这几个问题,而且程序也不太复杂,大家讨论。这了再贴一次:
        public static void main(String[] arg) throws IOException {
                String d="拾佰仟万拾佰仟亿拾佰仟万";
                String s="零壹贰叁肆伍陆柒捌玖";
                boolean zero=false;
                long value=1000000009;
                int count=0;
                String Cvalue="";
                while(value>0) {
                        int b=(int)(value % 10);
                        if(!zero || b!=0) {
                                String t="";
                                if(b!=0) {
                                        t=s.substring(b,b+1);
                                        if(count>0) t+=d.substring(count-1,count);
                                        zero=false;
                                }
                                else if(count!=4 && count!=8){
                                        t="零";
                                        zero=true;
                                }
                                Cvalue=t+Cvalue;
                        }
                        if(count==4 && !Cvalue.contains("万")) Cvalue="万"+Cvalue;
                        if(count==8 && !Cvalue.contains("亿")) Cvalue="亿"+Cvalue;
                        count++;
                        value/=10;
                }
                Cvalue=Cvalue.replaceFirst("亿万","亿");
                System.out.println(Cvalue);
        }
以下是几个结果:
1000000009:壹拾亿零玖
1023000009:壹拾亿贰仟叁佰万零玖
123000809:壹亿贰仟叁佰万零捌佰零玖
1230809:壹佰贰拾叁万零捌佰零玖
18009:壹万捌仟零玖
8092:捌仟零玖拾贰
回复

使用道具 举报

0

主题

11

帖子

10.00

积分

新手上路

Rank: 1

积分
10.00
发表于 2020-7-24 10:30:01 | 显示全部楼层
import java.util.Hashtable;
import java.util.Vector;
class Converter {
        // 中国的计数是四位一个单位的处理方式 例如 1 5487 4584 对应的单位是 亿 万 默认
        // 每四位的一个单元中,处理方式是一样的,当前能够处理的最大绝对值位数是UNIT_NAME.length * 4
        private final static String[] UNIT_NAME = {"亿", "萬", ""};
        private final static String[] SUB_UNIT_NAME = {"仟", "佰", "拾"};
        private final static String[] NUMBER_NAME = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        private static Hashtable<Integer, String> nums = new Hashtable<Integer, String>();
        static {
                for (int i = 0; i < NUMBER_NAME.length; i++) {
                        nums.put(i, NUMBER_NAME[i]);
                }
        }
        public static String convert(long value) throws TooBigNumberException {
                boolean isMinus = value < 0;
                if (isMinus) {
                        value = Math.abs(value);
                }
                String result = "";
                String valueString = String.valueOf(value);
                char[] chars = valueString.toCharArray();
                if (chars.length > UNIT_NAME.length * 4) {
                        throw new TooBigNumberException();
                } else {
                        // 当前可以处理,进行四段分割,每部分进行相同的处理,再添加各自段的单位
                        String[] segments = splitValue2Segments(chars, 4);
                        for (int i = 0, j = UNIT_NAME.length - segments.length; i < segments.length; i++) {
                                if (segments.length > 1 && i == segments.length - 1) {
                                        result += "零";
                                }
                                result += translate(segments[i]) + UNIT_NAME[j++];
                        }
                }
                if (isMinus) {
                        result = "负" + result;
                }
                return result;
        }
        /**
         * 将一个最多四个数的片段转换为自然语言表示方式 每一段由最多四为组成,最大数为9999
         *
         * @param value
         * @return
         */
        private static String translate(String value) {
                String result = "";
                int intValue = Integer.parseInt(value);
                int thousandBit = intValue / 1000;
                int hundredBit = (intValue - thousandBit * 1000) / 100;
                int tenthBit = (intValue - thousandBit * 1000 - hundredBit * 100) / 10;
                int oneBit = intValue - thousandBit * 1000 - hundredBit * 100 - tenthBit * 10;
                if (thousandBit > 0) {
                        result += nums.get(thousandBit) + "仟";
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                if (tenthBit > 0) {
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += "零";
                                                result += nums.get(oneBit);
                                        }
                                }
                        } else {
                                if (tenthBit > 0) {
                                        result += "零";
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }

                                }

                        }
                } else {
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                if (tenthBit > 0) {
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += "零";
                                                result += nums.get(oneBit);
                                        }
                                }
                        } else {
                                if (tenthBit > 0) {
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                }
                        }
                }
                // System.out.println("Translating from " + value + " To :" + result);
                return result;
        }
        public static void main(String[] args) {
                try {
                        System.out.println(convert(10000004));
                } catch (TooBigNumberException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        /**
         * 把字符数组分割为指定段数
         *
         * @param chars
         * @return
         */
        public static String[] splitValue2Segments(char[] chars, int segments) {
                int count = 0;
                Vector<String> v = new Vector<String>();
                StringBuffer sb = new StringBuffer();
                for (int i = chars.length - 1; i >= 0; i--) {
                        if (count >= segments) {
                                v.add(sb.toString());
                                sb = new StringBuffer();
                                count = 0;
                        }
                        sb.insert(0, chars[i]);
                        count++;
                }
                if (sb.length() > 0) {
                        v.add(sb.toString());
                }
                String[] result = new String[v.size()];
                for (int i = v.size() - 1, j = 0; i >= 0; i--) {
                        result[j++] = v.elementAt(i);
                }
                return result;
        }
}
class TooBigNumberException extends Exception {
        public String toString() {
                return "数值过大,当前系统无法处理。";
        }
}
回复

使用道具 举报

0

主题

11

帖子

10.00

积分

新手上路

Rank: 1

积分
10.00
发表于 2020-7-24 12:30:01 | 显示全部楼层
import java.util.Hashtable;
import java.util.Vector;
class Converter {
        // 中国的计数是四位一个单位的处理方式 例如 1 5487 4584 对应的单位是 亿 万 默认
        // 每四位的一个单元中,处理方式是一样的,当前能够处理的最大绝对值位数是UNIT_NAME.length * 4
        private final static String[] UNIT_NAME = {"亿", "萬", ""};
        private final static String[] SUB_UNIT_NAME = {"仟", "佰", "拾"};
        private final static String[] NUMBER_NAME = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        private static Hashtable<Integer, String> nums = new Hashtable<Integer, String>();
        static {
                for (int i = 0; i < NUMBER_NAME.length; i++) {
                        nums.put(i, NUMBER_NAME[i]);
                }
        }
        public static String convert(long value) throws TooBigNumberException {
                boolean isMinus = value < 0;
                if (isMinus) {
                        value = Math.abs(value);
                }
                String result = "";
                String valueString = String.valueOf(value);
                char[] chars = valueString.toCharArray();
                if (chars.length > UNIT_NAME.length * 4) {
                        throw new TooBigNumberException();
                } else {
                        // 当前可以处理,进行四段分割,每部分进行相同的处理,再添加各自段的单位
                        String[] segments = splitValue2Segments(chars, 4);
                        for (int i = 0, j = UNIT_NAME.length - segments.length; i < segments.length; i++) {
                                if (segments.length > 1 && i == segments.length - 1) {
                                        if (Integer.parseInt(segments[i]) < 100) {
                                                result += "零";
                                        }
                                }
                                result += translate(segments[i]) + UNIT_NAME[j++];
                        }
                }
                if (isMinus) {
                        result = "负" + result;
                }
                return result;
        }
        /**
         * 将一个最多四个数的片段转换为自然语言表示方式 每一段由最多四为组成,最大数为9999
         *
         * @param value
         * @return
         */
        private static String translate(String value) {
                String result = "";
                int intValue = Integer.parseInt(value);
                int thousandBit = intValue / 1000;
                int hundredBit = (intValue - thousandBit * 1000) / 100;
                int tenthBit = (intValue - thousandBit * 1000 - hundredBit * 100) / 10;
                int oneBit = intValue - thousandBit * 1000 - hundredBit * 100 - tenthBit * 10;
                if (thousandBit > 0) {
                        result += nums.get(thousandBit) + "仟";
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                if (tenthBit > 0) {
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += "零";
                                                result += nums.get(oneBit);
                                        }
                                }
                        } else {
                                if (tenthBit > 0) {
                                        result += "零";
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }

                                }

                        }
                } else {
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                if (tenthBit > 0) {
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += "零";
                                                result += nums.get(oneBit);
                                        }
                                }
                        } else {
                                if (tenthBit > 0) {
                                        result += nums.get(tenthBit) + "拾";
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                }
                        }
                }
                // System.out.println("Translating from " + value + " To :" + result);
                return result;
        }
        public static void main(String[] args) {
                try {
                        System.out.println(convert(8888683));
                } catch (TooBigNumberException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        /**
         * 把字符数组分割为指定段数
         *
         * @param chars
         * @return
         */
        public static String[] splitValue2Segments(char[] chars, int segments) {
                int count = 0;
                Vector<String> v = new Vector<String>();
                StringBuffer sb = new StringBuffer();
                for (int i = chars.length - 1; i >= 0; i--) {
                        if (count >= segments) {
                                v.add(sb.toString());
                                sb = new StringBuffer();
                                count = 0;
                        }
                        sb.insert(0, chars[i]);
                        count++;
                }
                if (sb.length() > 0) {
                        v.add(sb.toString());
                }
                String[] result = new String[v.size()];
                for (int i = v.size() - 1, j = 0; i >= 0; i--) {
                        result[j++] = v.elementAt(i);
                        System.out.println(v.elementAt(i));
                }
                return result;
        }
}
class TooBigNumberException extends Exception {
        public String toString() {
                return "数值过大,当前系统无法处理。";
        }
}
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|CopyRight © 2008-2023|verysource.com ( 京ICP备17048824号-1 )

快速回复 返回顶部 返回列表