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




자바 타입 변환 (24)

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

My String은 숫자 만 포함하고 있으며, 숫자가 나타내는 숫자를 반환하고 싶습니다.

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


여기에 우리가 간다.

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

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

가장 먼저 할 일은 입력 (이 경우 숫자 열)을받는 것입니다. 나는 String number 라고 부를 것이고,이 경우에는 숫자 12를 사용하여 그것을 예시 할 것이다. 그러므로 String number = "12";

또 다른 한계는 반복적 인 사이클을 사용할 수 없다는 사실이었습니다. 따라서 완벽한 사이클이었을 때도 사용할 수 없었습니다. 이것은 우리를 약간 제한하지만, 다시 그것은 목표입니다. 나는 단지 두 자릿수 (마지막 두 자릿수)를 필요로하기 때문에, 간단한 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의 2 개의 복식을 가지고 있지만, 12로 바꾸어야합니다. 우리가 할 수있는 수학 연산이 없습니다.

우리는 후자 (lastdigit)를 다음과 같이 유행 2/10 = 0.2 나누고 있습니다 (따라서 왜 double인지) :

 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"익스프레션이 없습니다.

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

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

문자열이 잘못된 숫자 형식이면 항상 0이 반환되기 때문에 Apache 유틸리티가 유용합니다. 따라서 try catch 블록을 절약 할 수 있습니다.

Apache NumberUtils API 버전 3.4


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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

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

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


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

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

문자열을 int로 변환하는 것은 숫자를 변환하는 것보다 복잡합니다. 다음과 같은 문제에 대해 생각해보십시오.

  • 문자열에 숫자 0-9 만 포함되어 있습니까?
  • 무슨 일 이니? / + 문자열 앞뒤에? 가능합니까 (회계 번호 참조)?
  • MAX_- / MIN_INFINITY는 무엇입니까? 문자열이 999999999999999999이면 어떻게됩니까? 기계가이 문자열을 int로 처리 할 수 ​​있습니까?

Integer.parseInt ()를 사용하여 try...catch 블록 안에 넣어서 숫자가 아닌 문자가 입력 된 경우 오류를 처리합니다. 예를 들어,

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 myString = "1234";
int foo = Integer.parseInt(myString);

자세한 정보는 Java. 서를 참조하십시오.


그런데 문자열이 null이면 호출은 다음과 같습니다.

int i = Integer.parseInt(null);

NumberFormatException을 throw하지만 NullPointerException은 throw하지 않습니다.


구아바에는 문자열을 파싱 할 수없는 경우 null 을 반환하는 tryParse(String)tryParse(String) 예 :

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

위의 답변 외에도 다음과 같은 몇 가지 기능을 추가하고 싶습니다.

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

그리고 실행하는 동안 결과는 다음과 같습니다.

  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
  }

String 값을 정수 값으로 변환하기 위해 Integer 래퍼 클래스의 parseInt(String str) 메서드를 사용할 수 있습니다.

예 :

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

Integer 클래스는 valueOf(String str) 메서드도 제공합니다.

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

또한 변환을 위해 NumberUtils 유틸리티 클래스toInt(String strValue) 를 사용할 수 있습니다.

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

String을 매개 변수로 사용하는 Integer 생성자에 대해서는 아무도 언급하지 않았다는 사실에 조금 놀랐습니다.
그래서, 여기 있습니다 :

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

자바 8 - 정수 (문자열) .

물론 생성자는 Integer 유형을 반환하고 unboxing 연산은 value를 int 로 변환합니다.

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

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

나는 해결책이 있지만 그것이 얼마나 효과적인지 모르겠다. 그러나 그것은 잘 작동하고, 당신이 그것을 향상시킬 수 있다고 생각합니다. 반면에 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));
        }
    }
}

간단하게 이것을 시도 할 수 있습니다 :

  • Integer.parseInt(your_string); 사용하십시오 Integer.parseInt(your_string); Stringint 로 변환한다.
  • Double.parseDouble(your_string); 사용하십시오 Double.parseDouble(your_string); Stringdouble 로 변환하는 방법

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

방법 :

 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 객체를 생성하고 다른 모든 메소드 - 원시 int를 생성합니다.

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


그냥 재미를 위해 : 자바 8의 Optional 을 사용하여 StringInteger 로 변환 할 수 있습니다.

String str = "123";
Integer value = Optional.of(str).map(Integer::valueOf).get();
// Will return the integer value of the specified string, or it
// will throw an NPE when str is null.

value = Optional.ofNullable(str).map(Integer::valueOf).orElse(-1);
// Will do the same as the code above, except it will return -1
// when srt is null, instead of throwing an NPE.

여기서 Integer.valueOfOptinal 결합합니다. 아마도 이것이 유용 할 때가있을 수 있습니다 - 예를 들어 null 검사를 피하고자 할 때. Pre Java 8 코드는 다음과 같습니다.

Integer value = (str == null) ? -1 : Integer.parseInt(str);

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

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

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

  • valueOfjava.lang.Integer 의 새 인스턴스 또는 캐시 된 인스턴스를 반환합니다.
  • parseInt 는 원시적 인 int .

Short.valueOf / parseShort , Short.valueOf / parseLong 등 모든 경우에 동일하게 적용됩니다.


이 코드는 몇 가지 예방책과 함께 사용할 수 있습니다.

  • 옵션 # 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 값을 반환하지 않기 때문에 문자열 상수를 비교 또는 모든 종류의 컴퓨팅에 사용하는 것은 항상 좋은 생각입니다.


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

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

그러나 이것이 음수가 아닌 숫자에 대해서만 작동한다는 경고를받습니다.


숫자가 항상 유효한 정수가 될 것이라는 점을 명심하는 프로그래밍 경연 대회에서, 당신은 입력을 분석하기위한 독자적인 방법을 쓸 수 있습니다. 이렇게하면 (모든 필요가 없으므로) 모든 유효성 검사 관련 코드를 건너 뛰고 더 효율적입니다.

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

또한 public static Integer decode(String nm) throws NumberFormatException 사용하여 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

Integer 대신 int 를 얻으려면 다음을 사용할 수 있습니다.

  1. 언 박싱 :

    int val = Integer.decode("12"); 
    
  2. intValue() :

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

new Scanner("1244").nextInt() 사용할 수 있습니다. 또는 int가 존재하는지 질문하십시오 : new Scanner("1244").hasNextInt()







type-conversion