Java — Разложение числа Java


Содержание

Java — Разложение числа Java

Посмотрел в java.lang.Math и в apache-commons-math, но не нашёл метода для разложения числа по степеням двойки. Надо что-то типа double[] unfold(double), подскажите плз где искать?

От: Blazkowicz
Дата: 26.08.08 15:21
Оценка:
От: crazy209
Дата: 26.08.08 15:33
Оценка:

Здравствуйте, Аноним, Вы писали:

А>Привет!

А>Посмотрел в java.lang.Math и в apache-commons-math, но не нашёл метода для разложения числа по степеням двойки. Надо что-то типа double[] unfold(double), подскажите плз где искать?

что имеешь в виду под разложения числа по степеням двойки ?

От: Аноним
Дата: 26.08.08 15:47
Оценка:

Здравствуйте, crazy209, Вы писали:
C>что имеешь в виду под разложения числа по степеням двойки ?

И есть метод, принимающий на вход int type, где type может быть равен например TYPE_1+TYPE_3.
В методе мне надо получить массив значений , для этого надо разложить type на суммы степеней двойки.

От: Аноним
Дата: 26.08.08 15:53
Оценка:

Здравствуйте, Blazkowicz, Вы писали:
B>А почему double? Он же не точный.

да, здесь лучше использовать int или long, для моей задачи это не принципиально.

От: crazy209
Дата: 26.08.08 16:15
Оценка:

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, crazy209, Вы писали:
C>>что имеешь в виду под разложения числа по степеням двойки ?

А>Есть:

А>

А>И есть метод, принимающий на вход int type, где type может быть равен например TYPE_1+TYPE_3.
А>В методе мне надо получить массив значений , для этого надо разложить type на суммы степеней двойки.

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

а затем прогоняй свой type через него

только зачем. но если надо — значит надо

От: Аноним
Дата: 26.08.08 19:27
Оценка:

Здравствуйте, crazy209, Вы писали:
C>код уже привёл
C>либо предопредели некоторый массив длинной равной разрядности ожидаемого типа, куда положи соответствующие значения
C>а затем прогоняй свой type через него

Спасибо! Работает.

C>только зачем. но если надо — значит надо

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

От: LeonidV http://vygovskiy.com
Дата: 27.08.08 05:50
Оценка:

Здравствуйте, Аноним, Вы писали:

А>Надо как раз затем, чтобы в метод можно было передавать не только один тип, а сразу несколько просто указывая их в виде суммы именованных констант. Может правильнее это реализовывать как-то иначе. не знаю, но если есть лучший способ, то поделись
Не совсем понял насчет «не только один тип». Может быть имелось ввиду «не только одно значение»? Тогда я бы так сделал:

От: mkizub http://symade.tigris.org
Дата: 27.08.08 11:04
Оценка: +1

Здравствуйте, Аноним, Вы писали:

А>Надо как раз затем, чтобы в метод можно было передавать не только один тип, а сразу несколько просто указывая их в виде суммы именованных констант. Может правильнее это реализовывать как-то иначе. не знаю, но если есть лучший способ, то поделись

О боже ты мой.
Такой случай мне рассказывал со-работник. У него был индус, который везде вместо if-ов писал while-ы. На вопрос — «зачем. » он ответил,
что прочитал книжку по яве только до while оператора, а про if он ещё не читал.

Открой для себя битовые операции.
Они в яве обозначаются как | для OR, & для побитового AND,

для побитового NOT, ^ для XOR.
У тебя будет код типа

От: GarryIV
Дата: 27.08.08 12:14
Оценка:

Здравствуйте, Аноним, Вы писали:

C>>только зачем. но если надо — значит надо

А>Надо как раз затем, чтобы в метод можно было передавать не только один тип, а сразу несколько просто указывая их в виде суммы именованных констант. Может правильнее это реализовывать как-то иначе. не знаю, но если есть лучший способ, то поделись

