Làm cách nào để chuyển đổi một Chuỗi thành một int trong Java?

Làm cách nào tôi có thể chuyển đổi Stringthành một inttrong Java?

Chuỗi của tôi chỉ chứa các số và tôi muốn trả về số mà nó đại diện.

Ví dụ, cho chuỗi "1234"kết quả sẽ là số 1234.

String myString = "1234";
int foo = Integer.parseInt(myString);

Nếu bạn nhìn vào Tài liệu Java, bạn sẽ nhận thấy "cái bẫy" là chức năng này có thể ném ra NumberFormatException, tất nhiên bạn phải xử lý:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(Điều trị này mặc định một số không đúng 0, nhưng bạn có thể làm điều gì khác nếu bạn muốn.)

Ngoài ra, bạn có thể sử dụng một Intsphương thức từ thư viện Guava, kết hợp với Java 8 Optional, tạo ra một cách mạnh mẽ và ngắn gọn để chuyển đổi một chuỗi thành int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

Ví dụ, đây là hai cách:

Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);

Có một sự khác biệt nhỏ giữa các phương pháp này:

• valueOf trả về một thể hiện mới hoặc được lưu trong bộ nhớ cache của java.lang.Integer
• parseInttrả về nguyên thủy int.

Điều tương tự là cho tất cả các trường hợp: Short.valueOf/ parseShort, Long.valueOf/ parseLong, v.v.

Chà, một điểm rất quan trọng cần xem xét là trình phân tích cú pháp Integer ném NumberFormatException như đã nêu trong Javadoc .

int foo;
String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exception
String StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exception
try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot);
} catch (NumberFormatException e) {
      //Will Throw exception!
      //do something! anything to handle the exception.
}

try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot2);
} catch (NumberFormatException e) {
      //No problem this time, but still it is good practice to care about exceptions.
      //Never trust user input :)
      //Do something! Anything to handle the exception.
}

Điều quan trọng là phải xử lý ngoại lệ này khi cố gắng lấy các giá trị nguyên từ các đối số phân tách hoặc phân tích động một cái gì đó.

Làm thủ công:

public static int strToInt( String str ){
    int i = 0;
    int num = 0;
    boolean isNeg = false;

    //Check for negative sign; if it's there, set the isNeg flag
    if (str.charAt(0) == '-') {
        isNeg = true;
        i = 1;
    }

    //Process each character of the string;
    while( i < str.length()) {
        num *= 10;
        num += str.charAt(i++) - '0'; //Minus the ASCII code of '0' to get the value of the charAt(i++).
    }

    if (isNeg)
        num = -num;
    return num;
}

Một giải pháp thay thế là sử dụng NumberUtils của Apache Commons :

int num = NumberUtils.toInt("1234");

Tiện ích Apache rất hay vì nếu chuỗi có định dạng số không hợp lệ thì 0 luôn được trả về. Do đó tiết kiệm cho bạn khối bắt thử.

API NumberUtils API phiên bản 3.4

Hiện tại tôi đang làm bài tập cho trường đại học, nơi tôi không thể sử dụng một số biểu thức nhất định, chẳng hạn như các biểu thức ở trên và bằng cách nhìn vào bảng ASCII, tôi đã xoay sở để làm điều đó. Đó là một mã phức tạp hơn nhiều, nhưng nó có thể giúp những người khác bị hạn chế như tôi.

Điều đầu tiên cần làm là nhận đầu vào, trong trường hợp này là một chuỗi các chữ số; Tôi sẽ gọi nó String number, và trong trường hợp này, tôi sẽ minh họa nó bằng cách sử dụng số 12, do đóString number = "12";

Một hạn chế khác là tôi không thể sử dụng các chu kỳ lặp đi lặp lại, do đó, một forchu trình (sẽ hoàn hảo) cũng không thể được sử dụng. Điều này giới hạn chúng tôi một chút, nhưng một lần nữa, đó là mục tiêu. Vì tôi chỉ cần hai chữ số (lấy hai chữ số cuối), một cách đơn giản đã charAtgiải quyết nó:

 // Obtaining the integer values of the char 1 and 2 in ASCII
 int semilastdigitASCII = number.charAt(number.length()-2);
 int lastdigitASCII = number.charAt(number.length()-1);

Có mã, chúng ta chỉ cần tra cứu bảng và thực hiện các điều chỉnh cần thiết:

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

