| |

VerySource

 Forgot password?
 Register
Search
Author: daike1017

A java written question, thought it was very simple, but I didn't write it right for a long time! Please prawn give a c

  [Copy link]

0

Threads

1

Posts

2.00

Credits

Newbie

Rank: 1

Credits
2.00

 China

Post time: 2020-7-22 14:15:01
| Show all posts
I realized it in C++, and I feel that it is mainly about zero processing:
There are several situations where multiple zeros are adjacent to each other, and the most important thing is to handle the situation where these zeros are around ten thousand and billion.
Reply

Use magic Report

0

Threads

3

Posts

4.00

Credits

Newbie

Rank: 1

Credits
4.00

 China

Post time: 2020-7-22 18:30:01
| Show all posts
Tired~
No matter so much~ Seeing you guys worked so hard~ Accept it
Reply

Use magic Report

1

Threads

6

Posts

6.00

Credits

Newbie

Rank: 1

Credits
6.00

 China

Post time: 2020-7-22 21:45:01
| Show all posts
In fact, the principle of realization is very simple, and I was wrong at the beginning!
It is distinguished by eight bits. After more than eight bits, it will only increase by 100 million. It is the same before eight bits. Therefore, the program implementation is to use eight bits as the node, and calculate the value of each eight bits first. An eight-digit number (counting from the right), each additional eight-digit number adds one billion words!
The specific implementation is as follows: (The following is the implementation of 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; //The largest number
  COLMAX = 3;

  U_NUM: array[0..9] of string = ('zero','一','贰','三', '4','Wu','Lu','柒','捌', '玖');
  U_LEV: array[0..ROWMAX, 0..COLMAX] of string = (('','lift','百','千'),
                                                  ('','','', '10,000'),
                                                  ('','','','billion')
                                                 );
  {
   In fact, the principle of realization is very simple, and I was wrong at the beginning!
   It is divided into eight digits. After surpassing eight digits, it only adds one hundred million. It is the same before eight digits.
   So the program implementation is to use eight bits as the node, first calculate the value of each eight bits, and then not the first eight bits (counting from the right),
   For every eight bits added, one hundred million words will be added!
The specific implementation is as follows:
  }


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;//Integer part and decimal part
  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]+'billion';
    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 billion', '100 million', [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.
Reply

Use magic Report

1

Threads

6

Posts

6.00

Credits

Newbie

Rank: 1

Credits
6.00

 China

Post time: 2020-7-22 23:45:01
| Show all posts
Back to 3nanase3:
What you said is not the main problem, just preprocess the input numbers while processing it!
Reply

Use magic Report

1

Threads

6

Posts

6.00

Credits

Newbie

Rank: 1

Credits
6.00

 China

Post time: 2020-7-23 01:15:01
| Show all posts
There are also negative numbers, just preprocess it, ha ha!
There is no processing in the program, please do it yourself!
Reply

Use magic Report

0

Threads

1

Posts

2.00

Credits

Newbie

Rank: 1

Credits
2.00

 China

Post time: 2020-7-23 11:15:01
| Show all posts
Welcome to test and correct mistakes!


public class DigitToChinese
{
public static final String CHINESE_NUMBER="Zero One Two Three Four Wu Lu Qi Ba Ji";
private static final String CARRY_UNITS[]={"","take","百","千"};
private static final String CARRY_UNITS_BIG[]={"","10,000","100 million","Mega","Master","京"};
public String convert(String digit){
return convert(toIntArray(digit));
To
}

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("The format of the number string is incorrect");
}
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();
}
To
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;
}
To
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");
}
}
Reply

Use magic Report

0

Threads

11

Posts

10.00

Credits

Newbie

Rank: 1

Credits
10.00

 China

