Метод valueof () на языке Java

Java

Метод JavaString valueOf() возвращает строковое представление аргументов boolean, char, char array, int, long, float и double. У нас есть разные версии этого метода для каждого типа аргументов. Метод JavaString valueOf() возвращает строковое представление аргументов boolean, char, chararray, int, long, float и double. У нас есть разные версии этого метода для каждого типа аргументов.

Простой пример JavaString valueOf()

Давайте возьмем простой пример, чтобы понять использование этого метода. В этом примере мы связываем двойные девятки с концом данного значения. Данное значение является целым числом, и для того, чтобы добавить 99 в конце целого числа, мы должны сначала преобразовать данное целое число в строку. Мы используем метод valueOf() для преобразования числа в эквивалентную строку str, а затем объединяем 99 в конце преобразованной строки.

Метод valueof () на языке Java

Метод valueOf()

Пример:

public class JavaExample{
public static void main(String args[]){
char vowel[] = {‘B’, ‘G’, ‘H’, ‘P’, ‘Q’};
String str = String.valueOf(гласный);
System.out.println(str);
}
}

Выход:

BGHPQ

Автобокс и распаковка

Последнее, что нам нужно понять, прежде чем мы сможем узнать о равенстве и сравнении, — это бокс.
Несмотря на то, что примитивы и ссылки на объекты имеют различную семантику, они могут использоваться взаимозаменяемо, благодаря компилятору Java.

Автобокс — это автоматическое преобразование примитивных типов в соответствующий им класс-оболочку, а распаковка-это другое направление. Это позволяет нам использовать оба вида типов без дискриминации:

List<Integer>values = newArrayList<>();

for (int i = 0; i < 50; i++>) {
values.add(i);
}

Наш список использует тип оболочки Integer, но наш код компилируется, даже если мы добавляем int. Это возможно благодаря компилятору, изменяющему наш код путем автобокса i:

List<Integer> values = new ArrayList<>();
for (int i = 0; i < 50; i++>) {
values.add(Integer.valueOf(i));
}

То же самое верно и для другого пути:

intsumEven(List<Integer> values) {
intf= 0;
for (Integer summand: values) {
if (summand % 2 == 0) {
f += summand;
}
}
return f;
}

Несмотря на то, что мы используем такие операторы, как % и+, которые недоступны объектному типу Integer, код компилируется нормально. Потому что компилятор распаковывает тип оболочки. Фактический скомпилированный код выглядит примерно так:

intsumEven(List<Integer> values) {
intresult = 0;
for (Целочисленное слагаемое: значения) {
if (i.intValue() % 2 == 0) {
результат += i.intValue();
}
}
возвращаемый результат;
}

Равенство

Если мы посмотрим на другие языки программирования, то наиболее логичным выводом для сравнения значений может быть оператор == и его антагонист !=. Да, мы можем использовать их для проверки равенства, и они сравнивают значения друг с другом, но это может быть не то значение, которое вы ожидаете.

Пробуем написать программу равенства объектов для двух целочисленных ссылок на объекты i1 и i2. Даже если они не указывают на один и тот же объект (i1 != i2), i1.equals(i2) будет истинным до тех пор, пока они представляют одно и то же целое число

Выполните следующий код. Это прояснит ваши сомнения относительно == и equals для целочисленных объектов:

public static void main(String[] args) {
integerq1 = new integer(5);
integerq2 = new Integer(5);

System.out.println(q1 == q2); // ложь
System.out.println(i1.equals(q2)); /правда
q1 = 10;
q2 = 10;

System.out.println(q1 == q2); //правда
System.out.println(i1.equals(q2));//правда

q1 = Integer.valueOf(7);
q2 = Integer.valueOf(7);

System.out.println(q1 == q2);//правда
System.out.println(i1.equals(q2));//правда

q1 = Integer.parseInt(«9»);
q2 = Integer.parseInt(«9»);

System.out.println(q1 == q2);//правда
System.out.println(i1.equals(q2));//правда
}

Примитивы

Примитивы-это литералы, фиксированные значения в памяти, которые можно проверить на равенство с ==.
За исключением тех случаев, когда они не могут. В отличие от других примитивных типов данных, типы данных с плавающей запятой float и double не могут быть надежно проверены на равенство с = = из-за их способа хранения в памяти. Это не точные значения:

floatvalue = 1.0q;
value += 0.1q; // 1.1q
value += 0.1q; // 1.2q
value += 0.1q; // 1.3000001q

boolean is Equal = (value == 1.3q) // ложь

У нас есть два варианта. Либо с помощью java.util.BigDecimal, что является точным. Или с помощью пороговых сравнений:

7 значение
поплавка = 1,0 f;
значение += 0.1 f; // 1.1 f
значение += 0.1 f; // 1.2 f
значение += 0.1 f; // 1.3000001 f

ПОРОГ ПОПЛАВКА = 0,00001 f;
booleanisEqual = Math.abs(value — 1.3 f) < THRESHOLD); // true

Оцените статью
Образовательный портал WELCOME4U.RU
Добавить комментарий

Adblock
detector