Java에서 문자열을 int로 변환하는 방법

Java에서 String를 로 변환하려면 어떻게 int해야합니까?

내 문자열에는 숫자 만 포함되어 있으며 숫자를 나타내는 숫자를 반환하고 싶습니다.

예를 들어, 문자열 "1234"이 주어지면 결과는 숫자 여야합니다 1234.

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

Java 문서 를 보면 "캐치"는이 함수 NumberFormatException가를 처리 할 수 ​​있다는 것을 알 수 있습니다.

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

(이 처리의 기본값은 잘못된 형식입니다. 0 로 설정하지만 원하는 경우 다른 작업을 수행 할 수 있습니다.)

또는 IntsJava 8과 결합하여 Guava 라이브러리 의 메소드를 사용하여 Optional문자열을 int로 변환하는 강력하고 간결한 방법을 만들 수 있습니다.

import com.google.common.primitives.Ints;

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

예를 들어, 다음 두 가지 방법이 있습니다.

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

이 방법들에는 약간의 차이가 있습니다.

• valueOf 캐시 된 새 인스턴스를 반환합니다. java.lang.Integer
• parseIntprimitive를 리턴합니다 int.

Short.valueOf/ parseShort, Long.valueOf/ parseLong등 모든 경우에 동일합니다 .

고려해야 할 매우 중요한 점은 Integer 파서가 Javadoc에 명시된대로 NumberFormatException을 던진다는 것입니다 .

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.
}

분할 인수에서 정수 값을 가져 오거나 동적으로 구문 분석 할 때이 예외를 처리하는 것이 중요합니다.

수동으로 수행하십시오.

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;
}

다른 해결책은 Apache Commons의 NumberUtils 를 사용하는 것입니다 .

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

문자열이 유효하지 않은 숫자 형식이면 항상 0이 반환되므로 Apache 유틸리티가 유용합니다. 따라서 try catch 블록을 절약하십시오.

Apache NumberUtils API 버전 3.4

현재 나는 대학에 배정을하고 있는데, 위의 식과 같은 특정 표현을 사용할 수 없으며 ASCII 테이블을 보면 그것을 할 수있었습니다. 훨씬 복잡한 코드이지만, 나처럼 제한된 다른 사람들을 도울 수 있습니다.

가장 먼저 할 일은 입력을받는 것입니다.이 경우에는 숫자 문자열입니다. 내가 전화 할게String number .이 경우에는 숫자 12를 사용하여 예시하겠습니다.String number = "12";

또 다른 제한 사항은 반복 사이클을 사용할 수 없으므로 for사이클 (완벽했을 것)도 사용할 수 없다는 사실입니다. 이것은 우리를 조금 제한하지만 다시 한 번 목표입니다. 두 자릿수 (마지막 두 자릿수 만 필요)가 필요했기 때문에 간단하게 charAt해결했습니다.

 // 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);

코드가 있으면 테이블을 살펴보고 필요한 조정을 수행하면됩니다.

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

자, 왜 두 배입니까? 글쎄, 정말 "이상한"단계 때문입니다. 현재 우리는 1과 2의 두 가지 복식을 가지고 있지만 12로 바꿔야합니다. 수학적 연산이 없습니다.

우리는 후자 (마지막 숫자)를 다음과 같이 패션 2/10 = 0.2(따라서 두 배) 으로 10으로 나눕니다 .

 lastdigit = lastdigit/10;

이것은 단지 숫자를 가지고 노는 것입니다. 우리는 마지막 숫자를 10 진수로 바 꾸었습니다. 그러나 이제 어떤 일이 발생하는지 살펴보십시오.

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

수학에 들어 가지 않고 단순히 숫자의 숫자를 단위로 분리합니다. 우리는 0-9 만 고려하기 때문에 10의 배수로 나누는 것은 저장하는 "상자"를 만드는 것과 같습니다 (1 학년 교사가 당신에게 한 단위와 백이 무엇인지 설명했을 때를 다시 생각해보십시오). 그래서:

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