Вот с этого и надо было начинать

От: Аноним
Дата: 28.08.08 19:46
Оценка:


Здравствуйте, Аноним, Вы писали:

А>Привет!

А>Посмотрел в java.lang.Math и в apache-commons-math, но не нашёл метода для разложения числа по степеням двойки. Надо что-то типа double[] unfold(double), подскажите плз где искать?

Наверное быстрее будт написать, если вы с битовыми операциями не на «вы».

От: yegres
Дата: 02.09.08 09:19
Оценка: +1

Здравствуйте, Аноним, Вы писали:

А>Надо как раз затем, чтобы в метод можно было передавать не только один тип, а сразу несколько просто указывая их в виде суммы именованных констант. Может правильнее это реализовывать как-то иначе. не знаю, но если есть лучший способ, то поделись

Java — Разложение числа Java

В уроке 8 мы затронули логические операторы, они нам были необходимы для формирования логического выражения в условиях if. Этот урок будет посвящен математике в Java, и поэтому мы рассмотрим подробнее арифметические операторы и частично возможности класса Math.

Но для начала, выясним, что же такое операторы. Операторы это специальные символы, отвечающие за ту или иную операцию, например сложение, умножение, сравнение. Все операторы в Java можно разбить на 4 класса — арифметические, битовые, операторы сравнения и логические.

Арифметические операторы в Java

Для стандартных арифметических операций, таких как сложение, вычитание, умножение, деление в Java используются традиционные символы, к которым мы привыкли со школы:

Примечание: при операции деления, если оба аргумента являются целыми числами, то в результате получим целое число. Дробная часть, если такая имеется, отбросится. Если хотим получить число с дробной частью, то нужно, чтобы один из аргументов был типа double. Это можно указать в самом выражении при помощи добавления после числа .0 или .d. Пример:

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

Пример использования: дан массив целых чисел, вывести на консоль только те числа, которые делятся на 3.

Операции с присваиванием

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

мы можем записать сокращенно

+= это оператор сложения с присваиванием. Подобные операторы есть для всех основных 5 операций, рассмотренных выше

Пример использования: Найти факториал числа 7.

Инкрементирование и декрементирование

Инкремент, обозначается ++ и увеличивает значение переменной на единицу. Декремент обозначается — и уменьшает значение на единицу. С инкрементом и декрементом мы часто встречаемся в цикле for.

Инкремент и декремент бывают двух форм

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

Цукерберг рекомендует:  C++ - C++. Переопределение операторов.

В первом случае сначала переменная a увеличится на 1, потом произойдет вычисление всего выражения. Во втором случае произойдет вычисление выражения при старом значении b = 3, и после вычисления b увеличится на 1, на результат в postfix это уже не повлияет.

Если вы поняли принцип работы постфиксного и префиксного инкремента/декремента, то предлагаю решить в уме такую задачу:

Вопрос: чему в итоге равны x и y? После того, как вы сделали предположение, проверьте его в java.

Задача со зведочкой. Дан код:

Какие числа будут выведены на экран? Почему? Разобраться самостоятельно.

Примечание: инкремент и декремент применяются только к переменной. Выражение вида 7++ считается недопустимым.

Математические функции и константы (класс Math)

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

Алгоритм поиска простых чисел на Java

Простое число — это число, которое делится нацело без остатка только на 1 и на самого себя. Также известно, что любое целое число, большее 1, является либо простым, либо может быть выражено как произведение простых чисел. Ряд простых чисел начинается с 2 и имеет следующий вид: 2, 3, 5, 7 и т.д.

Рассмотрим более-менее оптимальный алгоритм поиска простых чисел. Для этого давайте реализуем на Java метод getFirstPrimes(), который будет возвращать N первых простых чисел.


