Khác nhau giữa parseInt () và valueOf () trong java?

Làm thế nào parseInt()khác với valueOf()?

Họ dường như làm chính xác điều tương tự với tôi (cũng parseFloat()vậy parseDouble(), parseLong()v.v., họ khác nhau như thế nào Long.valueOf(string)?

Ngoài ra, cái nào trong số này là thích hợp hơn và được sử dụng thường xuyên hơn theo quy ước?

Chà, API Integer.valueOf(String)thực sự nói rằng nó Stringđược diễn giải chính xác như thể nó được trao cho Integer.parseInt(String). Tuy nhiên, valueOf(String)trả về một đối tượng trong khi trả về một nguyên thủy .new Integer()parseInt(String)int

Nếu bạn muốn tận hưởng những lợi ích bộ nhớ cache tiềm năng của Integer.valueOf(int), bạn cũng có thể sử dụng đôi mắt này:

Integer k = Integer.valueOf(Integer.parseInt("123"))

Bây giờ, nếu những gì bạn muốn là đối tượng và không phải là nguyên thủy, sau đó sử dụng valueOf(String)có thể hấp dẫn hơn làm cho một đối tượng mới ra khỏi parseInt(String)bởi vì trước đây là liên tục có mặt trên Integer, Long, Doublevv

Từ diễn đàn này :

parseInt()trả về kiểu nguyên nguyên ( int ), theo đó valueOftrả về java.lang.Integer , là đại diện đối tượng của số nguyên. Có những trường hợp bạn có thể muốn một đối tượng Integer, thay vì kiểu nguyên thủy.

Tất nhiên, một sự khác biệt rõ ràng khác là intValue là một phương thức cá thể, theo đó parseInt là một phương thức tĩnh.

Integer.valueOf(s)

tương tự như

new Integer(Integer.parseInt(s))

Sự khác biệt là valueOf()trả về một Integervà parseInt()trả về một int(kiểu nguyên thủy). Cũng lưu ý rằng valueOf()có thể trả về một thể hiện được lưu trong bộ nhớ cache Integer, điều này có thể gây ra kết quả khó hiểu trong đó kết quả của các ==xét nghiệm dường như không chính xác. Trước khi autoboxing có thể có sự khác biệt về sự thuận tiện, sau java 1.5, điều đó không thực sự quan trọng.

Hơn nữa, Integer.parseInt(s)có thể lấy kiểu dữ liệu nguyên thủy là tốt.

Nhìn vào các nguồn Java: valueOfđang sử dụng parseInt:

/**
 * Parses the specified string as a signed decimal integer value.
 *
 * @param string
 *            the string representation of an integer value.
 * @return an {@code Integer} instance containing the integer value
 *         represented by {@code string}.
 * @throws NumberFormatException
 *             if {@code string} cannot be parsed as an integer value.
 * @see #parseInt(String)
 */
public static Integer valueOf(String string) throws NumberFormatException {
    return valueOf(parseInt(string));
}

parseInt trả lại int

/**
 * Parses the specified string as a signed decimal integer value. The ASCII
 * character \u002d ('-') is recognized as the minus sign.
 *
 * @param string
 *            the string representation of an integer value.
 * @return the primitive integer value represented by {@code string}.
 * @throws NumberFormatException
 *             if {@code string} cannot be parsed as an integer value.
 */
public static int parseInt(String string) throws NumberFormatException {
    return parseInt(string, 10);
}

Integer.parseInt chỉ có thể trả về int là kiểu gốc.

Integer.valueOf thực sự có thể cần phải phân bổ một đối tượng Integer, trừ khi số nguyên đó xảy ra là một trong những đối tượng được preallocated. Chi phí này nhiều hơn.

Nếu bạn chỉ cần loại bản địa, sử dụng parseInt. Nếu bạn cần một đối tượng, sử dụng valueOf.

Ngoài ra, do sự phân bổ tiềm năng này, autoboxing không thực sự là điều tốt về mọi mặt. Nó có thể làm chậm mọi thứ.

Các biến thể parse * trả về các kiểu nguyên thủy và các phiên bản valueOf trả về các Đối tượng. Tôi tin rằng các phiên bản valueOf cũng sẽ sử dụng nhóm tham chiếu nội bộ để trả về đối tượng CÙNG cho một giá trị nhất định, không chỉ là một phiên bản khác có cùng giá trị nội bộ.

Bởi vì bạn có thể đang sử dụng jdk1.5 + và ở đó nó tự động chuyển đổi sang int. Vì vậy, trong mã của bạn, số nguyên trả về đầu tiên của nó và sau đó tự động chuyển đổi thành int.

mã của bạn giống như

int abc = new Integer(123);

Nếu bạn kiểm tra lớp Integer, bạn sẽ thấy giá trị đó gọi phương thức parseInt. Sự khác biệt lớn là bộ nhớ đệm khi bạn gọi API valueof. Nó lưu cache nếu giá trị nằm trong khoảng từ -128 đến 127 Vui lòng tìm bên dưới liên kết để biết thêm thông tin

http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html

giá trị tĩnh công khai valueOf (Chuỗi s)

1. Đối số được hiểu là đại diện cho một số nguyên thập phân có chữ ký, chính xác như thể đối số được đưa ra cho phương thức parseInt (java.lang.String).

2. Kết quả là một đối tượng Integer đại diện cho giá trị nguyên được chỉ định bởi chuỗi.

3. Nói cách khác, phương thức này trả về một đối tượng Integer bằng giá trị của: Integer mới (Integer.parseInt (s))

• valueOf - chuyển đổi sang lớp Wrapper
• parseInt - chuyển đổi sang kiểu nguyên thủy

Integer.parseInt chỉ chấp nhận Chuỗi và trả về kiểu nguyên nguyên (int).

   public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

Iteger.valueOf chấp nhận int và String. Nếu giá trị là String, valueOf chuyển đổi nó thành int đơn giản bằng cách sử dụng parseInt và trả về Integer mới nếu đầu vào nhỏ hơn -128 hoặc lớn hơn 127. Nếu đầu vào nằm trong phạm vi (-128 - 127), nó luôn trả về các đối tượng Integer từ một IntegerCache nội bộ. Lớp Integer duy trì một lớp IntegerCache tĩnh bên trong, đóng vai trò là bộ đệm và giữ các đối tượng nguyên từ -128 đến 127 và đó là lý do tại sao khi chúng ta cố gắng lấy đối tượng số nguyên cho 127 (ví dụ), chúng ta luôn nhận được cùng một đối tượng.

Iteger.valueOf(200)sẽ cung cấp cho Integer mới từ 200. Nó new Integer(200) Iteger.valueOf(127)giống như Integer = 127;

Nếu bạn không chuyển đổi String sang Integer, hãy sử dụng Iteger.valueOf.

Nếu bạn không chuyển đổi String sang sử dụng int đơn giản Integer.parseInt. Nó hoạt động nhanh hơn.

  public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

  public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
  }

  private static class IntegerCache {
      static final int low = -128;
      static final int high;
      static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
  }

