Java - разница между double и double в сравнении

Литералы в Java

Литерал — представление исходного кода как фиксированное значение. Оно представлено непосредственно в коде без каких-либо вычислений.

Литерал в Java можно назначить любой переменной из основного типа. Например:

Byte, int, long, и short может выражаться десятичной (основание 10), шестнадцатеричной (основание 16) или восьмеричной (основание системой исчисления.

При использовании литералов в Java, префикс 0 применяться для указания восьмеричной системы, а префикс 0x указывает на шестнадцатеричную систему. Например:

Строковые литералы в языке Java задаются как и в большинстве других языков, заключив последовательность символов между парой двойных кавычек. Примеры строковых литералов:

Типы литералов String и char могут содержать любые символы Юникода. Например:

Язык Java поддерживает несколько специальных управляющих последовательностей для литералов String и char:

Обозначение	Представление
\n	Новая строка (0x0a)
\r	Возврат каретки (0x0d)
\f	Прогон страницы (0x0c)
\b	Возврат на шаг (0x08)
\s	пробел (0x20)
\t	Табуляция
\»	Двойная кавычка
\’	Апостроф
\\	Обратная косая черта
\ddd	Восьмеричный символ (ddd)
\uxxxx	Шестнадцатеричный символ UNICODE (xxxx)

Более подробно управляющие последовательности с примерами рассмотрим в следующих уроках.

Следующий урок объясняет различные типы переменных и их использование. Это даст Вам хорошее представление о том, как они могут использоваться в java-классах, интерфейсах и т.д.

Нецелочисленные Типы Данных

Нецелочисленные типы float и double ведут себя не так, как целочисленные типы данных, когда дело доходит до арифметических операций.

Одно из отличий заключается в том, что арифметические операции с числами с плавающей запятой могут привести к NaN . У нас есть специальная статья о NaN в Java , поэтому мы не будем вдаваться в подробности в этой статье. Кроме того, в пакете Math нет точных арифметических методов, таких как addExact или multiplyExact для нецелочисленных типов.

Java следует стандарту IEEE для арифметики с плавающей запятой (IEEE 754) для своих типов данных float и double|/. Этот стандарт является основой для того, как Java обрабатывает избыточный и недостаточный поток чисел с плавающей запятой.

В нижеприведенных разделах мы сосредоточимся на избыточном и недостаточном потоке двойной тип данных и что мы можем сделать, чтобы справиться с ситуациями, в которых они возникают.

5.1. Переполнение

Что касается целочисленных типов данных, мы могли бы ожидать, что:

assertTrue(Double.MAX_VALUE + 1 == Double.MIN_VALUE);

Однако это не относится к переменным с плавающей запятой. Верно следующее:

assertTrue(Double.MAX_VALUE + 1 == Double.MAX_VALUE);

Это происходит потому, что двойной значение имеет только ограниченное количество значащие биты . Если мы увеличим значение большого двойной значение только на один, мы не меняем ни один из значимых битов. Следовательно, значение остается прежним.

Если мы увеличим значение нашей переменной таким образом, что увеличим один из значимых битов переменной, переменная будет иметь значение БЕСКОНЕЧНОСТЬ :

assertTrue(Double.MAX_VALUE * 2 == Double.POSITIVE_INFINITY);

и NEGATIVE_INFINITY для отрицательных значений:

assertTrue(Double.MAX_VALUE * -2 == Double.NEGATIVE_INFINITY);

Мы видим, что, в отличие от целых чисел, нет обтекания, но есть два разных возможных результата переполнения: значение остается неизменным, или мы получаем одно из специальных значений, POSITIVE_INFINITY или НЕГАТИВНАЯ БЛИЗОСТЬ .

5.2. Недостаточный поток

Существуют две константы, определенные для минимальных значений двойного значения: MIN_VALUE (4,9 e-324) и MIN_NORMAL (2,2250738585072014 E-308).

Стандарт IEEE для арифметики с плавающей запятой (IEEE 754) более подробно объясняет разницу между ними.

Давайте сосредоточимся на том, зачем нам вообще нужно минимальное значение для чисел с плавающей запятой.

A двойной значение не может быть произвольно малым, так как у нас есть только ограниченное количество битов для представления значения.

Глава о в спецификации языка Java SE описывает, как представлены типы с плавающей запятой. Минимальный показатель степени для двоичного представления double задается в виде -1074 . Это означает, что наименьшее положительное значение , которое может иметь двойник, равно Math.pow(2, -1074) , что равно 4,9 e-324 .

Как следствие, точность double в Java не поддерживает значения между 0 и 4,9 e-324, или между -4,9 e-324 и для отрицательных значений.

Итак, что произойдет, если мы попытаемся присвоить слишком маленькое значение переменной типа double ? Давайте рассмотрим пример:

for(int i = 1073; i <= 1076; i++) {
    System.out.println("2^" + i + " = " + Math.pow(2, -i));
}

С выходом:

2^1073 = 1.0E-323
2^1074 = 4.9E-324
2^1075 = 0.0
2^1076 = 0.0

Мы видим, что если мы назначим слишком малое значение, мы получим недостаточный поток, и результирующее значение будет 0.0 (положительный ноль). Аналогично, при отрицательных значениях недостаточный поток приведет к значению -0.0 (отрицательный ноль).

Большие числа BigInteger и BigDecimal

Последнее обновление: 10.11.2018

Встроенные примитивные числовые типы не всегда могут подходить для определенных программ. Например, необходимо хранить и использовать в
программе очень большие числа, которые выходят за пределы допустимых значений для типов long и double. В этом случае для работы с числовыми данными можно использовать два дополнительных типа из
пакета java.math — BigInteger (для целочисленных данных) и BigDecimal (для чисел с плавающей точкой).

Основные методы класса BigInteger:

: возвращает сумму двух чисел
: возвращает разность двух чисел
: возвращает произведение двух чисел
: возвращает частное двух чисел
: возвращает остаток от целочисленного деления двух чисел
: возвращает квадратный корень числа
: сравнивает два числа. Возвращает -1, если текущий объект меньше числа other, 1 — если текущий объект больше и 0 — если числа равны
: возвращает объект BigInteger, значение которого равно числу, переданному в качестве параметра
: конвертирует объект BigInteger в объект int
: преобразует объект BigInteger в byte
: преобразует объект BigInteger в short
: преобразует объект BigInteger в long

Основные методы класса BigDecimal:

: возвращает сумму двух чисел
: возвращает разность двух чисел
: возвращает произведение двух чисел
: возвращает частное двух чисел
: результат деления двух чисел, округленное в соответствии с режимом mode
: сравнивает два числа. Возвращает -1, если текущий объект меньше числа other, 1 — если текущий объект больше и 0 — если числа равны
: возвращает объект BigDecimal, значение которого равно числу, переданному в качестве параметра
: преобразует объект BigDecimal в double
: преобразует объект BigDecimal в float

Пример использования классов BigInteger и BigDecimal:

import java.math.*;

public class Program {
  
    public static void main(String[] args) {
          
        BigInteger a = BigInteger.valueOf(2147483647);
        BigInteger b = BigInteger.valueOf(2147483641);
        //a = a * b;  // так нельзя
        a = a.multiply(b);
        System.out.println(a);  // 4611686001247518727
        long x = a.longValue();
        System.out.println(x);  // 4611686001247518727
        
        BigDecimal c = BigDecimal.valueOf(2325.06);
        BigDecimal d = BigDecimal.valueOf(215.06);
        c = c.subtract(d.multiply(BigDecimal.valueOf(2.1)));
        System.out.println(c);      // 1873.434
        double y = c.doubleValue();
        System.out.println(y);      // 1873.434
    }
}

Стоит отметить, несмотря на то, что объекты BigInteger и BigDecimal представляют числа, мы не можем применять с ними стандартные арифметические операции. Все математические
действия с данными объектами идут через их методы.

НазадВперед

4. Операции возведения в степень

Метод Math.pow(a, b) может использоваться для вычисления ab. Метод pow определён в классе Math в Java API. Этот метод вызывается с использованием синтаксиса Math.pow(a, b) (например, Math.pow(2, 3)), который возвращает результата ab (23). Здесь a и b являются параметрами для метода pow, а числа 2 и 3 настоящими значениями, используемыми для вызова метода. Например:

System.out.println(Math.pow(2, 3)); // Выведет 8.0
System.out.println(Math.pow(4, 0.5)); // Выведет 2.0
System.out.println(Math.pow(2.5, 2)); // Выведет 6.25
System.out.println(Math.pow(2.5, -2)); // Выведет 0.16

В одной из последующих главах будут даны дополнительные подробности о методах. На данный момент всё, что вам нужно знать, это как вызывать метод pow для выполнения операций возведения в степень.

Примитивный тип данных (Primitive)

Примитивные типы Java не являются объектами. Всего их восемь, к ним относятся: byte, short, int, long, float, double, charи boolean.

Каждый примитивный тип как член класса имеет значение по умолчанию:

Примитивный тип	Значение по умолчанию
byte, short, int, long
float	0.0F
double	0.0D
char	0; или ‘\u0000’
boolean	false

Если использовать локальную переменную без инициализации компилятор выдаст ошибку.

Пример.

В классе объявим несколько полей класса примитивного типа без инициализации, в конструкторе выведем их значения.

public class Test {
    int x;
    char ch;
    boolean f;
    double d;
    // конкструтор   
    public Test()
    {
        System.out.println("x=" + x);
        System.out.println("ch=" + ch);
        System.out.println("f=" + f);
        System.out.println("d=" + d);
    }
  }

Где нужны значения типа Boolean

Булевы значения и условные выражения часто используются в условиях операторов ветвления, тернарного оператора и циклов.

Операторы ветвления

Оператор ветвления позволяет выбрать и исполнить определённый блок кода в зависимости от срабатывания некоторого условия.

Есть два оператора ветвления (условные конструкции): if-else и switch.

Оператор if

Его синтаксис выглядит так:

if (условие) {

//код

} else {

//код

}

В круглых скобках после if указывают условное выражение (высказывание). Если оно истинно (то есть результат его вычисления равен true), то выполняется код в фигурных скобках после условия, иначе выполняется код по ветке else (если она есть).

Примеры:

Проверяем условие в круглых скобках:

3 > 2?

Если да, то в консоль выводим: «Высказывание в скобках правдивое», иначе ничего не выводим.

Так как 3 и правда больше 2, то в консоли появилось наше сообщение.

Печатаем «Высказывание в скобках правдивое», если результат вычислений в круглых скобках = true. В ином случае выводим: «Высказывание в скобках ложное».

Так как выражение (3 < 2) возвращает false, то и в консоли видим: «Высказывание в скобках ложное».

Вложенные конструкции

Допустим, мы хотим проверить некое условие, и если оно не выполнилось — проверить другое условие и так далее. Сделать это можно двумя способами.

1. Вложенный if

Синтаксис тут такой:

if (условие1) {

//действия, если условие1 выполнено;

} else {

if (условие2) {

//действия, если условие2 выполнено;

}

<…>

else {

//действия, если все предыдущие условия не выполнились;

}

Пример:

2. Конструкция else if

Каждое логическое условие записывают через комбинацию else if, после которых в круглых скобках идёт альтернативное условие. Последний вариант (если ни одно из условий не сработало) записывается через else без условия.

Синтаксически это выглядит так:

if (условие1) {

//действия, если условие1 выполнено;

}

else if (условие2) {

//действия, если условие2 выполнено;

}

else if (условие3) {

//действия, если условие3 выполнено;

}

<…>

else {

//действия, если условие последнего if тоже не выполнилось;

}

Пример:

Каждое следующее условие проверяется только в том случае, если предыдущее не выполнилось. Как только найдётся одно правдивое условие (или мы достигнем последнего else), выполнится код в фигурных скобках после этого условия, а оставшаяся цепочка условий будет пропущена.

Иногда условий else if нужно довольно много:

Такой код сложно воспринимать: увеличение глубины вложенности быстро сделало его запутанным. Для таких случаев придуман оператор switch.

Поплавок против Двойного … В чем дело?

Float и Double — это представление данных, которое используется для арифметических операций с плавающей запятой, подумайте о десятичных числах, которые вы вычисляете в классе математики, например, 20.123, 16.23, 10.2и т. д., они не являются целыми числами (т. 2, 5, 15и т. д.), поэтому они требуют рассмотрения фракций в двоичном формате. В результате десятичные числа (т. Е. 20.123, 16.23, и т. д.) не может быть легко представлен нормальным двоичным форматом (т. е. Integer). Основное различие между Float и Double заключается в том, что первое представляет собой данные с плавающей запятой с единственной точностью (32-разрядные), в то время как второй тип данных с плавающей точкой двойной точности (64-разрядная). Двойной называется «двойным», потому что это в основном версия с двойной точностью Float. Если вы вычисляете огромную сумму (думайте о тысячах 0 в номере), тогда неточности будут меньше в Double, и вы не потеряете много точности.

Лучше проработать с использованием примеров кода. Ниже приведена операция по Float и Double через математические функции, предоставляемые на языке C:

#включают

int main () {

float num1 = 1.f / 82;

float num2 = 0;

для (int i = 0; i <738; ++ i)

num2 + = num1;

printf («%. 7g n», num2);

double num3 = 1.0 / 82;

double num4 = 0;

для (int i = 0; i <738; ++ i)

num4 + = num3;

printf («%. 15g n», num4);

GetChar ();

}

Он печатает следующее:

9.000031

8.99999999999983

Здесь вы можете видеть, что небольшая разница в точности Float и Double дает совсем другой ответ, хотя Double кажется более точным, чем Float.

Ниже приведен пример функции sqrt () в C:

#включают

int main () {

float num1 = sqrt (2382719676512365.1230112312312312);

double num2 = sqrt (2382719676512365.1230112312312312);

printf («% f n», num1);

printf («% f n», num2);

GetChar ();

}

Он дает следующий результат:

48813108.000000

48813109.678778

Здесь вы можете видеть, что ответ в Double имеет более высокую точность.

В общем, лучше использовать Double для арифметики с плавающей запятой, поскольку несколько стандартных математических функций в C работают на Double и современных компьютерах, чрезвычайно быстрые и эффективные для расчетов с двойной плавающей запятой. Это приводит к уменьшению необходимости использования Float, если вам не нужно работать с множеством чисел с плавающей запятой (думайте о больших массивах с тысячами 0 в числах) или вы работаете в системе, прецизионная плавающая точка, так как многие графические процессоры, маломощные устройства и определенные платформы (ARM Cortex-M2, Cortex-M4 и т. д.) не поддерживают Double еще, тогда вы должны использовать Float. Кроме того, следует помнить, что некоторые графические процессоры / процессоры работают лучше / эффективнее в обработке Float, например, при вычислении векторов / матриц, поэтому вам может потребоваться найти руководство по спецификации оборудования / документацию, чтобы лучше решить, какой из них вы должны использовать для конкретной машины.

Ссылочный тип данных. (Reference)

Ссылочным типом называются тип, для которого в ячейке памяти содержится не сами данные, а только адреса этих данных, то есть ссылки на данные.

Ссылочные типы в языке Java включают:

- Массивы
- Классы
- Интерфейсы
- Перечисления

Свойства ссылочного типа данных:

Различие примитивных и ссылочных типов данных

Возьмем примитивный тип int и рассмотрим следующий код:

int a=5;    // объявляем первую переменную и инициализируем ее
int b=a;    // объявляем вторую переменную, далее присваиваем b=a.
            //В этой операции выполняется копирование значения ячейки а в ячейку b
a=3;        // меняем значение первой переменной
// выводим значение переменной a
System.out.println(“a= “ + a);         // будетвыведено  a= 3
// выводим значение переменной b
System.out.println(“b= “ + b);         // будет выведено b= 5

Из данного примера следует, что при выполнении операции присвоения для переменных, имеющих примитивный тип, выполняется копирование данных из одной ячейки памяти в другую.

Выполним операцию присвоения (копирования) для ссылочных переменных. Для этого напишем простой класс Point -точка на плоскости, имеющая координаты x и y.

public static class Point{
    public   int x; //координататочки x
    public   inty; //координата тоски y
//конструктор
Point(int X, int Y) {
    x=X;
    y=Y;
  }
}

Создадим несколько объектов класса Point и выполним операцию присвоения.

//cоздаем объект – первую точку
//при выполнении данной операции будет
//создана переменная объектного типа p1,
//которая будет содержать адрес объекта 
Point p1 = new Point(1,1);
//создаем переменную p2 и выполняем 
//операцию присваивания
Point p2=p1;
//меняем координату x первого объекта
p1.x=7;
//выводим координаты первого и второго объекта
System.out.println("p1.x="+ p1.x);
System.out.println("p1.y="+ p1.y);
System.out.println("p2.x="+ p2.x);
System.out.println("p3.y="+ p2.y);
System.out.println("---------");
//создаем переменную p3 и выполняем
Point p3 = null;
//создаем третий объект
p3= new Point(3,3);
//выполняем операцию присваивания
//теперь все переменные указывают на 
//третий объект
p2=p3;
p1=p3;
System.out.println("p3.x="+ p3.x);
System.out.println("p3.y="+ p3.y);
//выводим коорлинаты
System.out.println("---------");
System.out.println("p1.x="+ p1.x);
System.out.println("p1.y="+ p1.y);
System.out.println("p2.x="+ p2.x);
System.out.println("p3.y="+ p2.y);
System.out.println("---------");

буудет выведено:

p1.x=7p1.y=1p2.x=7p3.y=1———p3.x=3p3.y=3———p1.x=3p1.y=3p2.x=3p3.y=3———

Из данного примера следует, что при выполнении операции присвоения применительно к ссылочным переменным копируются адреса, а не сами данные. В данном примере мы получили, что все объектные переменные ссылаются на третий объект. Первый объект остался существовать, но на него никто не ссылается. Более того, адрес первого объекта нигде не сохранился, и поэтому это потерянный объект, другими словами «мусор», который только занимает память.

В чем разница между float и double?


Float — это 32-битный тип данных с плавающей запятой одинарной точности IEEE 754.	Double — это 64-битный тип данных с плавающей запятой IEEE 754 двойной точности.
Количество байтов
Длина числа с плавающей запятой составляет 4 байта.	Длина двойника составляет 8 байт.
Значения по умолчанию
По умолчанию значение float равно 0,0f.	По умолчанию значение double равно 0,0d.
Ключевое слово
Ключевое слово «float» используется для объявления плавающего значения.	Ключевое слово double используется для объявления значения типа double.
Требуемая память
Float требует меньше памяти, чем double.	Двойник требует больше памяти, чем float.

6 ответов

Лучший ответ

возвращает примитивный тип double, содержащий значение строки:

возвращает Double Например, если он уже кэширован, вы получите тот же кешированный экземпляр.

Чтобы избежать накладных расходов на создание нового экземпляра объекта Double, обычно следует использовать

MByD
14 Май 2012 в 06:03

Если вы хотите преобразовать строку в двойной тип данных, тогда большинство из них выбирают метод parseDouble (). См. Пример кода:

matthewnreid
14 Май 2012 в 12:39

В документации для говорится: «Возвращает новый тип double, инициализированный значением, представленным указанной строкой, как это выполняется методом valueOf класса Double.», Поэтому они должны быть идентичными.

Rob I
14 Май 2012 в 04:49

Оба они преобразуют String в значение типа double, но там, где метод parseDouble () возвращает примитивное значение типа double, метод valueOf () дополнительно преобразует примитивный тип double в объект класса-оболочки Double, который содержит примитивное значение типа double.

Преобразование из String в примитивный тип double может вызвать NFE (NumberFormatException), если значение в String не может быть преобразовано в примитивный тип double.

Surender Thakran
14 Май 2012 в 06:30

Метод parseDouble () используется для инициализации STRING (которая должна содержать некоторое числовое значение) …. возвращаемое значение имеет примитивный тип данных, например int, float и т. д.

Но valueOf () создает объект класса Wrapper. Вы должны развернуть его, чтобы получить двойное значение. Его можно сравнить с шоколадом. Производитель оборачивает шоколад фольгой или бумагой, чтобы предотвратить загрязнение. Пользователь берет шоколад, снимает, бросает обертку и съедает.

Обратите внимание на следующее преобразование. Тип данных int k преобразуется в объект it1 с использованием класса Integer

Объект it1 может использоваться в программировании на Java везде, где требуется объект k

Тип данных int k преобразуется в объект it1 с использованием класса Integer. Объект it1 может использоваться в программировании на Java везде, где требуется объект k.

Следующий код можно использовать для разворачивания (возврата int из объекта Integer) объекта it1.

System.out.println (м * м); // выводит 10000

// intValue () — это метод класса Integer, который возвращает тип данных int.

rohanpro
25 Июн 2014 в 06:20

вернет примитивный тип . вернет объект-оболочку типа .

Итак, например:

Более того, — перегруженный метод. Имеется два варианта:

Тогда как — это единственный метод со следующей сигнатурой:

Radiodef
27 Янв 2018 в 02:04

Ловушки:

Тем не менее, есть много вещей, которые не охвачены в коде выше. Код выше не является нулевым.

Теперь он работает нормально для большинства значений. Однако целые числа имеют очень маленький диапазон (минимальное / максимальное значение) по сравнению с Double . Кроме того, double также может содержать «специальные значения», которые целые числа не могут:

1/0 = + бесконечность
-1/0 = -infinity
0/0 = не определено (NaN)

Поэтому, в зависимости от приложения, вы можете захотеть добавить фильтрацию, чтобы избежать неприятных исключений.

Тогда следующим недостатком является стратегия округления. По умолчанию Java всегда будет округляться. Округление вниз имеет смысл во всех языках программирования. По сути, Java просто отбрасывает некоторые байты. В финансовых приложениях вы наверняка захотите использовать округление до половины (например: round(0.5) = 1 и round(0.4) = 0 ).

Оператор instanceof

Есть ещё один оператор, который возвращает булево значение, — это instanceof.

Он проверяет принадлежность переменной к какому-то классу.

Когда используют instanceof?

Если классы объектов нужно узнать во время выполнения программы.

Допустим, есть два потока исполнения. В первом создаются объекты разных классов, а в другом они используются. С instanceof легко выяснять класс каждого объекта, который получает второй поток.

Класс объекта важно знать и для приведения типов. Хотя большинство подобных проблем выявляет компилятор, но приведение типов при иерархии классов чревато ошибками, которые всплывают только во время работы

Вообще, instanceof используется редко, потому что обычно типы объектов известны сразу. Применять этот оператор считается дурным тоном, это признак плохой программной архитектуры. Но его используют в обобщённых процедурах, которые оперируют объектами из сложной иерархии классов.

Как работать с instanceof

Рассмотрим на примере:

Объект c принадлежит только к классу C. Нам пришлось привести его к классу Object, чтобы можно было проверить на соответствие классу A.

Иначе компилятор сразу бы увидел, что объект класса C не принадлежит к классу A, — и не дал бы запустить программу с ошибкой несовместимости типов:

Упрощённый оператор instanceof в Java 15

Раньше был допустим только такой синтаксис:

То есть мы сначала проверяем, что object может быть приведён к какому-то типу Type, — это и делает оператор instanceof, а внутри условия приводим объект к этому типу и записываем результат в новую переменную.

В Java 15 появилась конструкция упрощённого приведения:

3. Числовые операторы

Операторы +, -, *, /, % и операнды

Операторы для числовых типов данных включают стандартные арифметические операторы: сложение (+), вычитание (–), умножение (*), деление () и остаток от деления (%).

Имя	Значение	Пример	Результат
+	Сложение	34 + 1	35
—	Вычитание	34.0 — 0.1	33.9
*	Умножение	300 * 30	9000
Деление	1.0 / 2.0	0.5
%	Остаток от деления	20 % 3	2

Целочисленное деление

Когда оба операнда деления (делимое и делитель) являются целыми числами, результатом деление будет частное без дробной части. Например, 5 / 2 даёт 2, а не 2.5, а -5 / 2 даёт -2, а не -2.5. Для выполнения деления с плавающей точкой один из операндов должен быть числом с плавающей запятой. Например, 5.0 / 2 даёт 2.5.

Оператор %, известный как остаток от деления, или оператор модуля, даёт остаток после деления. Операндом слева – это делимое, а операнд справа – делитель. Поэтому 7 % 3 даёт 1, 3 % 7 даёт 3, 12 % 4 даёт , 26 % 8 даёт 2 и 20 % 13 даёт 7.

Оператор % часто используется для положительных целых чисел, но также может использоваться для отрицательных и значений с плавающей запятой. Остаток от деления является отрицательным только если отрицательным является делимое. Например, -7 % 3 даёт -1, -12 % 4 даёт , -26 % -8 даёт -2 и 20 % -13 даёт 7.

Остаток от деления очень полезен в программировании. Например, чётные числа % 2 всегда , а нечётные числа % 2 всегда 1. Так вы можете использовать это свойство для определения, является ли число чётным или нечётным. Если сегодня суббота, то суббота снова будет через 7 дней. Предположим, вы и ваши друзья собираетесь встретиться через 10 дней. Какой день будет через 10 дней? Вы можете узнать, что будет вторник используя следующее выражение:

Следующая программа считает сколько минут и секунд содержится в количестве введённых секунд. Например, 500 секунд содержат 8 минут и 20 секунд.

import java.util.Scanner;

public class DisplayTime {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        // Запрос пользователю на ввод
        System.out.print("Введите число секунд: ");
        int seconds = input.nextInt();

        int minutes = seconds / 60; // Найти минуты в секундах
        int remainingSeconds = seconds % 60; // Оставшиеся секунды
        System.out.println(seconds + " секунд это " + minutes
                + " минут и " + remainingSeconds + " секунд");
    }
}

Метод nextInt() (строка считывает число для seconds. Строка 10 получает минуты используя seconds / 60. Строка 11 (seconds % 60) получает оставшиеся секунды без минут.

Унарные и бинарные операторы

Операторы + и — могут быть как унарными, так и бинарными. Унарный оператор имеет только один операнд; а бинарные – два. Например, оператор — в -5 – это унарный оператор, показывающей, что число 5 является отрицательным, в то время как оператор — в 4 — 5 является бинарным оператор для вычитания 5 из 4.