Все найденные простые числа будем складывать в список. Далее проверяем, что если у нас запросили хотя бы одно простое число, то сразу добавим 2, т.к. с него начинается последовательность. Далее в цикле начинаем проверять числа, сразу начиная с трёх. Также обратите внимание, что мы проверяем только нечётные числа (приращение +2), т.к. все чётные числа по определению делятся на 2.

Цикл выполняется до тех пор, пока в нашем результирующем списке не окажется ровно столько простых чисел, сколько у нас запросили. Саму проверку на «простоту» выполняем с помощью метода isPrime(), которому передаём текущее проверяемое число и уже накопленные нами на предыдущих итерациях числа.

Здесь мы сначала вызываем метод Math.sqrt(), ведь если проверяемое число состоит хотя бы из двух множителей, то ни одно из них не может превышать двоичный корень.

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

Рассмотренный алгоритм работает довольно быстро. За пару секунд он находит 500 000 простых чисел.

Оптимизации, которые мы применили:

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

Последняя оптимизация оказалась наиболее существенной.

Java — Разложение числа Java

We recommend upgrading to the latest Google Chrome or Firefox.

Join GitHub today

GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together.

JavaRushHomeWork / src / com / javarush / test / level34 / lesson02 / task03 / Solution.java

Users who have contributed to this file

package com.javarush.test.level34.lesson02.task03 ;
/* Разложение на множители с помощью рекурсии
Разложить целое число n > 1 на простые множители.
Вывести в консоль через пробел все множители в порядке возрастания.
Написать рекуррентный метод для вычисления простых множителей.
Не создавайте статические переменные и поля класса.
Пример:
132
Вывод на консоль:
2 2 3 11
*/
public class Solution <
public void recursion ( int n ) <
int a = 2 ;
while (a n) <
if ((n % a) == 0 ) <
if (a != n) <
System . out . print(a + » » );
recursion(n / a);
> else <
System . out . print(a);
>
return ;
>
a ++ ;
>
>
>
  • © 2020 GitHub , Inc.
  • Terms
  • Privacy
  • Security
  • Status
  • Help

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.

java@Cat

Учебные материалы по изучению основ языка програvмирования Java

dr.Mazurok

Software developer AI Scientist Ass.prof Odessa National I.I.Mechnikov University

Свежие комментарии


  • Артем Чернобровкин к записи e-olymp 47. Паркет из треугольников
  • Игорь Мазурок к записи e-olymp 47. Паркет из треугольников
  • Илья Черноморец к записи e-olymp112.Торт
  • Игорь Мазурок к записи e-olymp112.Торт
  • Игорь Мазурок к записи А329. Квадрат суммы цифр числа

Новые решения

e-olymp 842. Разложение на простые множители

Условие задачи
Вывести представление целого числа $n$ в виде произведения простых чисел.
Входные данные
Единственное число $n (2 \leq n \leq 2^ <31>— 1).$
Выходные данные
Вывести список простых множителей в порядке неубывания, разделённых знаком «$*$».
Тесты

Код программы

Решение задачи
Пока наше число больше либо равно divisor*divisor выполняется:

  1. Если numb делится нацело на divisor , мы выводим наш делитель, следовательно numb делится на divisor ;
  2. В противном случае:
    • Если divisor равен $2$ , то присваиваем ему значение $3$ и повторяем;
    • В другом случае увеличиваем его на $2$;

Таким образом перебираются $2$,$3$ и $5$, которые являются делителем для всех чисел.
Ссылки
Задача на сайте e-olymp
Код решения в Ideone

Поделиться «e-olymp 842. Разложение на простые множители»

Похожее

Добавить комментарий Отменить ответ

Решения задач

Задачи

Задачи

