在Java中手动将字符串转换为整数

Question

我有一个由数字序列组成的字符串（例如

"1234"

）。如何在不使用像

String

这样的 Java 库函数的情况下将

int

作为

Integer.parseInt

返回？

public class StringToInteger {
  public static void main(String [] args){
    int i = myStringToInteger("123");
    System.out.println("String decoded to number " + i);
  }

  public int myStringToInteger(String str){
      /* ... */
  }
}

Answer 1

这有什么问题吗？

int i = Integer.parseInt(str);

编辑：

如果您真的需要手动进行转换，请尝试以下操作：

public static int myStringToInteger(String str) {
    int answer = 0, factor = 1;
    for (int i = str.length()-1; i >= 0; i--) {
        answer += (str.charAt(i) - '0') * factor;
        factor *= 10;
    }
    return answer;
}

上面的方法对于正整数来说效果很好，如果数字是负数，你必须先做一些检查，但我会把它留给读者作为练习。

Answer 2

如果标准库不被允许，有很多方法可以解决这个问题。思考这个问题的一种方法是将其视为递归函数：

如果n小于10，则将其转换为包含其数字的单字符字符串。例如，3 变为“3”。
如果n大于10，则用除法和取模得到n的最后一位以及排除最后一位得到的数。递归获取第一个数字的字符串，然后为最后一个数字附加适当的字符。例如，如果 n 是 137，您将递归计算“13”并附加“7”以获得“137”。

您需要逻辑来处理特殊情况 0 和负数，但除此之外这可以相当简单地完成。

因为我怀疑这可能是家庭作业（并且知道在某些学校确实如此），所以我将把实际的转换作为练习留给读者。 :-)

希望这有帮助！

Answer 3

在这种情况下使用 long 而不是 int 。您需要检查是否有溢出。

public static int StringtoNumber(String s) throws Exception{
    if (s == null || s.length() == 0)
        return 0;
    while(s.charAt(0) == ' '){
        s = s.substring(1);
    }
    boolean isNegative = s.charAt(0) == '-';
    if (s.charAt(0) == '-' || (s.charAt(0) == '+')){
        s = s.substring(1);
    }

    long result = 0l;
    for (int i = 0; i < s.length(); i++){
        int value = s.charAt(i) - '0';
        if (value >= 0 && value <= 9){
            if (!isNegative && 10 * result + value > Integer.MAX_VALUE ){
                throw new Exception();
            }else if (isNegative && -1 * 10 * result - value < Integer.MIN_VALUE){
                throw new Exception();
            }
            result = 10 * result + value;
        }else if (s.charAt(i) != ' '){
            return (int)result;
        }
    }
    return isNegative ? -1 * (int)result : (int)result;
}

Answer 4

此处已发布答案的替代方法。您可以从前面遍历字符串并构建数字

 public static void stringtoint(String s){      
    boolean isNegative=false;
    int number =0;      
    if (s.charAt(0)=='-') {
        isNegative=true;            
    }else{
        number = number* 10 + s.charAt(0)-'0';
    }

    for (int i = 1; i < s.length(); i++) {

        number = number*10 + s.charAt(i)-'0';           
    }
    if(isNegative){
        number = 0-number;
    }
    System.out.println(number);
}

Answer 5

只要给出正确的提示，我认为大多数受过高中教育的人都可以自己解决这个问题。大家都知道

134 = 100x1 + 10x3 + 1x4

大多数人错过的关键部分是，如果你在 Java 中做这样的事情

 System.out.println('0'*1);//48

它将选择 ascii 图表中字符 0 的十进制表示形式，并将其乘以 1。

在 ascii 表中，字符 0 的十进制表示形式为 48。因此上面的行将打印 48。因此，如果您执行类似 '1'-'0' 的操作，则与 49-48 相同。由于在ascii图表中，字符0-9是连续的，因此您可以取0到9之间的任何字符并减去0以获得其整数值。一旦获得了一个字符的整数值，那么将整个字符串转换为 int 就很简单了。

