Различаются между parseInt () и valueOf () в Java?

Чем parseInt()отличается от valueOf()?

Они , кажется, делать то же самое для меня (также касается parseFloat(), parseDouble(), и parseLong()т.д., как они отличаются от Long.valueOf(string)?

Кроме того, какой из них предпочтительнее и используется чаще всего по соглашению?

Что ж, API для Integer.valueOf(String)действительно говорит, что Stringинтерпретируется точно так, как если бы оно было дано Integer.parseInt(String). Однако valueOf(String)возвращает объект, тогда как возвращает примитив .new Integer()parseInt(String)int

Если вы хотите воспользоваться потенциальными преимуществами кэширования Integer.valueOf(int), вы также можете использовать это раздражение глаз:

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

Теперь, если то , что вы хотите , это объект , а не примитивный, а затем с помощью valueOf(String)может быть более привлекательным , чем создание нового объекта из parseInt(String)потому что бывший последовательно присутствует через Integer, Long, Doubleи т.д.

С этого форума :

parseInt()возвращает примитивный целочисленный тип ( int ), посредством чего valueOfвозвращает java.lang.Integer , который является объектом, представляющим целое число. В некоторых случаях вам может потребоваться объект типа Integer вместо примитивного типа.

Конечно, еще одно очевидное отличие состоит в том, что intValue является методом экземпляра, в котором parseInt является статическим методом.

Integer.valueOf(s)

похоже на

new Integer(Integer.parseInt(s))

Разница в том, что valueOf()возвращает Integerи parseInt()возвращает int(примитивный тип). Также обратите внимание, что valueOf()может возвращать кешированный Integerэкземпляр, что может привести к сбивающим с толку результатам, если результаты ==тестов кажутся периодически правильными. До автобокса может быть разница в удобстве, после Java 1.5 это не имеет большого значения.

Более того, Integer.parseInt(s)может принимать и примитивный тип данных.

Посмотрите на источники Java: valueOfиспользует 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 возвращается 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 может просто вернуть int как нативный тип.

Integer.valueOf на самом деле может потребоваться выделить объект Integer, если только это целое число не является одним из предварительно выделенных. Это стоит дороже.

Если вам нужен только нативный тип, используйте parseInt. Если вам нужен объект, используйте valueOf.

Кроме того, из-за этого потенциального распределения, автобокс не очень хорошая вещь во всех отношениях. Это может замедлить вещи.

Варианты parse * возвращают примитивные типы, а версии valueOf возвращают Objects. Я полагаю, что версии valueOf также будут использовать внутренний пул ссылок для возврата одного и того же объекта для данного значения, а не просто другого экземпляра с таким же внутренним значением.

Потому что вы можете использовать jdk1.5 + и там он автоматически конвертируется в int. Таким образом, в вашем коде сначала возвращается Integer, а затем автоматически преобразуется в int.

ваш код такой же, как

int abc = new Integer(123);

Если вы проверите класс Integer, вы найдете это значение вызова метода parseInt. Большая разница заключается в кешировании, когда вы вызываете valueof API. Он кэшируется, если значение находится в диапазоне от -128 до 127. Более подробную информацию вы найдете под ссылкой.

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

public static Integer valueOf (String s)

1. Аргумент интерпретируется как представляющий десятичное целое со знаком, точно так же, как если бы аргумент был передан методу parseInt (java.lang.String).

2. Результатом является объект Integer, представляющий целочисленное значение, указанное в строке.

3. Другими словами, этот метод возвращает объект Integer, равный значению: new Integer (Integer.parseInt (s))

• valueOf - конвертирует в класс Wrapper
• parseInt - конвертирует в примитивный тип

Integer.parseInt принимает только String и возвращает примитивный целочисленный тип (int).

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

Iteger.valueOf принимает int и String. Если значением является String, valueOf преобразует его в простое int, используя parseInt, и возвращает новое Integer, если входное значение меньше -128 или больше 127. Если входное значение находится в диапазоне (-128 - 127), оно всегда возвращает объекты Integer из внутренний IntegerCache. Целочисленный класс поддерживает внутренний статический класс IntegerCache, который действует как кеш и содержит целочисленные объекты от -128 до 127, и поэтому, когда мы пытаемся получить целочисленный объект для 127 (например), мы всегда получаем один и тот же объект.

Iteger.valueOf(200)даст новое целое число от 200. Это как new Integer(200) Iteger.valueOf(127)то же самое, что и Integer = 127;

Если вы хотите конвертировать String в Integer, используйте Iteger.valueOf.

Если вы хотите конвертировать String в простой int, используйте Integer.parseInt. Работает быстрее.

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

И сравнивая Integer.valueOf (127) == Integer.valueOf (127) возвращает 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 

Потому что он берет объекты Integer с одинаковыми ссылками из кэша.

Но Integer.valueOf (128) == Integer.valueOf (128) имеет значение false, поскольку значение 128 выходит за пределы диапазона IntegerCache и возвращает новое значение Integer, поэтому объекты будут иметь разные ссылки.

1. В случае ValueOf -> это создает объект Integer. не примитивный тип и не статический метод.
2. В случае ParseInt.ParseFloat -> он возвращает соответствующий тип примитива. и является статическим методом.

Мы должны использовать любой в зависимости от наших потребностей. В случае ValueOf, как это экземпляр объекта. он потребляет больше ресурсов, если нам нужно только значение некоторого текста, тогда мы должны использовать parseInt, parseFloat и т. д.