Задачи

  1. Найдите сумму цифр в десятичной записи целого числа
  2. Найдите сумму цифр в десятичной записи целого числа, хранящегося при помощи класса java.math.BigInteger
  3. Напишите функцию получения записи заданного числа в сбалансированной троичной системе счисления. (На вход поступает целое значение, на выходе — строка текста.)
  4. Напишите функцию вычисления синуса при помощи разложения в ряд Тейлора и формул приведения. Точность вычисления должна быть максимально возможной для типа данных double.
  5. Напишите функцию вычисления косинуса при помощи разложения в ряд Тейлора и формул приведения. Точность вычисления должна быть максимально возможной для типа данных double.
  6. Напишите функцию вычисления тангенса при помощи разложения в ряд Тейлора и формул приведения. Точность вычисления должна быть максимально возможной для типа данных double.
  7. Напишите функцию вычисления логарифма по натуральному основанию при помощи разложения в ряд Тейлора. Точность вычисления должна быть максимально возможной для типа данных double.

Более сложные задачи

  1. Напишите функцию с тремя целочисленными параметрами [latex]n, m, k[/latex] для вычисления [latex]n^m \mod k[/latex]. Т.е. для вычисления остатка от деления на [latex]k[/latex] числа [latex]n[/latex] в степени [latex]m[/latex]. Постарайтесь сделать алгоритм быстрым.
  2. Составить программу, выводящую на печать первые [latex]n[/latex] знаков числа [latex]\pi[/latex]. Число знаков может быть. Количество знаков задаётся переменной целого типа.
  3. Для заданного натурального [latex]n[/latex] выведите последовательность чисел в которой нулевой элемент показывает сколько раз встретилось в этой же последовательности число ноль. Первый элемент — сколько раз встретилась единица. Второй — двойка и т.д. до [latex]n[/latex]. Обработайте ситуацию, когда такой последовательности нет.

Побитовые операции в Java

В данной статье мы рассмотрим:

1. Что такое бит, история возникновения.

2. Побитовые операции в Java.


3. + в конце статьи будет бонус ��

Что такое бит. История возникновения

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

Жил был такой ученый Готфрид Вильгельм Лейбниц.

Может кто-то знает его за многочисленные заслуги в математике и не только:

  • создание математического анализа — дифференциальное и интегральное исчисления;
  • создал комбинаторику как науку;
  • заложил основы математической логики;
  • в физике сформулировал закон сохранения энергии;
  • в психологии развил учение о бессознательной психической жизни;
  • и именно он описал двоичную систему счисления с цифрами 0 и 1.

Одним словом — был серьезным ученым. И вот в 1703 году он описал двоичную систему исчисления с цифрами 0 и 1. В своей работе он упоминал, что двоичная система исчисления существовала в Китае много-много лет до того как он взялся за ее изучение. Она была описана великим Китайским императором и философом по имени Fu Xi (Фу Си), который жил еще более, чем за 4000 лет до Лейбница.

Китайский император описывал Инь и Ян как инь-ян«-«1«), китайский двоичный разряд, китайский бит. Другими словами можно сделать вывод, что двоичная система исчисления за долго до компьютеров уже имела огромную силу и большую историю!

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

Всем известна Дездемона из пьесы Уильяма Шекспира «Отелло«. И на вопрос «Молилась ли ты на ночь Дездемона?«, она могла бы ответить вот таким способом:

Тоесть, 1 это ДА, а это НЕТ!

Любое число можно перевести в последовательность Битов!
Например:

  • число 0 — (представление в битах) 0 0
  • число 1 — (представление в битах) 0 1
  • число 2 — (представление в битах) 1 0
  • число 3 — (представление в битах) 1 1
  • число 4 — (представление в битах) 1 0 0
  • число 5 — (представление в битах) 1 0 1
  • число 6 — (представление в битах) 1 1 0
  • число 7 — (представление в битах) 1 1 1
  • число 8 — (представление в битах) 1 0 0 0
  • число 9 — (представление в битах) 1 0 0 1
  • число 10 — (представление в битах) 1 0 1 0
  • число 15 — (представление в битах) 1 1 1 1
  • число 20 — (представление в битах) 1 0 1 0 0
  • число 25 — (представление в битах) 1 1 0 0 1
  • число 31 — (представление в битах) 1 1 1 1 1