这是问题的另一种解决方案

String a = "-12512";
char[] chars = a.toCharArray();
boolean isNegative = (chars[0] == '-');
if (isNegative) {
    chars[0] = '0';
}

int multiplier = 1;
int total = 0;

for (int i = chars.length - 1; i >= 0; i--) {
    total = total + ((chars[i] - '0') * multiplier);
    multiplier = multiplier * 10;
}

if (isNegative) {
    total = total * -1;
}

Answer 6

使用这个：

static int parseInt(String str) {
    char[] ch = str.trim().toCharArray();
    int len = ch.length;
    int value = 0;
    for (int i=0, j=(len-1); i<len; i++,j--) {
        int c = ch[i];
        if (c < 48 || c > 57) {
            throw new NumberFormatException("Not a number: "+str);
        }
        int n = c - 48;
        n *= Math.pow(10, j);
        value += n;
    }
    return value;
}

顺便说一句，你可以处理负整数的特殊情况，否则会抛出异常NumberFormatException。

Answer 7

您可以这样做：从字符串中，为每个元素创建一个字符数组，保存索引，并将其 ASCII 值乘以实际反向索引的幂。将部分因数相加即可得到。

只有一小部分可以使用

Math.pow

（因为它返回一个双精度值），但您可以通过创建自己的幂函数来避免它。

public static int StringToInt(String str){
    int res = 0;
    char [] chars = str.toCharArray();
    System.out.println(str.length());
    for (int i = str.length()-1, j=0; i>=0; i--, j++){
        int temp = chars[j]-48;
        int power = (int) Math.pow(10, i);
        res += temp*power;
        System.out.println(res);
    }
    return res;
}

Answer 8

使用 Java 8，您可以执行以下操作：

public static int convert(String strNum)
{
   int result =strNum.chars().reduce(0, (a, b)->10*a +b-'0');
}

将 srtNum 转换为 char
对于每个字符（表示为“b”）->“b”-“0”将给出相对数字
对 a 中的所有内容求和（初始值为 0）（每次我们对 char 执行操作时 do -> a=a*10

Answer 9

利用 Java 以相同方式使用 char 和 int 的事实。基本上，执行 char - '0' 即可获取 char 的 int 值。

public class StringToInteger {
    public static void main(String[] args) {
        int i = myStringToInteger("123");
        System.out.println("String decoded to number " + i);
    }

    public static int myStringToInteger(String str) {
        int sum = 0;
        char[] array = str.toCharArray();
        int j = 0;
        for(int i = str.length() - 1 ; i >= 0 ; i--){
            sum += Math.pow(10, j)*(array[i]-'0');
            j++;
        }
        return sum;
    }
}

Answer 10

public int myStringToInteger(String str) throws NumberFormatException 
{
    int decimalRadix = 10; //10 is the radix of the decimal system

    if (str == null) {
        throw new NumberFormatException("null");
    }

    int finalResult = 0;
    boolean isNegative = false;
    int index = 0, strLength = str.length();

    if (strLength > 0) {
        if (str.charAt(0) == '-') {
            isNegative = true;
            index++;
        } 

        while (index < strLength) {

            if((Character.digit(str.charAt(index), decimalRadix)) != -1){   
                finalResult *= decimalRadix;
                finalResult += (str.charAt(index) - '0');
            } else throw new NumberFormatException("for input string " + str);

            index++;
        }

    } else {
        throw new NumberFormatException("Empty numeric string");
    }

    if(isNegative){
        if(index > 1)
            return -finalResult;
        else
            throw new NumberFormatException("Only got -");
    }

    return finalResult;
}

结果： 1) 对于输入“34567”，最终结果为：34567 2) 对于输入“-4567”，最终结果将是：-4567 3）对于输入“-”，最终结果将是： java.lang.NumberFormatException: Only got - 4) 对于输入“12ab45”，最终结果将是： java.lang.NumberFormatException: for input string 12ab45