Và so sánh Integer.valueOf (127) == Integer.valueOf (127) trả về true

Integer a = 127; // Compiler converts this line to Integer a = Integer.valueOf(127);
Integer b = 127; // Compiler converts this line to Integer b = Integer.valueOf(127);
a == b; // return true 

Bởi vì nó lấy các đối tượng Integer có cùng tham chiếu từ bộ đệm.

Nhưng Integer.valueOf (128) == Integer.valueOf (128) là sai, vì 128 nằm ngoài phạm vi IntegerCache và nó trả về Integer mới, do đó các đối tượng sẽ có các tham chiếu khác nhau.

1. Trong trường hợp ValueOf -> nó đang tạo một đối tượng Integer. không phải là một kiểu nguyên thủy và không phải là một phương thức tĩnh.
2. Trong trường hợp ParseInt.PudeFloat -> nó trả về kiểu nguyên thủy tương ứng. và là một phương thức tĩnh.

Chúng ta nên sử dụng bất kỳ một tùy thuộc vào nhu cầu của chúng tôi. Trong trường hợp ValueOf vì nó đang khởi tạo một đối tượng. nó sẽ tiêu tốn nhiều tài nguyên hơn nếu chúng ta chỉ cần giá trị của một số văn bản thì chúng ta nên sử dụng parseInt, parseFloat, v.v.