그리고 당신은 간다. 다음 제한 사항을 고려하여 문자열 자릿수 (이 경우 두 자릿수)를이 두 자릿수로 구성된 정수로 바꿨습니다.

• 반복적 인 사이클 없음
• parseInt와 같은 "Magic"표현식이 없습니다.

Integer.decode

당신은 또한 사용할 수 있습니다 public static Integer decode(String nm) throws NumberFormatException .

기본 8과 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

당신이 얻고 싶은 경우에 int대신 Integer사용할 수 :

1. 언 박싱 :

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

2. intValue():

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

주어진 문자열에 정수가 포함되어 있지 않을 가능성이있을 때마다이 특수한 경우를 처리해야합니다. 슬프게도, 표준 Java 메소드 Integer::parseInt와 Integer::valueOf을 던져는 NumberFormatException이 특별한 경우를 신호합니다. 따라서 흐름 제어에는 일반적으로 잘못된 코딩 스타일로 간주되는 예외를 사용해야합니다.

내 의견으로는,이 특별한 경우는 empty 반환하여 처리해야합니다 Optional<Integer>. Java는 이러한 방법을 제공하지 않기 때문에 다음 래퍼를 사용합니다.

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

사용법 예 :

// 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"));

이것은 여전히 ​​내부적으로 흐름 제어에 예외를 사용하고 있지만 사용 코드는 매우 깨끗합니다. 또한 -1유효한 값으로 구문 분석 된 경우와 유효하지 않은 문자열을 구문 분석 할 수없는 경우를 명확하게 구별 할 수 있습니다 .

문자열을 정수로 변환하는 것은 숫자를 변환하는 것보다 더 복잡합니다. 다음과 같은 문제에 대해 생각했습니다.

• 문자열에 숫자 0-9 만 포함되어 있습니까?
• -/ + 의 최신 소식문자열 전후에 ? 가능합니까 (회계 번호 참조)?
• 무엇이야 _- / MIN_INFINITY MAX? 문자열이 99999999999999999999이면 어떻게됩니까? 기계가이 문자열을 정수로 취급 할 수 있습니까?

그렇게하는 방법 :

 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는 Integer 객체, 다른 모든 메소드-primitive int를 생성합니다.

commons-lang3의 마지막 두 가지 방법 과 here 변환에 대한 큰 기사 .

랩퍼 클래스 의 parseInt(String str)메소드를 사용하여 Integer문자열 값을 정수 값으로 변환 할 수 있습니다 .

예를 들면 다음과 같습니다.

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

이 Integer클래스는 다음과 같은 valueOf(String str)메소드 도 제공합니다 .

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

우리는 또한 사용 toInt(String strValue)의 NumberUtils 유틸리티 클래스 전환을 위해 :

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

사용하십시오 Integer.parseInt(yourString).

다음 사항을 기억하십시오.

Integer.parseInt("1"); // 확인

Integer.parseInt("-1"); // 확인

Integer.parseInt("+1"); // 확인

Integer.parseInt(" 1"); // 예외 (공백)

Integer.parseInt("2147483648");// 예외 (정수는 최대 값 2,147,483,647로 제한됨 )

Integer.parseInt("1.1");// 예외 ( . 또는 , 또는 허용되지 않는 항목)

Integer.parseInt(""); // 예외 (0 이상은 아님)

예외 유형은 한 가지뿐입니다. NumberFormatException

나는 해결책이 있지만 그것이 얼마나 효과적인지 모른다. 그러나 잘 작동하며 개선 할 수 있다고 생각합니다. 반면에 JUnit 을 사용 하여 올바르게 테스트 한 몇 가지 테스트를 수행했습니다 . 기능과 테스트를 첨부했습니다.

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;
}

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 에는 tryParse (String)이 있습니다 . 이는 null문자열을 구문 분석 할 수없는 경우 를 반환 합니다. 예를 들면 다음과 같습니다.

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

숫자가 아닌 문자를 모두 제거한 다음 정수를 구문 분석하여 시작할 수도 있습니다.

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