Компьютер хранит в своей памяти таким образом любые символы (цифры, буквы, знаки препинания и т.д.) и для этого использует определенное количество бит. Компьютер распознает 256 (от 0 до 255) различных символов по их коду, чтобы вместить все цифры, буквы и много других символов.

Для представления символа с максимальным кодом, то есть 255 — нужно 8 бит. Эти 8 бит называются байтом. Один любой символ — это всегда 1 байт.

Но вернемся к Java!

— Что можно делать с битами с помощью языка программирования Java?

Побитовые операции!

Побитовые операции в Java можно проводить только над целочисленными типами данных. То есть long, int, short, char, byte.

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

Существуют следующие побитовые операторы в Java:

Пара слов о числах с плавающей точкой в 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 ситуация совершенно идентичная, за исключением того факта, что кол-во чисел после запятой значительно выше.

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

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

12.1. Java — Числа

Обычно, когда работаем с числами в Java, мы используем примитивные типы данных, таких как byte, int, long, double, и т.д.

Содержание

Пример

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

Все классы-оболочки (Integer, Long, Byte, Double, Float, Short) являются подклассами абстрактного класса чисел в Java (class Number).

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

Объект оболочки может быть преобразован обратно в примитивный тип данных, и этот процесс называется распаковка. Класс чисел является частью пакета java.lang.

Вот пример упаковки и распаковки:

Будет получен следующий результат:

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

Методы класса чисел

Список методов всех подклассов класса чисел в Java:

Блог только про Java

Учимся программировать на Java с нуля

Взаимное преобразование чисел и символьных строк Java

Одной из наиболее часто выполняемых рутинных операций в программиро­вании является преобразование строкового представления чисел во внутренний двоичный формат.

Правда, сделать это в Java совсем не трудно. В классах Byte, Short, Integer и Long для этой цели предоставляются методы parseByte(), parseShort(), parseInt() и parseLong() соответственно.

Эти методы возвра­щают значения типа byte, short, int или long, эквивалентные числовой стро­ке, с которой они были вызваны (аналогичные методы предусмотрены в классах Float и Double).

В приведенном ниже примере программы демонстрируется применение мето­да parseInt(). В этой программе суммируется ряд целочисленных значений, вво­димых пользователем.

С этой целью целочисленные значения считываются мето­дом readLine() в виде числовых строк, которые затем преобразуются методом parseInt() в эквивалентные им числовые значения типа int.

Вывод программы что-то наподобие следующего, все зависит от введенных вами чисел:

Для преобразования целого числа в десятичную строку служат варианты ме­тода toString(), определенные в классе Byte, Short, Integer или Long. В клас­сах Integer и Long предоставляются также методы toBinaryString(), toHexString() и toOctalString(), преобразующие числовое значение в двоичную, шестнадцатеричную и восьмеричную строки соответственно.

В следующем примере программы демонстрируется преобразование целого числа в двоичную, шестнадцатеричную и восьмеричную строковую форму:

Вывод программы что-то наподобие следующего, все зависит от введенных вами чисел:

Один комментарий на “ Взаимное преобразование чисел и символьных строк Java ”

Очень легко и доступно читаются Ваши статьи. У Вас есть твитер, чтобы быть в курсе ваших новых работ. Спасибо.

Нахождение простого числа с реализацией в виде метода на Java

Простое число — это натуральное (целое положительное) число, имеющее ровно два различных натуральных делителя — единицу и самого себя.
Другими словами, число p является простым, если оно больше 1 и при этом делится без остатка только на 1 и на p (на самого себя). (Википедия)

Примерами простых чисел являются: 3,7,13 и т.д.

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

Цукерберг рекомендует:  Работа с XML из Java
Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих
Входные данные Выходные данные