it-swarm-vi.com

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

Làm cách nào tôi có thể chuyển đổi String thành int trong 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ụ: với chuỗi "1234", kết quả sẽ là số 1234.

2725
Unknown user
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 "bắt" là chức năng này có thể ném 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 thành 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 phương thức Ints từ thư viện Guava, kết hợp với Optional của Java 8, 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)
3787
Rob Hruska

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
  • parseInt trả 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.

629
smas

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ì đó.

230
Ali Akdurak

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

Hiện tại tôi đang thực hiện một 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 xem bảng ASCII, tôi đã xoay sở để thực hiện. Đó 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ó là 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à thực tế là tôi không thể sử dụng các chu kỳ lặp đi lặp lại, do đó, một chu trình for (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 charAt đơn giản đã giả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ó bất kỳ thao tác toán học nào chúng tôi có thể làm.

Chúng tôi chia số sau (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
42
Oak

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

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

Tiện ích Apache là Nice 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ử.

Apache NumberUtils API Phiên bản 3.4

40
Ryboflavin

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 int thay vì Integer bạn có thể sử dụng:

  1. Bỏ hộp:

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

    _Integer.decode("12").intValue();
    _
33
ROMANIA_engineer

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::parseIntInteger::valueOf ném 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 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();
    }
}

Sử dụng:

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

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

25
Stefan Dollase

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:

  • Chuỗi có chứa số 0-9 không?
  • 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?
23
Dennis Ahaus

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 thức cuối cùng từ commons-lang3 và bài viết lớn về chuyển đổi tại đây .

22
Dmytro Shvechikov

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

Ví dụ:

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

Lớp Integer cũng cung cấp phương thức valueOf(String str):

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

Chúng tôi cũng có thể sử dụng toInt(String strValue) của Lớp tiện ích NumberUtils để chuyển đổi:

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

Sử dụng Integer.parseInt(yourString)

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

Integer.parseInt("1");/ ok

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

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

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

Integer.parseInt("2147483648"); // Ngoại lệ (Số nguyên bị 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 gì đó)

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

19
Lukas Bauer

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

Chỉ để giải trí: Bạn có thể sử dụng Optional của Java 8 để chuyển đổi String thành Integer:

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.

Ở đây chúng tôi chỉ kết hợp Integer.valueOfOptinal. Có thể có những tình huống khi điều này hữu ích - ví dụ khi bạn muốn tránh kiểm tra null. Mã Java 8 trước sẽ trông như thế này:

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

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

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

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 cú pháp int:

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. 

14
Thijser

Ngoài những câu trả lời trên, tôi muốn thêm một số chức năng: 

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

Và đây là kết quả trong khi bạn chạy 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
  }
12
nxhoaf

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.

9
Raman Sahasi

Như đã đề cập Apache Commons NumberUtils có thể làm điều đó. Trả về 0 nếu nó không thể chuyển đổi 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; 
9
Alireza Fattahi

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.

9
manikant gautam

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()

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

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

7
iKing

Đối với 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());
7
Aditya

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

  • Sử dụng Integer.parseInt(your_string); để chuyển đổi String thành int
  • Sử dụng Double.parseDouble(your_string); để chuyển đổi String thành double

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

Chúng ta đi đây

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

Tôi hơi ngạc nhiên khi không ai không đề 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ề loại Integer và thao tác unboxing chuyển đổi giá trị thành int


Điều quan trọng là phải đề cập đến
Hàm tạo này gọi phương thức parseInt

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

Sử dụng Integer.parseInt () và đặt nó vào trong khối try...catch để xử lý bất kỳ lỗi nào 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);
    }
 }
5
David

Một phương thức là parseInt (String) 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) trả về một đối tượng Integer () mới.

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

Đây là chương trình Hoàn chỉnh với tất cả các điều kiện tích cực, 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;
     }
    }
4
Anup Gupta

Bạn có thể sử dụng bất kỳ nội dung 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)
4
Rajeev Ranjan

Integer.parseInt(myString); - sử dụng lớp bao bọc

3
Phani Kumar

Có thể được thực hiện theo 5 cách:

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

1) Sử dụng Ints.tryParse:

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

2) Sử dụng NumberUtils.createInteger:

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

3) Sử dụng NumberUtils.toInt:

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

4) Sử dụng Integer.valueOf:

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

5) Sử dụng Integer.parseInt:

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

Nhân tiện, lưu ý rằng nếu chuỗi là null, hãy gọi:

int i = Integer.parseInt(null);

ném NumberFormatException, không phải NullPulumException.

3
Pavel Molchanov

nhập Java.util. *;

lớp công khai 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) ném NumberFormatException

bạn có thể sử dụng Integer.parseInt() để chuyển đổi Chuỗi thành int.

chuyển đổi một chuỗi 20 thành một int nguyên thủy.

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

Đầu ra-20

nếu chuỗi không chứa số nguyên có thể phân tích được. nó sẽ ném NumberFormatException

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

công khai số nguyên tĩnh valueOf (Chuỗi s) ném NumberFormatException

bạn có thể sử dụng Integer.valueOf(), trong đó, nó sẽ trả về một đối tượng Integer.

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

Đầu ra-20

Tài liệu tham khảo https://docs.Oracle.com/en/

1
Poorna Senani Gamage

Một số cách để chuyển đổi String thành Int như sau:

  1. bạn có thể sử dụng Integer.parseInt():

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

  2. bạn cũng có thể sử dụng Integer.valueOf():

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

0
ishant kulshreshtha

Chuyển đổi một chuỗi thành một số nguyên bằng phương thức parseInt của lớp Số nguyên Java. Phương thức parseInt là chuyển đổi Chuỗi thành int và ném NumberFormatException nếu chuỗi không thể được chuyển đổi thành kiểu int.

Nhìn ra ngoại lệ nó có thể ném, sử dụng cái này:

int i = Integer.parseInt(myString);

Nếu Chuỗi được biểu thị bằng biến myString là một số nguyên hợp lệ như “1234”, “200”, “1”, và nó sẽ được chuyển đổi thành int Java. Nếu nó không thành công vì bất kỳ lý do gì, thay đổi có thể tạo ra NumberFormatException, vì vậy mã phải dài hơn một chút để tính đến điều này.

Vd Phương thức chuyển đổi Java String thành int, kiểm soát khả năng NumberFormatException có thể

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

Nếu nỗ lực thay đổi không thành công - trong trường hợp, nếu bạn có thể thử chuyển đổi kiểm tra Chuỗi Java thành int - thì quy trình parseInt sẽ gửi một NumberFormatException, mà bạn phải xử lý trong khối thử/bắt.

0
Nisarg

Bạn có thể sử dụng phương thức parseInt  

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

Thuật toán tùy chỉnh:

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

một giải pháp khác: (sử dụng chuỗi charAt phương thức thay vì chuyển chuỗi thành mảng byte):

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

Ví dụ:

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

Sử dụng phương pháp: Integer.parseInt(String s)

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

Sử dụng Integer.parseInt(), điều này sẽ giúp bạn phân tích giá trị chuỗi của bạn thành int.

Thí dụ:

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

sản lượng: 2017

0
Alekya

Sử dụng phương pháp này:

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

Hãy thử mã này với các đầu vào khác nhau của 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

Tôi đã viết phương thức nhanh này để phân tích một chuỗi đầu vào thành int hoặc long. Nó nhanh hơn JDK 11 Integer.parseInt hoặc Long.parseLong hiện tại. Mặc dù, bạn chỉ yêu cầu int, tôi cũng bao gồm trình phân tích cú pháp dài. Trình phân tích cú pháp mã dưới đây yêu cầu phương thức của trình phân tích cú pháp phải nhỏ để nó hoạt động nhanh. Một phiên bản thay thế nằm dưới mã kiểm tra. Phiên bản thay thế khá nhanh và không phụ thuộc vào quy mô của lớp.

Lớp này kiểm tra tràn và bạn có thể tùy chỉnh mã để thích ứng với nhu cầu của bạn. Một chuỗi rỗng sẽ mang lại 0 với phương thức của tôi nhưng đó là cố ý. Bạn có thể thay đổi điều đó để điều chỉnh trường hợp của bạn hoặc sử dụng như hiện tại. 

Đây chỉ là một phần của lớp mà parseInt và parseLong là cần thiết. Lưu ý rằng điều này chỉ đối phó với 10 số cơ sở.

Mã kiểm tra cho trình phân tích cú pháp int nằm bên dưới mã bên dưới. 

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

Phần mã kiểm tra. Điều này sẽ mất khoảng 200 giây hoặc lâu hơn.

// 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 */

Một phương pháp thay thế cũng rất nhanh. Lưu ý rằng mảng int pow không được sử dụng mà là tối ưu hóa toán học nhân với 10 lần dịch chuyển bit.

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