it-swarm-ko.tech

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

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

My String은 숫자 만 포함하고 있으며 그 숫자가 나타내는 값을 반환하려고합니다.

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

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

Java Documentation 을 보면 "catch"가이 함수가 NumberFormatException을 던질 수 있다는 것을 알 수 있습니다. 물론 처리해야합니다 :

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

(이 치료법은 기형의 숫자를 0로 기본 설정하지만 원하는 경우 다른 것을 할 수 있습니다.)

또는 Guava 라이브러리의 Ints 메서드를 사용할 수 있습니다.이 메서드는 Java 8의 Optional과 함께 문자열을 int로 변환하는 강력하고 간결한 방법을 제공합니다.

import com.google.common.primitives.Ints;

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

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

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

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

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

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

629
smas

글쎄요, 고려해야 할 중요한 점은 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.
}

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

230
Ali Akdurak

수동으로 수행하십시오.

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

현재 저는 위와 같은 특정 표현식을 사용할 수없는 대학 과제를 수행하고 있으며 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의 2 개의 복식을 가지고 있지만, 12로 바꾸어야합니다. 우리가 할 수있는 수학 연산이 없습니다.

우리는 후자 (lastdigit)를 2/10 = 0.2 (따라서 왜 double) 형식으로 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"표현식이 없습니다.
42
Oak

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

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

문자열이 잘못된 숫자 형식이면 항상 0이 반환되므로 Apache 유틸리티는 Nice입니다. 따라서 try catch 블록을 절약 할 수 있습니다.

Apache NumberUtils API 버전 3.4

40
Ryboflavin

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();
    
32
ROMANIA_engineer

주어진 문자열에 Integer가 포함되지 않을 가능성이 거의 없으면이 특별한 경우를 처리해야합니다. 안타깝게도 표준 Java 메소드 Integer::parseIntInteger::valueOf는이 특별한 경우를 알리기 위해 NumberFormatException을 던집니다. 따라서 일반적으로 잘못된 코딩 스타일로 간주되는 흐름 제어에 예외를 사용해야합니다.

제 생각에는이 특별한 경우는 Optional<Integer>를 반환해야합니다. 자바는 그런 방법을 제공하지 않기 때문에 다음 wrapper를 사용한다.

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

용법:

// prints 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

내부적으로 흐름 제어에 대한 예외가 여전히 사용되고 있지만 사용 코드는 매우 깨끗합니다.

25
Stefan Dollase

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

  • 문자열에 숫자 만 포함되어 있습니까 0-9?
  • 문자열 앞뒤에 -/+이 (가) 있습니다. 가능합니까 (회계 번호 참조)?
  • MAX _-/MIN_INFINITY? 문자열이 999999999999999999 인 경우 어떻게됩니까? 기계가이 문자열을 int로 처리 할 수 ​​있습니까?
23
Dennis Ahaus

방법 :

 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를 생성합니다.

마지막 2 가지 방법은 commons-lang3here 로 변환하는 것에 대한 큰 기사입니다.

22
Dmytro Shvechikov

문자열 값을 정수 값으로 변환하기 위해 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);
22
Giridhar Kumar

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

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

Integer.parseInt("1"); // ok

Integer.parseInt("-1"); // ok

Integer.parseInt("+1"); // ok

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

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

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

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

하나의 예외 유형 만 있습니다 : NumberFormatException

19
Lukas Bauer

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

그냥 재미로보기 : 자바 8의 OptionalStringInteger으로 변환하는 데 사용할 수 있습니다.

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);
17
Anton Balaniuc

구아바에는 tryParse (String) 이 있는데, 문자열을 파싱 할 수없는 경우 null을 반환합니다. 예를 들면 다음과 같습니다.

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

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

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

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

14
Thijser

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

    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
  }
12
nxhoaf

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

  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()을 수행하십시오.

9
Raman Sahasi

언급했듯이 Apache Commons NumberUtils은이를 수행 할 수 있습니다. 문자열을 int로 변환 할 수없는 경우 0를 반환합니다.

고유 한 기본값을 정의 할 수도 있습니다.

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; 
9
Alireza Fattahi

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

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

9
manikant gautam

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

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

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

7
iKing

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());
7
Aditya

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

  • Stringint으로 변환하려면 Integer.parseInt(your_string);을 사용하십시오.
  • Stringdouble으로 변환하려면 Double.parseDouble(your_string);을 사용하십시오.

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
7
Vishal Yadav