그러나 이것은 음수가 아닌 숫자에만 적용됩니다.

이전 답변 외에도 여러 기능을 추가하고 싶습니다. 사용하는 동안 결과는 다음과 같습니다.

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
}

이행:

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;
}

언급 한 바와 같이, Apache Commons가 NumberUtils할 수 있습니다. 반환0문자열을 int로 변환 할 수 없으면 합니다.

자신의 기본값을 정의 할 수도 있습니다.

NumberUtils.toInt(String str, int defaultValue)

예:

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;

이 코드는 몇 가지주의 사항과 함께 사용할 수도 있습니다.

• 옵션 # 1 : 메시지 대화 상자 표시와 같이 예외를 명시 적으로 처리 한 후 현재 워크 플로우 실행을 중지하십시오. 예를 들면 다음과 같습니다.

  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;
  }

• 옵션 # 2 : 예외 발생시 실행 흐름이 계속 될 수있는 경우 영향을받는 변수를 재설정하십시오. 예를 들어 catch 블록에서 일부 수정

  catch (NumberFormatException ex) {
      integerValue = 0;
  }

상수는 결코 null 값을 반환하지 않기 때문에 비교 또는 모든 종류의 컴퓨팅에 문자열 상수를 사용하는 것이 좋습니다.

당신이 사용할 수있는 new Scanner("1244").nextInt() . 또는 정수가 존재하는지 묻습니다.new Scanner("1244").hasNextInt()

프로그래밍 경쟁에서는 숫자가 항상 유효한 정수라고 확신하는 경우 입력을 구문 분석하는 고유 한 메소드를 작성할 수 있습니다. 이것은 모든 유효성 검사 관련 코드를 건너 뛰고 (필요하지 않기 때문에) 조금 더 효율적입니다.

1. 유효한 양의 정수의 경우 :

   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. 양수와 음수 모두 :

   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. 이 숫자 전후에 공백이 필요한 경우 str = str.trim()추가 처리를하기 전에 수행해야합니다 .

간단히 시도해 볼 수 있습니다.

• 사용 Integer.parseInt(your_string);변환 String에int
• 사용 Double.parseDouble(your_string);변환 String에double

예

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

일반 문자열의 경우 다음을 사용할 수 있습니다.

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

문자열 빌더 및 문자열 버퍼의 경우 다음을 사용할 수 있습니다.

Integer.parseInt(myBuilderOrBuffer.toString());

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

문자열에 숫자가 아닌 데이터가 없는지 확인하십시오.

String을 매개 변수로 사용하는 Integer 생성자를 언급 한 사람이 없다는 것에 약간 놀랐습니다.

그래서 여기 있습니다 :

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

Java 8-정수 (문자열) .

물론 생성자는 type을 반환 Integer하고 unboxing 작업은 값을로 변환합니다 int.

언급하는 것이 중요합니다 .이 생성자는 parseInt메소드를 호출합니다 .

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

try...catch숫자가 아닌 문자를 입력하는 경우를 대비하여 Integer.parseInt ()를 사용하여 블록 안에 넣어 오류를 처리하십시오.

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);
    }
 }

우리는 간다

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

7 가지 방법으로 수행 할 수 있습니다.

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

String number = "999";

1) 사용 Ints.tryParse:

int result = Ints.tryParse(number);

2) 사용 NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) 사용 NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) 사용 Integer.valueOf:

Integer result = Integer.valueOf(number);

5) 사용 Integer.parseInt:

int result = Integer.parseInt(number);

6) 사용 Integer.decode:

int result = Integer.decode(number);

7) 사용 Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

한 가지 방법은 parseInt (String)입니다. 프리미티브 int를 반환합니다.

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

두 번째 방법은 valueOf (String)이며 새 Integer () 객체를 반환합니다.

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

다음 중 하나를 사용할 수 있습니다.

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)

이것은 라이브러리를 사용하지 않고 모든 조건이 긍정적이고 부정적인 완전한 프로그램입니다

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;
    }
}