Bây giờ, tại sao lại tăng gấp đôi? Vâng, bởi vì một bước thực sự "kỳ lạ". Hiện tại chúng tôi có hai nhân đôi, 1 và 2, nhưng chúng tôi cần biến nó thành 12, không có thao tác toán học nào chúng tôi có thể làm.

Chúng tôi đang chia số thứ hai (chữ số cuối) cho 10 theo kiểu 2/10 = 0.2(vì thế tại sao lại gấp đôi) như thế này:

 lastdigit = lastdigit/10;

Đây chỉ đơn thuần là chơi với những con số. Chúng tôi đã biến chữ số cuối cùng thành số thập phân. Nhưng bây giờ, hãy nhìn vào những gì xảy ra:

 double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

Không đi sâu vào toán học, chúng ta chỉ cần cô lập các đơn vị chữ số của một số. Bạn thấy đấy, vì chúng tôi chỉ xem xét 0-9, chia cho bội số 10 giống như tạo một "hộp" nơi bạn lưu trữ nó (hãy nghĩ lại khi giáo viên lớp một của bạn giải thích cho bạn một đơn vị và một trăm là gì). Vì thế:

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

Và ở đó bạn đi. Bạn đã biến một chuỗi các chữ số (trong trường hợp này là hai chữ số), thành một số nguyên gồm hai chữ số đó, xem xét các giới hạn sau:

• Không có chu kỳ lặp đi lặp lại
• Không có biểu thức "Magic" nào như parseInt

Integer.decode

Bạn cũng có thể sử dụng public static Integer decode(String nm) throws NumberFormatException.

Nó cũng hoạt động cho cơ sở 8 và 16:

// base 10
Integer.parseInt("12");     // 12 - int
Integer.valueOf("12");      // 12 - Integer
Integer.decode("12");       // 12 - Integer
// base 8
// 10 (0,1,...,7,10,11,12)
Integer.parseInt("12", 8);  // 10 - int
Integer.valueOf("12", 8);   // 10 - Integer
Integer.decode("012");      // 10 - Integer
// base 16
// 18 (0,1,...,F,10,11,12)
Integer.parseInt("12",16);  // 18 - int
Integer.valueOf("12",16);   // 18 - Integer
Integer.decode("#12");      // 18 - Integer
Integer.decode("0x12");     // 18 - Integer
Integer.decode("0X12");     // 18 - Integer
// base 2
Integer.parseInt("11",2);   // 3 - int
Integer.valueOf("11",2);    // 3 - Integer

Nếu bạn muốn nhận intthay vì Integerbạn có thể sử dụng:

1. Bỏ hộp:

   int val = Integer.decode("12"); 

2. intValue():

   Integer.decode("12").intValue();

Bất cứ khi nào có khả năng nhỏ nhất là Chuỗi đã cho không chứa Số nguyên, bạn phải xử lý trường hợp đặc biệt này. Đáng buồn thay, các phương thức Java tiêu chuẩn Integer::parseIntvà Integer::valueOfđưa ra NumberFormatExceptionđể báo hiệu trường hợp đặc biệt này. Do đó, bạn phải sử dụng các ngoại lệ để kiểm soát luồng, thường được coi là kiểu mã hóa xấu.

Theo tôi, trường hợp đặc biệt này nên được xử lý bằng cách trả lại một sản phẩm nào Optional<Integer>. Vì Java không cung cấp một phương thức như vậy, tôi sử dụng trình bao bọc sau:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

Ví dụ sử dụng:

// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

Trong khi điều này vẫn đang sử dụng ngoại lệ cho kiểm soát luồng nội bộ, mã sử dụng trở nên rất sạch sẽ. Ngoài ra, bạn có thể phân biệt rõ ràng trường hợp -1được phân tích cú pháp thành giá trị hợp lệ và trường hợp chuỗi không hợp lệ không thể được phân tích cú pháp.

Chuyển đổi một chuỗi thành một int phức tạp hơn là chỉ chuyển đổi một số. Bạn đã nghĩ về các vấn đề sau:

• Có phải chuỗi chỉ chứa các số 0-9 ?
• Có gì với - / + trước hoặc sau chuỗi? Điều đó có thể không (tham khảo số kế toán)?
• Có chuyện gì với MAX _- / MIN_INFINITY? Điều gì sẽ xảy ra nếu chuỗi là 99999999999999999999? Máy có thể coi chuỗi này là int không?