여기에 우리가 간다.

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

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

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

Java 8 - 정수 (문자열)

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


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

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

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

한 가지 방법은 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);
5
Pankaj Mandale

이것은 라이브러리를 사용하지 않고 모든 조건이 양수이고 음수 인 Complete 프로그램입니다.  

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;
     }
    }
4
Anup Gupta

Integer.parseInt(myString); - 래퍼 클래스 사용

3
Phani Kumar

5 가지 방법으로 할 수 있습니다 :

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

1) Ints.tryParse 사용 :

String number = "999";
int result = Ints.tryParse(number);

2) NumberUtils.createInteger 사용 :

String number = "999";
Integer result = NumberUtils.createInteger(number);

3) NumberUtils.toInt 사용 :

String number = "999";
int result = NumberUtils.toInt(number);

4) Integer.valueOf 사용 :

String number = "999";
Integer result = Integer.valueOf(number);

5) Integer.parseInt 사용 :

String number = "999";
int result = Integer.parseInt(number);
3
Santosh Jadi

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

int i = Integer.parseInt(null);

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

3
Pavel Molchanov

당신은 다음 중 하나를 사용할 수 있습니다 : 

  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)
2
Rajeev Ranjan

import Java.util. *;

public class strToint {

    public static void main(String[] args){

            String str = "123";

            byte barr[] = str.getBytes();

            System.out.println(Arrays.toString(barr));
            int result=0;
            for(int i=0;i<barr.length;i++){
                    //System.out.print(barr[i]+" ");
                    int ii = barr[i];
                    char a = (char)ii;
                    int no = Character.getNumericValue(a);
                    result=result*10+no;
                    System.out.println(result);

            }
            System.out.println("result:"+result);
    }

}

2
Abhijeet Kale

public static int parseInt (String s) throws NumberFormatException

문자열을 int로 변환하기 위해 사용자 Integer.parseInt()을 사용할 수 있습니다.

string 20을 원시적 int로 변환합니다.

    String n = "20";
    int r = Integer.parseInt(n);//returns a primitive int       
    System.out.println(r);

출력 - 20

캐릭터 라인에 해석 가능한 정수가없는 경우 그것은 NumberFormatException 던져 질 것이다

String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

public static 정수 valueOf (String s) throws NumberFormatException

Integer.valueOf()을 사용할 수 있습니다.이 경우 Integer 객체를 반환합니다.

String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.   
System.out.println(r);

출력 - 20

참고 문헌 https://docs.Oracle.com/en/

1

StringInt으로 변환하는 몇 가지 방법은 다음과 같습니다.

  1. Integer.parseInt()을 사용할 수 있습니다.

    String test = "4568"; int new = Integer.parseInt(test);

  2. 또한 Integer.valueOf()을 사용할 수 있습니다.

    String test = "4568"; int new =Integer.parseInt(test);

0

Java Integer 클래스의 parseInt 메소드를 사용하여 문자열을 정수로 변환하십시오. parseInt 메서드는 문자열을 int로 변환하고 문자열을 int 유형으로 변환 할 수없는 경우 NumberFormatException을 발생시킵니다.

던져 넣을 수있는 예외를 간과하면 다음과 같이 사용하십시오.

int i = Integer.parseInt(myString);

myString 변수가 나타내는 문자열이 “1234”, “200”, “1”,와 같은 유효한 정수이고 Java int로 변환됩니다. 어떤 이유로 든 실패하면 변경으로 인해 NumberFormatException이 throw 될 수 있으므로 코드는이를 설명하기 위해 조금 더 길어야합니다.

전의. Java String - int 변환 방법, 가능한 NumberFormatException 제어