Answer 11

public static int convertToInt(String input){
        char[] ch=input.toCharArray();
        int result=0;
        for(char c : ch){
            result=(result*10)+((int)c-(int)'0');
        }
        return result;
    }

Answer 12

也许这样会快一点：

public static int convertStringToInt(String num) {
     int result = 0;

     for (char c: num.toCharArray()) {
        c -= 48;
        if (c <= 9) {
            result = (result << 3) + (result << 1) + c;
        } else return -1;
    }
    return result;
}

Answer 13

这是完整的程序，所有条件均为正、负，无需使用库

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("error!!!");
  } 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;
 }
}

Answer 14

Works for Positive and Negative String Using TDD

//Solution

public int convert(String string) {
    int number = 0;
    boolean isNegative = false;
    int i = 0;
    if (string.charAt(0) == '-') {
        isNegative = true;
        i++;
    }

    for (int j = i; j < string.length(); j++) {
        int value = string.charAt(j) - '0';
        number *= 10;
        number += value;
    }
    if (isNegative) {
        number = -number;
    }

    return number;
}

//测试用例

public class StringtoIntTest {
private StringtoInt stringtoInt;


@Before
public void setUp() throws Exception {
stringtoInt = new StringtoInt();
}

@Test
public void testStringtoInt() {
    int excepted = stringtoInt.convert("123456");
    assertEquals(123456,excepted);
}

@Test
public void testStringtoIntWithNegative() {
    int excepted = stringtoInt.convert("-123456");
    assertEquals(-123456,excepted);
}

}

Answer 15

    //Take one positive or negative number
    String str="-90997865";

    //Conver String into Character Array
    char arr[]=str.toCharArray();

    int no=0,asci=0,res=0;

    for(int i=0;i<arr.length;i++)
    {
       //If First Character == negative then skip iteration and i++
       if(arr[i]=='-' && i==0)
       {
           i++;
       }

           asci=(int)arr[i]; //Find Ascii value of each Character 
           no=asci-48; //Now Substract the Ascii value of 0 i.e 48  from asci
           res=res*10+no; //Conversion for final number
    }

    //If first Character is negative then result also negative
    if(arr[0]=='-')
    {
        res=-res;
    }

    System.out.println(res);

Answer 16

将字符串转换为 int 的一种非常巧妙的方法 - 将契约视为数组列表输入并输出 null（如果不可转换）或有效值。

package <package>;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.IntStream;

public class SO79073232 {
    public static void main(String ...args) {
        ArrayList<String> strs = new ArrayList<>(Arrays.asList("1","2","200","",null, "two"));
        strs.stream().map(SO79073232::toInt).forEach(System.out::println);
    }

    private static int getInt(char c) {
        if (Character.isDigit(c)) {
            return (int) (c - '0');
        } else {
            throw new ArithmeticException(String.format("char %c is not a digit", c));
        }
    }

    private static Integer toInt(String s) {
        try {
            return IntStream.range(0, s.length()).map(i -> (int) (Math.pow(10, s.length() - i - 1)) * (int) getInt(s.charAt(i))).sum();
        } catch (Exception e) {
           return null;
        }
    }
}

它输出：

1
2
200
0
null
null

其美妙之处在于它如何利用 Java lambda 编程的“流”和映射/归约。

Answer 17

public class ConvertInteger {

public static int convertToInt(String numString){
    int answer = 0, factor = 1;

    for (int i = numString.length()-1; i >= 0; i--) {
        answer += (numString.charAt(i) - '0') *factor;
        factor *=10;
    }
    return answer;
}

public static void main(String[] args) {

    System.out.println(convertToInt("789"));
}

}

在Java中手动将字符串转换为整数

问题描述投票：0回答：17

17个回答

最新问题

在Java中手动将字符串转换为整数

问题描述 投票：0回答：17

17个回答

最新问题

问题描述投票：0回答：17