Phương pháp để làm điều đó:

 1. Integer.parseInt(s)
 2. Integer.parseInt(s, radix)
 3. Integer.parseInt(s, beginIndex, endIndex, radix)
 4. Integer.parseUnsignedInt(s)
 5. Integer.parseUnsignedInt(s, radix)
 6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
 7. Integer.valueOf(s)
 8. Integer.valueOf(s, radix)
 9. Integer.decode(s)
 10. NumberUtils.toInt(s)
 11. NumberUtils.toInt(s, defaultValue)

Integer.valueOf tạo đối tượng Integer, tất cả các phương thức khác - int nguyên thủy.

2 phương pháp cuối cùng từ commons-lang3 và bài viết lớn về chuyển đổi ở đây .

Chúng ta có thể sử dụng parseInt(String str)phương thức của Integerlớp bao bọc để chuyển đổi giá trị Chuỗi thành giá trị nguyên.

Ví dụ:

String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);

Các Integerlớp học cũng cung cấp các valueOf(String str)phương pháp:

String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);

Chúng tôi cũng có thể sử dụng toInt(String strValue)các NumberUtils Utility Lớp cho việc chuyển đổi:

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);

Sử dụng Integer.parseInt(yourString).

Hãy nhớ những điều sau đây:

Integer.parseInt("1"); // đồng ý

Integer.parseInt("-1"); // đồng ý

Integer.parseInt("+1"); // đồng ý

Integer.parseInt(" 1"); // Ngoại lệ (khoảng trống)

Integer.parseInt("2147483648");// Ngoại lệ (Số nguyên được giới hạn ở giá trị tối đa là 2.147.483.647)

Integer.parseInt("1.1");// Ngoại lệ ( . Hoặc , hoặc bất cứ điều gì không được phép)

Integer.parseInt(""); // Ngoại lệ (không phải 0 hoặc một cái gì đó)

Chỉ có một loại ngoại lệ: NumberFormatException

Tôi có một giải pháp, nhưng tôi không biết nó hiệu quả như thế nào. Nhưng nó hoạt động tốt, và tôi nghĩ bạn có thể cải thiện nó. Mặt khác, tôi đã thực hiện một vài thử nghiệm với JUnit , bước nào chính xác. Tôi đã đính kèm chức năng và kiểm tra:

static public Integer str2Int(String str) {
    Integer result = null;
    if (null == str || 0 == str.length()) {
        return null;
    }
    try {
        result = Integer.parseInt(str);
    } 
    catch (NumberFormatException e) {
        String negativeMode = "";
        if(str.indexOf('-') != -1)
            negativeMode = "-";
        str = str.replaceAll("-", "" );
        if (str.indexOf('.') != -1) {
            str = str.substring(0, str.indexOf('.'));
            if (str.length() == 0) {
                return (Integer)0;
            }
        }
        String strNum = str.replaceAll("[^\\d]", "" );
        if (0 == strNum.length()) {
            return null;
        }
        result = Integer.parseInt(negativeMode + strNum);
    }
    return result;
}

Kiểm tra với JUnit:

@Test
public void testStr2Int() {
    assertEquals("is numeric", (Integer)(-5), Helper.str2Int("-5"));
    assertEquals("is numeric", (Integer)50, Helper.str2Int("50.00"));
    assertEquals("is numeric", (Integer)20, Helper.str2Int("$ 20.90"));
    assertEquals("is numeric", (Integer)5, Helper.str2Int(" 5.321"));
    assertEquals("is numeric", (Integer)1000, Helper.str2Int("1,000.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("0.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int(".50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("-.10"));
    assertEquals("is numeric", (Integer)Integer.MAX_VALUE, Helper.str2Int(""+Integer.MAX_VALUE));
    assertEquals("is numeric", (Integer)Integer.MIN_VALUE, Helper.str2Int(""+Integer.MIN_VALUE));
    assertEquals("Not
     is numeric", null, Helper.str2Int("czv.,xcvsa"));
    /**
     * Dynamic test
     */
    for(Integer num = 0; num < 1000; num++) {
        for(int spaces = 1; spaces < 6; spaces++) {
            String numStr = String.format("%0"+spaces+"d", num);
            Integer numNeg = num * -1;
            assertEquals(numStr + ": is numeric", num, Helper.str2Int(numStr));
            assertEquals(numNeg + ": is numeric", numNeg, Helper.str2Int("- " + numStr));
        }
    }
}

Google Guava có tryPude (Chuỗi) , trả về nullnếu chuỗi không thể được phân tích cú pháp, ví dụ:

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}

Bạn cũng có thể bắt đầu bằng cách xóa tất cả các ký tự không phải là số và sau đó phân tích số nguyên:

String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);

Nhưng được cảnh báo rằng điều này chỉ hoạt động cho các số không âm.

Ngoài các câu trả lời trước, tôi muốn thêm một số chức năng. Đây là kết quả trong khi bạn sử dụng chúng:

public static void main(String[] args) {
  System.out.println(parseIntOrDefault("123", 0)); // 123
  System.out.println(parseIntOrDefault("aaa", 0)); // 0
  System.out.println(parseIntOrDefault("aaa456", 3, 0)); // 456
  System.out.println(parseIntOrDefault("aaa789bbb", 3, 6, 0)); // 789
}

Thực hiện:

public static int parseIntOrDefault(String value, int defaultValue) {
  int result = defaultValue;
  try {
    result = Integer.parseInt(value);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int endIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex, endIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}

Như đã đề cập, Apache Commons NumberUtilscó thể làm điều đó. Nó trả về 0nếu nó không thể chuyển đổi một chuỗi thành int.

Bạn cũng có thể xác định giá trị mặc định của riêng bạn:

NumberUtils.toInt(String str, int defaultValue)

Thí dụ:

NumberUtils.toInt("3244", 1) = 3244
NumberUtils.toInt("", 1)     = 1
NumberUtils.toInt(null, 5)   = 5
NumberUtils.toInt("Hi", 6)   = 6
NumberUtils.toInt(" 32 ", 1) = 1 // Space in numbers are not allowed
NumberUtils.toInt(StringUtils.trimToEmpty("  32 ", 1)) = 32;

Bạn cũng có thể sử dụng mã này, với một số biện pháp phòng ngừa.

• Tùy chọn # 1: Xử lý ngoại lệ một cách rõ ràng, ví dụ, hiển thị hộp thoại thông báo và sau đó dừng thực thi quy trình công việc hiện tại. Ví dụ:

  try
      {
          String stringValue = "1234";
  
          // From String to Integer
          int integerValue = Integer.valueOf(stringValue);
  
          // Or
          int integerValue = Integer.ParseInt(stringValue);
  
          // Now from integer to back into string
          stringValue = String.valueOf(integerValue);
      }
  catch (NumberFormatException ex) {
      //JOptionPane.showMessageDialog(frame, "Invalid input string!");
      System.out.println("Invalid input string!");
      return;
  }

• Tùy chọn # 2: Đặt lại biến bị ảnh hưởng nếu luồng thực thi có thể tiếp tục trong trường hợp có ngoại lệ. Ví dụ: với một số sửa đổi trong khối bắt

  catch (NumberFormatException ex) {
      integerValue = 0;
  }

Sử dụng hằng số chuỗi để so sánh hoặc bất kỳ loại máy tính nào luôn là một ý tưởng hay, bởi vì hằng số không bao giờ trả về giá trị null.

Bạn có thể sử dụng new Scanner("1244").nextInt(). Hoặc hỏi nếu thậm chí một int tồn tại:new Scanner("1244").hasNextInt()

Trong các cuộc thi lập trình, khi bạn chắc chắn rằng số đó sẽ luôn là số nguyên hợp lệ, thì bạn có thể viết phương thức của riêng mình để phân tích cú pháp đầu vào. Điều này sẽ bỏ qua tất cả các mã liên quan đến xác thực (vì bạn không cần bất kỳ mã nào trong số đó) và sẽ hiệu quả hơn một chút.

1. Đối với số nguyên dương hợp lệ:

   private static int parseInt(String str) {
       int i, n = 0;
   
       for (i = 0; i < str.length(); i++) {
           n *= 10;
           n += str.charAt(i) - 48;
       }
       return n;
   }

2. Đối với cả số nguyên dương và số âm:

   private static int parseInt(String str) {
       int i=0, n=0, sign=1;
       if (str.charAt(0) == '-') {
           i = 1;
           sign = -1;
       }
       for(; i<str.length(); i++) {
           n* = 10;
           n += str.charAt(i) - 48;
       }
       return sign*n;
   }

3. Nếu bạn đang mong đợi một khoảng trắng trước hoặc sau những con số này, thì hãy đảm bảo thực hiện str = str.trim()trước khi xử lý thêm.

Đơn giản là bạn có thể thử điều này:

• Sử dụng Integer.parseInt(your_string);để chuyển đổi Stringthànhint
• Sử dụng Double.parseDouble(your_string);để chuyển đổi Stringthànhdouble

Thí dụ

String str = "8955";
int q = Integer.parseInt(str);
System.out.println("Output>>> " + q); // Output: 8955

String str = "89.55";
double q = Double.parseDouble(str);
System.out.println("Output>>> " + q); // Output: 89.55

Đối với một chuỗi bình thường, bạn có thể sử dụng:

int number = Integer.parseInt("1234");

Đối với trình tạo chuỗi và bộ đệm Chuỗi, bạn có thể sử dụng:

Integer.parseInt(myBuilderOrBuffer.toString());

int foo=Integer.parseInt("1234");

Đảm bảo không có dữ liệu không phải là số trong chuỗi.

Tôi hơi ngạc nhiên khi không ai đề cập đến hàm tạo Integer lấy String làm tham số.

Vì vậy, đây là:

String myString = "1234";
int i1 = new Integer(myString);

Java 8 - Số nguyên (Chuỗi) .

Tất nhiên, hàm tạo sẽ trả về kiểu Integervà một hoạt động unboxing chuyển đổi giá trị thành int.

Điều quan trọng cần đề cập : Hàm tạo này gọi parseIntphương thức.

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}

Sử dụng Integer.parseInt () và đặt nó vào trong một try...catchkhối để xử lý bất kỳ lỗi nào chỉ trong trường hợp nhập một ký tự không phải là số, ví dụ:

private void ConvertToInt(){
    String string = txtString.getText();
    try{
        int integerValue=Integer.parseInt(string);
        System.out.println(integerValue);
    }
    catch(Exception e){
       JOptionPane.showMessageDialog(
         "Error converting string to integer\n" + e.toString,
         "Error",
         JOptionPane.ERROR_MESSAGE);
    }
 }

Chúng ta đi đây

String str="1234";
int number = Integer.parseInt(str);
print number;//1234

Nó có thể được thực hiện theo bảy cách:

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;

String number = "999";

1) Sử dụng Ints.tryParse:

int result = Ints.tryParse(number);

2) Sử dụng NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Sử dụng NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Sử dụng Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Sử dụng Integer.parseInt:

int result = Integer.parseInt(number);

6) Sử dụng Integer.decode:

int result = Integer.decode(number);

7) Sử dụng Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

Một phương thức là parseInt (String). Nó trả về một int nguyên thủy:

String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);

Phương thức thứ hai là valueOf (String) và nó trả về một đối tượng Integer () mới:

String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);

Bạn có thể sử dụng bất kỳ cách nào sau đây:

1. Integer.parseInt(s)
2. Integer.parseInt(s, radix)
3. Integer.parseInt(s, beginIndex, endIndex, radix)
4. Integer.parseUnsignedInt(s)
5. Integer.parseUnsignedInt(s, radix)
6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
7. Integer.valueOf(s)
8. Integer.valueOf(s, radix)
9. Integer.decode(s)
10. NumberUtils.toInt(s)
11. NumberUtils.toInt(s, defaultValue)

Đây là một chương trình hoàn chỉnh với tất cả các điều kiện tích cực và tiêu cực mà không cần sử dụng thư viện

import java.util.Scanner;


public class StringToInt {

    public static void main(String args[]) {
        String inputString;
        Scanner s = new Scanner(System.in);
        inputString = s.nextLine();

        if (!inputString.matches("([+-]?([0-9]*[.])?[0-9]+)")) {
            System.out.println("Not a Number");
        }
        else {
            Double result2 = getNumber(inputString);
            System.out.println("result = " + result2);
        }
    }


    public static Double getNumber(String number) {
        Double result = 0.0;
        Double beforeDecimal = 0.0;
        Double afterDecimal = 0.0;
        Double afterDecimalCount = 0.0;
        int signBit = 1;
        boolean flag = false;

        int count = number.length();
        if (number.charAt(0) == '-') {
            signBit = -1;
            flag = true;
        }
        else if (number.charAt(0) == '+') {
            flag = true;
        }
        for (int i = 0; i < count; i++) {
            if (flag && i == 0) {
                continue;
            }
            if (afterDecimalCount == 0.0) {
                if (number.charAt(i) - '.' == 0) {
                    afterDecimalCount++;
                }
                else {
                    beforeDecimal = beforeDecimal * 10 + (number.charAt(i) - '0');
                }
            }
            else {
                afterDecimal = afterDecimal * 10 + number.charAt(i) - ('0');
                afterDecimalCount = afterDecimalCount * 10;
            }
        }
        if (afterDecimalCount != 0.0) {
            afterDecimal = afterDecimal / afterDecimalCount;
            result = beforeDecimal + afterDecimal;
        }
        else {
            result = beforeDecimal;
        }
        return result * signBit;
    }
}