Bazaprogram.ru

Новости из мира ПК
3 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Класс double java

Java.Lang.Double класс в Java

Двойной класс — это класс-оболочка для примитивного типа double, который содержит несколько методов для эффективной работы с двойным значением, например, преобразование его в строковое представление и наоборот. Объект класса Double может содержать одно значение типа double. Есть в основном два конструктора для инициализации объекта Double.

  • Double (double b): Создает объект Double, инициализированный с предоставленным значением.
  • Double (String s): создает объект Double, инициализированный с проанализированным двойным значением, предоставленным строковым представлением. Радиус дефалута принят равным 10.


Методы:

  1. toString (): возвращает строку, соответствующую двойному значению.
  2. valueOf (): возвращает объект Double, инициализированный с предоставленным значением.

Другая перегруженная функция valueOf (String val), которая предоставляет функцию, аналогичную
новый Double (Double.parseDouble (val, 10))

  • parseDouble (): возвращает двойное значение, анализируя строку. Отличается от valueOf () тем, что возвращает примитивное двойное значение, а valueOf () возвращает объект Double.
  • byteValue (): возвращает байтовое значение, соответствующее этому двойному объекту.
  • shortValue (): возвращает короткое значение, соответствующее этому двойному объекту.
  • intValue (): возвращает значение int, соответствующее этому двойному объекту.
  • longValue (): возвращает длинное значение, соответствующее этому двойному объекту.
  • doubleValue (): возвращает двойное значение, соответствующее этому двойному объекту.
  • floatValue (): возвращает значение с плавающей точкой, соответствующее этому двойному объекту.
  • hashCode (): возвращает хэш-код, соответствующий этому двойному объекту.
  • isNaN (): возвращает true, если рассматриваемый двойной объект не является числом, в противном случае — false.

    Другой статический метод isNaN (double val) может быть использован, если нам не нужен объект double для создания. Он обеспечивает функциональность, аналогичную вышеприведенной версии.

    isInfinite (): возвращает true, если рассматриваемый двойной объект очень большой, иначе false. В частности, любое число за 0x7ff0000000000000L на положительной стороне и ниже 0xfff0000000000000L на отрицательной стороне являются значениями бесконечности.

    Другой статический метод isInfinite (double val) можно использовать, если нам не нужен объект double для создания. Он обеспечивает функциональность, аналогичную вышеприведенной версии.

    compareTo (): используется для сравнения двух объектов Double на числовое равенство. Это следует использовать при сравнении двух значений Double для числового равенства, поскольку оно будет различать меньшее и большее значения. Возвращает значение меньше 0,0, значение больше 0 для меньше, равно и больше, чем.

  • сравнение (): используется для сравнения двух примитивных двойных значений для числового равенства. Так как это статический метод, поэтому его можно использовать без создания какого-либо объекта Double.
  • Java.lang.Double Class

    Introduction

    The java.lang.Double class wraps a value of the primitive type double in an object. An object of type Double contains a single field whose type is double.

    Class Declaration

    Following is the declaration for java.lang.Double class −

    Field

    Following are the fields for java.lang.Double class −

    static int MAX_EXPONENT − This is the maximum exponent a finite double variable may have.

    static double MAX_VALUE − This is the constant holding the largest positive finite value of type double, (2-2- 52 )×2 1023 .

    static int MIN_EXPONENT − This is the minimum exponent a normalized double variable may have.

    static double MIN_NORMAL − This is the constant holding the smallest positive normal value of type double, 2 -1022 .

    static double MIN_VALUE − This is the constant holding the smallest positive nonzero value of type double, 2 -1074 .

    static double NaN − This is the constant holding a Not-a-Number (NaN) value of type double.

    static double NEGATIVE_INFINITY − This is the constant holding the negative infinity of type double.

    static double POSITIVE_INFINITY − This is the constant holding the positive infinity of type double.

    static int SIZE − This is the number of bits used to represent a double value.

    static Class TYPE − This is the class instance representing the primitive type double

    >

    Sr.No.Constructor & Description1

    This constructs a newly allocated Double object that represents the primitive double argument.

    This constructs a newly allocated Double object that represents the floating-point value of type double represented by the string.

    >

    Sr.No.Method & Description1byte byteValue()

    This method returns the value of this Double as a byte (by casting to a byte).

    This method compares the two specified double values.

    This method compares the two specified double values.

    This method returns a representation of the specified floating-point value according to the IEEE 754 floating-point «double format» bit layout.

    This method returns a representation of the specified floating-point value according to the IEEE 754 floating-point «double format» bit layout, preserving Not-a-Number (NaN) values.

    This method returns a representation of the specified floating-point value according to the IEEE 754 floating-point «double format» bit layout, preserving Not-a-Number (NaN) values.

    This method compares this object against the specified object.

    This method returns the float value of this Double object.

    This method returns a hash code for this Double object.

    This method returns the value of this Double as an int (by casting to type int).

    This method returns true if this Double value is infinitely large in magnitude, false otherwise.

    This method returns true if the specified number is infinitely large in magnitude, false otherwise.

    This method returns true if this Double value is a Not-a-Number (NaN), false otherwise.

    This method returns true if the specified number is a Not-a-Number (NaN) value, false otherwise.

    This method returns the double value corresponding to a given bit representation.

    This method returns the value of this Double as a long (by casting to type long).

    This method returns a new double initialized to the value represented by the specified String, as performed by the valueOf method of class Double.

    This method returns the value of this Double as a short (by casting to a short).

    This method returns a hexadecimal string representation of the double argument.

    This method returns a string representation of this Double object.

    This method returns a string representation of the double argument.

    This method returns a Double instance representing the specified double value.

    This method returns a Double object holding the double value represented by the argument string s.

    Methods inherited

    This class inherits methods from the following classes −

    Пара слов о числах с плавающей точкой в Java


    Несколько дней назад мне на глаза попался занимательный такой вопрос, касающийся того, каков будет результат выполнения данного кода:

    Вопреки всем моим ожиданиям, ответ: 0.89999999999999991 в первом случае и 0.99999999999999989 во втором.
    Для тех, кто хочет узнать почему, а так же еще несколько занимательных фактов про этот тип данных, милости просим.

    В общем виде ответ на поставленный выше вопрос будет звучать примерно так: «Подобные ошибки связанны с внутренним двоичным (binary) представлением чисел. Подобно тому, как в десятичной системе нельзя точно представить результат деления 1/3, так и в двоичной системе невозможно точно представить 1/10. Если вам нужно исключить ошибки округления, следует использовать класс BigDecimal».

    Существует важное различие между абстрактными вещественными числами, такими как π или 0.2, и типом данных double в Java. Во-первых, платонически-идеальное представление вещественных чисел является бесконечным, в то время как представление в Java ограничено числом бит. Однако точность вычислений является еще более насущной проблемой, чем ограничение на размер чисел. Еще больше «интригует» совершенно оригинальный способ округления чисел, но обо всем по порядку.

    Начать, пожалуй, стоит с двоичного представления целых чисел. Этот абзац нам пригодится чуть позже. Итак. Самым простым вариантом представления целых чисел считается так называемый «Прямой код», в котором старший бит используется для записи знака числа (0 — положительное, 1 — отрицательное), а оставшиеся биты используются непосредственно для записи самого значения. Таким образом, число «-9» в восьмиразрядном представлении будет выглядеть как 10001001. Недостатком такого подхода считается наличие двух нулей («+0» и «-0») и усложнение арифметических операций с отрицательными числами. Другим вариантом, интересующим нас, является «Код со сдвигом», в котором, говоря простым языком, мы прибавляем к нашему числу некое константное для данного типа представления число, равное 2^(n-1), где n — число разрядов (бит). В нашем случае, пример с числом «-9» в восьмиразрядном представлении будет выглядеть так:
    -9 + 2^(8-1) = -9 + 128 = 119. В двоичном виде получим 01110111. Этот вариант удобен тем, что ноль у нас всего один, однако при арифметических операциях необходимо будет учитывать смещение.

    Здесь стоит упомянуть вот о чем. Одной из заявленных целей языка Java является машинная независимость. Вычисления должны приводить к одинаковому результату, независимо от того, какая виртуальная машина их выполняет. Для арифметических вычислений над числами с плавающей точкой это неожиданно оказалось трудной задачей. Тип double использует для хранения числовых значений 64 бита, однако некоторые процессоры применяют 80-разрядные регистры с плавающей точкой. Эти регистры обеспечивают дополнительную точность на промежуточных этапах вычисления, т.е. промежуточный результат вычислений храниться в 80-разрядном регистре, после чего ответ округляется до 64 бит. Однако этот результат может оказаться иным, если в процессе всех вычислений используется 64-разрядный процессор. По этой причине в первоначальном описании JVM указывалось, что все промежуточные вычисления должны округляться. Это вызвало протест многих специалистов, поскольку подобное округление не только может привести к переполнению, но и сами вычисления происходят медленнее. Это привело к тому, что в JDK 1.2 появилась поддержка ключевого слова strictfp, гарантирующая воспроизводимость результатов всех вычислений, производимых внутри этого метода, класса или интерфейса (вернее его реализации). Иными словами, ключевое слово strictfp гарантирует, что на каждой платформе вычисления с плавающей точкой будут вести себя одинаково и с определенной точностью, даже если некоторые платформы могут производить вычисления с большей точностью. Интересно, что для процессоров семейства x86 модуль операций с плавающей точкой был выделен в отдельную микросхему, называемую математическим сопроцессором (floating point unit (FPU)). Начиная с процессоров Pentium модели MMX модуль операций с плавающей точкой интегрирован в центральный процессор. Подробнее.

    Далее. Стандарт IEEE 754 говорит нам, что представление действительных чисел должно записываться в экспоненциальном виде. Это значит, что часть битов кодирует собой так называемую мантиссу числа, другая часть — показатель порядка (степени), и ещё один бит используется для указания знака числа (0 — если число положительное, 1 — если число отрицательное). Математически это записывается так:
    (-1)^s × M × 2^E, где s — знак, M — мантисса, а E — экспонента. Экспонента записывается со сдвигом, который можно получить по формуле, приведенной выше.

    Что такое мантисса и экспонента? Мантисса – это целое число фиксированной длины, которое представляет старшие разряды действительного числа. Допустим наша мантисса состоит из четырех бит (|M|=4). Возьмем, например, число «9», которое в двоичной системе будет равно 1001.
    Экспонента (ее еще называют «порядком» или «показателем степени») – это степень базы (двойки) старшего разряда. Можно рассматривать ее как количество цифр перед точкой, отделяющей дробную часть числа. Если экспонента переменная, записываемая в регистр и неизвестная при компиляции, то число называют «числом с плавающей точкой». Если экспонента известна заранее, то число называют «числом с фиксированной точкой». Числа с фиксированной точкой могут записываться в обыкновенные целочисленные переменные (регистры) путем сохранения только мантиссы. В случае же записи чисел с плавающей точкой, записываются и мантиса и экспонента в так называемом стандартном виде, например «1.001e+3». Сразу видно, что мантисса состоит из четырех знаков, а экспонента равна трем.

    Допустим мы хотим получить дробное число, используя те же 3 бита мантиссы. Мы можем это сделать, если возьмем, скажем, E=1. Тогда наше число будет равно

    1.001e+1 = 1×2^2 + 0×2^1 + 0×2^0 + 1×2^(-1) = 4 + 0,5 = 4,5

    Одной из проблем такого подхода может стать различное представление одного и того же числа в рамках одной длины мантиссы. Нашу «9-ку», при длине мантиссы равной 5, можно представить и как 1.00100e+3 и как 0.10010e+4 и как 0.01001e+5. Это не удобно для оборудования, т.к. нужно учитывать множественность представления при сравнении чисел и при выполнении над ними арифметических операций. Кроме того, это не экономично, поскольку число представлений — конечное, а повторения уменьшают множество чисел, которые вообще могут быть представлены. Однако тут есть маленькая хитрость. Оказывается, что для вычисления значения первого бита можно использовать экспоненту. Если все биты экспоненты равны 0, то первый бит мантиссы также считается равным нулю, в противном случае он равен единице. Числа с плавающей точкой, в которых первый бит мантиссы равен единице, являются нормализованными. Числа с плавающей точкой, первый бит мантиссы в которых равен нулю, называются денормализованными. С их помощью можно представлять значительно меньшие величины. Поскольку первый бит всегда может быть вычислен, нет необходимости хранить его явным образом. Это экономит один бит, так как неявную единицу не нужно хранить в памяти, и обеспечивает уникальность представления числа. В нашем примере с «9» нормализованным представлением будет 1.00100e+3, а мантисса будет храниться в памяти как «00100», т.к. старшая единица подразумевается неявно. Проблемой такого подхода является невозможность представления нуля, о которой я скажу чуть позже. Подробнее об этом и многом другом можно почитать тут и тут.

    К слову, в JDK 1.5 допустимо задавать числа с плавающей точкой в шестнадцатеричном формате. Например, 0.125 можно представить как 0x1.0p-3. В шестнадцатеричной записи для указания экспоненты используется знак «p» вместо «е».

    Вещи, о которых стоит помнить, работая с Double:

    1. Целочисленное деление на 0 генерирует исключение, в то время как результатом деления на 0 чисел с плавающей точкой является бесконечность (или NaN в случае деления 0.0/0). Кстати мне было интересно узнать, что разработчики JVM, согласно все тому же стандарту IEEE 754 ввели также и значения Double.NEGATIVE_INFINITY и Double.POSITIVE_INFINITY, равные -1.0 / 0.0 и 1.0 / 0.0 соответственно.
    2. Double.MIN_VALUE на самом деле не самое маленькое число, которое можно записать в double. Помните, мы говорили о том, что согласно стандарту IEEE 754, старшая единица мантиссы указывается неявно? Так вот. Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль, поскольку нет такой степени двойки, которая равнялась бы нулю. И разработчики JVM специально для решения этой проблемы ввели переменную Double.MIN_VALUE, которая, по сути, является максимально близким значением к нулю. Самым маленьким значением, которое вы можете сохранить в double является «-Double.MAX_VALUE».
    3. Развивая предыдущую тему, можно привести еще один интересный пример, показывающий нам, что не все так очевидно, как может показаться на первый взгляд. Double.MAX_VALUE возвращает нам 1.7976931348623157E308, но что будет если мы преобразуем строку, содержащую число с плавающей запятой в double?

    Оказывается, между Double.MAX_VALUE и Double.POSITIVE_INFINITY есть еще некоторые значения, которые при вычислении округляются в одну или другую сторону. Тут стоит остановиться подробнее.

    Множество вещественных чисел является бесконечно плотным (dense). Не существует такого понятия, как следующее вещественное число. Для любых двух вещественных чисел существует вещественное число в промежутке между ними. Это свойство не выполняется для чисел с плавающей точкой. Для каждого числа типа float или double существует следующее число. Кроме того, существует минимальное конечное расстояние между двумя последовательными числами типа float или double. Метод Math.nextUp() возвращает следующее число с плавающей точкой, превышающее заданный параметр. Например, данный код печатает все числа типа float между 1.0 и 2.0 включительно.

    Оказывается, что в промежутке от 1.0 до 2.0 включительно лежит ровно 8,388,609 чисел типа float. Это немало, но намного меньше, чем бесконечное множество вещественных чисел, которые находятся в том же диапазоне. Каждая пара последовательных чисел типа float находится на расстоянии примерно 0.0000001 друг от друга. Это расстояние называется единицей наименьшей точности (unit of least precision – ULP). Для типа double ситуация совершенно идентичная, за исключением того факта, что кол-во чисел после запятой значительно выше.

    Пожалуй, на этом все. Желающим «копнуть поглубже» может пригодится следующий код:

    Спасибо всем осилившим. Буду рад конструктивной критике и дополнениям.

    Класс double java

    System.out.println(«April has » + month_days[3] + » days.»);

    При запуске эта программа печатает количество дней в апреле, как это показано ниже. Нумерация элементов массива в Java начинается с нуля, так что число дней в апреле — это month_days [3].

    April has 30 days.

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

    public static void main(String args[]) <

    System.out.println(«April has » + month_days[3] + » days.»);

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

    Java строго следит за тем, чтобы вы случайно не записали или не попытались получить значения, выйдя за границы массива. Если же вы попытаетесь использовать в качестве индексов значения, выходящие за границы массива — отрицательные числа либо числа, которые больше или равны количеству элементов в массиве, то получите сообщение об ошибке времени выполнения. В главе 10 мы подробно расскажем о том, что делать при возникновении подобных ошибок.

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

    double matrix [][] = new double [4][4];

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

    double matrix [][] = new double [4][];

    matrix [0] = new double[4];

    matrix[1] = new double[4];

    В следующем примере создается матрица размером 4 на 4 с элементами типа double, причем ее диагональные элементы (те, для которых х==у) заполняются единицами, а все остальные элементы остаются равными нулю.

    public static void main(String args[]) < double m[][];

    m = new double[4][4];

    System.out.println(m[0][0] +» «+ m[0][1] +» «+ m[0][2] +» «+ m[0][3]);

    System.out.println(m[1][0] +» «+ m[1][1] +» «+ m[1][2] +» «+ m[1][3]);

    System.out.println(m[2][0] +» «+ m[2][1] +» «+ m[2][2] +» «+ m[2][3]);

    System.out.println(m[3][0] +» «+ m[3][1] +» «+ m[3][2] +» «+ m[3][3]);

    Запустив эту программу, вы получите следующий результат:

    C : > Java Matrix

    Обратите внимание — если вы хотите, чтобы значение элемента было нулевым, вам не нужно его инициализировать, это делается автоматически.

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

    public static vo >

    System.out.println(m[0][0] +» «+ m[0][1] +» «+ m[0][2] +» «+ m[0][3]);

    System.out.println(m[1][0] +» «+m[1][1] +» «+ m[1][2] +» «+ m[1][3]);

    System.out.println(m[2][0] +» «+m[2][1] +» «+ m[2][2] +» «+ m[2][3]);

    System.out.println(m[3][0] +» «+m[3][1] +» «+ m[3][2] +» «+ m[3][3]);

    Запустив эту программу, вы получите следующий результат:

    С: > Java AutoMatrix

    Теперь вы знаете, как работать с восьмью простыми типами языка Java. Вы видели, как нужно создавать объекты этих типов и знаете разрядности каждого из них. Вы знаете, как эти типы взаимодействуют и какие из них подходят для арифметических вычислений. Вы познакомились с типом boolean и почувствовали, что от символов мало пользы пока нет возможности группировать их вместе, образуя слова — к этому вопросу мы вернемся в главе 9, где познакомимся со строками. Мы не обошли своим вниманием массивы и видели, как можно создавать массивы из массивов. В следующей главе мы научимся выполнять над всеми этими типами различные операции.

    Читать еще:  Sql и java
    Ссылка на основную публикацию
    Adblock
    detector