Разница между parseInt и valueOf в Java?

В чем разница между этими двумя методами? Они, кажется, делают то же самое для меня (также идет для parseFloat(), parseDouble(), parseLong() и т.д., чем они отличаются от Long.valueOf(string)?

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

12 ответов

Решение

Ну, API для Integer.valueOf(String) действительно говорит, что String интерпретируется точно так, как если бы оно было дано Integer.parseInt(String), Тем не мение, valueOf(String) возвращает newInteger() объект тогда как 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.

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

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), если вы хотите получить новое Integer из int 200. Iteger.valueOf(127) не имеет никакого смысла, потому что он такой же, как Integer = 127;

Если вы хотите конвертировать String, например, в новое Integer или 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, поэтому объекты будут иметь разные ссылки.

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

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

int abc = new Integer(123);

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

Если вы проверите класс 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 возвращает новый объект Integer, почему приведенный ниже код верен?

String base5String = "230";
int result = Integer.valueOf(base5String);
  1. В случае ValueOf -> это создает объект Integer. не примитивный тип и не статический метод.
  2. В случае ParseInt.ParseFloat -> он возвращает соответствующий тип примитива. и является статическим методом.

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

Другие вопросы по тегам