Post time: 2020-7-23 22:30:01
| Show all posts
import java.util.Hashtable;
import java.util.Vector;
class Converter {
// The count in China is a unit of four digits. For example, 1 5487 4584 corresponds to a unit of hundreds of millions. Default
// In each unit of four digits, the processing method is the same, the maximum absolute value digits that can be processed currently is UNIT_NAME.length * 4
private final static String[] UNIT_NAME = {"100 million", "10,000", ""};
private final static String[] SUB_UNIT_NAME = {"千", "百", "take"};
private final static String[] NUMBER_NAME = {"zero", "一", "贰", "三", "四", "Wu", "Lu", "柒", "捌", "玖"};
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 {
// Currently it can be processed, divided into four sections, each section is processed the same, and then the unit of each section is added
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 = "negative" + result;
}
return result;
}
/**
* Convert a segment of up to four numbers into natural language representation. Each segment consists of up to four elements, and the maximum number is 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) + "lift";
result += nums.get(oneBit);
} else {
result += "zero";
result += nums.get(tenthBit) + "lift";
result += nums.get(oneBit);
}
} else {
if (hundredBit> 0) {
result += nums.get(hundredBit) + "百";
result += nums.get(tenthBit) + "lift";
result += nums.get(oneBit);
} else {
if (tenthBit> 0) {
result += nums.get(tenthBit) + "lift";
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();
}
}
/**
* Divide the character array into the specified number of segments
*
* @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 "The value is too large and the current system cannot handle it.";
}
}
Reply

Use magic Report

0

Threads

4

Posts

4.00

Credits

Newbie

Rank: 1

Credits
4.00

 China

Post time: 2020-7-24 08:45:01
| Show all posts
Still discussing it. In fact, there are several points to note:
1) Under normal circumstances, correctly correspond to the name of Chinese and numbers. This is mainly based on the basis that "one hundred ten million" should be called "one hundred thousand" in the future, and "billion" should be repeated "one hundred thousand trillion" in the future. To determine, so the complete unit sequence we give should be "One hundred ten million ten hundred million ten hundred million ten hundred million ten hundred million" (due to the limitation of the number of digits of shaping, that is enough here);
2) In the case of 0, there should be one in habit, and only one zero is enough, for example: 1003 should be called one thousand and three
3) When the number is above trillions and billions, if 0 appears, the units of trillions and billions should be added. For example, 10030 is ten thousand and three hundred and 1003000040 is one hundred and three million and four.
4) Specially, if there are 1000000001 responses to one million and one hundred million, there should be no situation of ten thousand in between.
Therefore, I personally feel that the program I gave above is correct, and basically solves these problems, and the program is not too complicated, let’s discuss it. Post this again:
public static void main(String[] arg) throws IOException {
String d="Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands and Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands of Thousands in
String s="Zero One Two Three Four Wu Lu Qi Ba Ji";
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";
zero=true;
}
Cvalue=t+Cvalue;
}
if(count==4&&!Cvalue.contains("万")) Cvalue="万"+Cvalue;
if(count==8&&!Cvalue.contains("billion")) Cvalue="billion"+Cvalue;
count++;
value/=10;
}
Cvalue=Cvalue.replaceFirst("Billion","Billion");
System.out.println(Cvalue);
}
Here are a few results:
1000000009: One hundred million ninety nine
1023000009: One hundred million two thousand three million nine
123000809: One hundred million, twenty-three million, one hundred and ninety-nine
1230809: One hundred two hundred and thirty thousand one hundred and one hundred and ninety nine
18009: Ten Thousand Five Thousand Nine Nine
8092: One Thousand One Pickup Two
Reply

Use magic Report

0

Threads

11

Posts

10.00

Credits

Newbie

Rank: 1

Credits
10.00

 China

Post time: 2020-7-24 10:30:01
| Show all posts
import java.util.Hashtable;
import java.util.Vector;
class Converter {
// The count in China is a unit of four digits. For example, 1 5487 4584 corresponds to a unit of hundreds of millions. Default
// In each unit of four digits, the processing method is the same, the maximum absolute value digits that can be processed currently is UNIT_NAME.length * 4
private final static String[] UNIT_NAME = {"100 million", "10,000", ""};
private final static String[] SUB_UNIT_NAME = {"千", "百", "take"};
private final static String[] NUMBER_NAME = {"zero", "一", "贰", "三", "四", "Wu", "Lu", "柒", "捌", "玖"};
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 {
// Currently it can be processed, divided into four sections, each section is processed the same, and then the unit of each section is added
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 += "zero";
}
result += translate(segments[i]) + UNIT_NAME[j++];
}
}
if (isMinus) {
result = "negative" + result;
}
return result;
}
/**
* Convert a segment of up to four numbers into natural language representation. Each segment consists of up to four elements, and the maximum number is 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) + "lift";
if (oneBit> 0) {
result += nums.get(oneBit);
}
} else {
if (oneBit> 0) {
result += "zero";
result += nums.get(oneBit);
}
}
} else {
if (tenthBit> 0) {
result += "zero";
result += nums.get(tenthBit) + "lift";
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) + "lift";
if (oneBit> 0) {
result += nums.get(oneBit);
}
} else {
if (oneBit> 0) {
result += "zero";
result += nums.get(oneBit);
}
}
} else {
if (tenthBit> 0) {
result += nums.get(tenthBit) + "lift";
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();
}
}
/**
* Divide the character array into the specified number of segments
*
* @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 "The value is too large and the current system cannot handle it.";
}
}
Reply

Use magic Report

0

Threads

11

Posts

10.00

Credits

Newbie

Rank: 1

Credits
10.00

 China

Post time: 2020-7-24 12:30:01
| Show all posts
import java.util.Hashtable;
import java.util.Vector;
class Converter {
// The count in China is a unit of four digits. For example, 1 5487 4584 corresponds to a unit of hundreds of millions. Default
// In each unit of four digits, the processing method is the same, the maximum absolute value digits that can be processed currently is UNIT_NAME.length * 4
private final static String[] UNIT_NAME = {"100 million", "10,000", ""};
private final static String[] SUB_UNIT_NAME = {"千", "百", "take"};
private final static String[] NUMBER_NAME = {"zero", "一", "贰", "三", "四", "Wu", "Lu", "柒", "捌", "玖"};
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 {
// Currently it can be processed, divided into four sections, each section is processed the same, and then the unit of each section is added
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 += "zero";
}
}
result += translate(segments[i]) + UNIT_NAME[j++];
}
}
if (isMinus) {
result = "negative" + result;
}
return result;
}
/**
* Convert a segment of up to four numbers into natural language representation. Each segment consists of up to four elements, and the maximum number is 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) + "lift";
if (oneBit> 0) {
result += nums.get(oneBit);
}
} else {
if (oneBit> 0) {
result += "zero";
result += nums.get(oneBit);
}
}
} else {
if (tenthBit> 0) {
result += "zero";
result += nums.get(tenthBit) + "lift";
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) + "lift";
if (oneBit> 0) {
result += nums.get(oneBit);
}
} else {
if (oneBit> 0) {
result += "zero";
result += nums.get(oneBit);
}
}
} else {
if (tenthBit> 0) {
result += nums.get(tenthBit) + "lift";
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();
}
}
/**
* Divide the character array into the specified number of segments
*
* @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 "The value is too large and the current system cannot handle it.";
}
}
Reply

Use magic Report

You have to log in before you can reply Login | Register

Points Rules

Contact us|Archive|Mobile|CopyRight © 2008-2023|verysource.com ( 京ICP备17048824号-1 )

Quick Reply To Top Return to the list