public class JavaStringToIntExample
{
  public static void main (String[] args)
  {
    // String s = "test";  // use this if you want to test the exception below
    String s = "1234";

    try
    {
      // the String to int conversion happens here
      int i = Integer.parseInt(s.trim());

      // print out the value after the conversion
      System.out.println("int i = " + i);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

변경 시도가 실패하는 경우 - Java String 테스트를 int로 변환하려고하면 Integer parseInt 프로세스가 try/catch 블록에서 처리해야하는 NumberFormatException을 발생시킵니다.

0
Nisarg

parseInt 메소드를 사용할 수 있습니다.  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790
0
Sunil Dhappadhule

사용자 정의 알고리즘 :

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

또 다른 해결책 : (문자열을 바이트 배열로 변환하는 대신 charAt 메서드를 사용하십시오.) :

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

예 :

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}
0
nabeghe

메서드 사용 : Integer.parseInt(String s)

String s = "123";
int n = Integer.parseInt(s);
0
karthik_varma_k

Integer.parseInt()을 사용하면 문자열 값을 int로 파싱하는 데 도움이됩니다.

예:

String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);

출력 : 2017

0
Alekya

이 방법을 사용하십시오.

public int ConvertStringToInt(String number)
{
 int num = 0;
 try
 {
   int newNumber = Integer.ParseInt(number);
   num = newNumber;
 }
 catch(Exception ex)
 {
   num = 0;
   Log.i("Console",ex.toString);
 }
   return num;
}
0
mohamad sheikhi

다음 코드를 String의 다른 입력으로 시도하십시오.

String a = "10";  
String a = "10ssda";  
String a = null; 
String a = "12102";

if(null != a) {
    try {
        int x = Integer.ParseInt(a.trim()); 
        Integer y = Integer.valueOf(a.trim());
        //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
    } catch(NumberFormatException ex) {
        // ex.getMessage();
    }
}
0
Ram Chhabra

Int 또는 long으로 문자열 입력을 파싱하려면이 빠른 방법을 썼다. 현재의 JDK 11 Integer.parseInt 또는 Long.parseLong보다 빠릅니다. 비록 int에 대해서만 요청했지만 긴 파서도 포함했습니다. 아래의 코드 파서는 구문 분석기의 메서드가 작아서 신속하게 작동해야한다고 요구합니다. 대안 버전은 테스트 코드 아래에 있습니다. 대체 버전은 꽤 빠르며 클래스의 크기에 의존하지 않습니다.

이 클래스는 오버플로를 확인하고 필요에 맞게 코드를 사용자 정의 할 수 있습니다. 빈 문자열은 내 메서드로 0을 반환하지만 이는 의도적 인 것입니다. 당신은 당신의 사건을 적응 시키거나 그대로 사용하도록 그것을 바꿀 수 있습니다. 

이것은 parseInt와 parseLong이 필요한 클래스의 일부일뿐입니다. 이것은 기본 10 숫자 만 처리합니다.

Int 파서의 테스트 코드는 아래 코드와 같습니다. 

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected]
 **/
final class faiNumber{        
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                           };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000 
                                        };

    /**
     * parseLong(String str) parse a String into Long. 
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0L;        

        char c1 = str.charAt(0); int start;

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }
        /*
         * Note: if length > 19, possible scenario is to run through the string 
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if ( length - start > 19 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );

        long c; 
        long out = 0L;

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1L;
            // if out > 0 number underflow(supposed to be negative).
            if ( out > 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            return out;
        }
        // if out < 0 number overflow(supposed to be positive).
        if ( out < 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty. 
     **/
    public static int parseInt(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0;        

        char c1 = str.charAt(0); int start; 

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if ( runlen > 9 ) {
            if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

            c = (str.charAt(start) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1;
            if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            return out;
        }

        if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }
}

테스트 코드 섹션. 이것은 약 200 초 정도 걸릴 것입니다.

// Int Number Parser Test;
long start = System.currentTimeMillis();    
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if( faiNumber.parseInt(""+i) != i ) System.out.println("Wrong");
   if ( i == 0 ) System.out.println("HalfWay Done");
}

if( faiNumber.parseInt(""+Integer.MAX_VALUE) != Integer.MAX_VALUE ) System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);        
// INT PARSER END */

매우 빠른 대체 방법. int pow의 배열은 사용되지 않지만 비트 단위로 10을 곱하는 수학적 최적화가 사용됩니다.

public static int parseInt(final String str) { 
    final int length = str.length();
    if ( length == 0 ) return 0;        

    char c1 = str.charAt(0); int start; 

    if ( c1 == '-' || c1 == '+' ){
        if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
        start = 1;
    } else {
        start = 0;
    }

    int out = 0; int c;
    while( start < length && str.charAt(start) == '0' ) start++; // <-- This to disregard leading 0, can be removed if you know exactly your source does not have leading zeroes.
    int runlen = length - start;

    if ( runlen > 9 ) {
        if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

        c = (str.charAt(start++) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; // <- alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++){
        c = (str.charAt(start) ^ '0');
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; 
    }

    if ( c1 == '-' ){
        out = ~out + 1;
        if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }

    if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
    return out;
}
0
Kevin Ng