Генерация уникальных случайных чисел в java

Генерирование целочисленных псевдослучайных значений

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

Обратите внимание, что закрывающаяся скобка квадратная, т.е. 20 входит в диапазон

В этом случае к разности
между максимальным и минимальным значениями следует добавить 1, т.е. определить диапазон целочисленных значений [5,21),
где 21 не попадает в желаемый диапазон :

// после подстановки значений
int i = (int)Math.random() * (20 - 5 + 1) + 5;
// получаем
int i = (int)Math.random() * 16 + 5;

Лучшие практики

Определить критерии производительности и балансировки нагрузки

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

с помощью является более гибким, но оно блокирует, если энтропия недостаточно велика на сервере, так как он читает из . Если вы не знаете, с чего начать, начните с .

Укажите ваши критерии, как это:

SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "SUN");

Ниже приведена дополнительная информация о поддерживаемых PRNG и провайдерах.

Ниже приведен список PRNG для поставщика SUN:

• SHA1PRNG (в настоящее время начальное заполнение выполняется с помощью комбинации системных атрибутов и устройства сбора энтропии java.security)
• NativePRNG (nextBytes() использует / dev / urandom, generateSeed() использует / dev / random)
• NativePRNGBlocking (nextBytes() и generateSeed() используют / dev / random)
• NativePRNGNonBlocking (nextBytes() и generateSeed() используют / dev / urandom)
• Блокировка NativePRNGB и NativePRNGNonBlocking доступны в JRE 8+.

Предоставить больше возможностей увеличить энтропию

Периодически новый экземпляр и повторяйте его, например:

SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "SUN");
sr.setSeed(SecureRandom.generateSeed(int))

Периодическое повторное посевание защищает от разглашения данных, если семена просочились. При использовании SHA1PRNG всегда вызывайте сразу после создания нового экземпляра PRNG.

Уменьшить предсказуемость

Если , параметр конфигурации в файле или системное свойство назначены с предсказуемым файлом / URL, то SecureRandom может стать предсказуемым.

Патч старых версий Java

Версии JRE старше 1.4.2 имеют известные проблемы с генерацией защищенных семян SHA1PRNG. Опять же, если вы используете старые версии Java, у вас больше проблем с безопасностью.

Старые версии Java очень небезопасны, и очень важно постоянно обновлять исправления. Один из лучших способов обеспечения безопасности ваших клиентов — это быстрая сертификация вашего программного обеспечения на предмет самого последнего возможного обновления Oracle Critical Patch

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

Пайтон предоставляет огромное количество библиотек для решения вычислительных задач. Большой набор методов ставит Python на один уровень с Matlab и Octave. Арифметические операции применяются относительно к целым числам типа int, вещественным типа float, комплексным complex.

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

Все возможные арифметические операции приведены в таблице.

Добавление одного числа к другому выполняет оператор additional. Вычитание осуществляется с помощью subtraction. Умножение одного числа на другое происходит с multiplication. Возведение в степень осуществляется с помощью exponenta. Для деления используется division.

Оператор modulus (%) возвращает остаток от деления левого операнда на правый. Если переменная a = 10, переменная b = 20, то b%a == 0. Что такое оператор деления с остатком, легко понять на следующем примере. Если 9/2 == 4.5, то 9//2 возвращает результат, равный 4. Деление с floor division (//) возвращает целое число от операции деления левого операнда на правый.

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

Наряду с целыми и вещественными числами в Python существуют комплексные числа. Они состоят из действительной и мнимой части. Записываются в виде c = a+bj, где а — действительная часть,

C.real()
#a

b — мнимая.

C.imag()
#b

Арифметические операции c комплексными числами имеют те же свойства, что и с вещественными. Использование complex numbers можно представить на плоскости с прямоугольной системой координат. Точка a пересечения оси X и оси Y соответствует комплексному числу x + yi. Таким образом, на оси X располагаются вещественные числа, а на вертикальной оси Y — мнимые.

Using Third-Party APIs

As we have seen, Java provides us with a lot of classes and methods for generating random numbers. However, there are also third-party APIs for this purpose.

We’re going to take a look at some of them.

3.1. org.apache.commons.math3.random.RandomDataGenerator

There are a lot of generators in the commons mathematics library from the Apache Commons project. The easiest, and probably the most useful, is the RandomDataGenerator. It uses the Well19937c algorithm for the random generation. However, we can provide our algorithm implementation.

Let’s see how to use it. Firstly, we have to add dependency:

The latest version of commons-math3 can be found on Maven Central.

Then we can start working with it:

3.2. it.unimi.dsi.util.XoRoShiRo128PlusRandom

Certainly, this is one of the fastest random number generator implementations. It has been developed at the Information Sciences Department of the Milan University.

The library is also available at Maven Central repositories. So, let’s add the dependency:

This generator inherits from java.util.Random. However, if we take a look at the JavaDoc, we realize that there’s only one way of using it —  through the nextInt method. Above all, this method is only available with the zero- and one-parameter invocations. Any of the other invocations will directly use the java.util.Random methods.

For example, if we want to get a random number within a range, we would write:

Пример

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

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

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

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

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

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

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

Causes of Error Code 0xc0000001

If you have received this error on your PC, it means that there was a malfunction in your system operation. Common reasons include incorrect or failed installation or uninstallation of software that may have left invalid entries in your Windows registry, consequences of a virus or malware attack, improper system shutdown due to a power failure or another factor, someone with little technical knowledge accidentally deleting a necessary system file or registry entry, as well as a number of other causes. The immediate cause of the “Error Code: 0xc0000001” error is a failure to correctly run one of its normal operations by a system or application component.

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

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

№	Метод с описанием
1	xxxValue() Преобразует значение целочисленного объекта в ххх тип данных и возвращает его.
2	compareTo() Сравнивает целочисленный объект с аргументом.
3	equals() Определяет, является ли целочисленный объект равным аргументу.
4	valueOf() Возвращает целочисленный объект, держа указанное значение.
5	toString() Возвращает строковый объект (String), представляющий указанное значение int или целочисленный объект.
6	parseInt() Метод используется для получения примитивного типа данных определенной строки.
7	abs() Возвращает абсолютное значение аргумента.
8	ceil() Возвращает наименьшее (ближайшее к отрицательной бесконечности) double значение, которое больше или равно аргументу и равное математическому целому числу.
9	floor() Возвращает наибольшее (ближайшее к положительной бесконечности) double значение, которое меньше или равно аргумента и равно математическому целому числу.
10	rint() Возвращает double значение, которое ближе всего по значению аргумента и равно математическому целому числу.
11	round() Возвращает ближайшее long или int к аргументу по правилам округления.
12	min() Возвращает меньшее из двух аргументов.
13	max() Возвращает большее из двух аргументов.
14	exp() Возвращает число е Эйлера, возведенную в степень double значения.
15	log() Возвращает натуральный логарифм (по основанию е) с double значением.
16	pow() Возвращает значение первого аргумента, возведенное в степень второго аргумента.
17	sqrt() Возвращает правильно округленный положительный квадратный корень из double значения.
18	sin() Возвращает синус указанного double значения.
19	cos() Возвращает косинус указанного double значения.
20	tan() Возвращает тангенс указанного double значения.
21	asin() Возвращает арксинус указанного double значения.
22	acos() Возвращает арккосинус указанного double значения.
23	atan() Возвращает арктангенс указанного double значения.
24	atan2() Возвращает угол тета от преобразования прямоугольных координат (x, y) в полярных координатах (г, тета).
25	toDegrees() Преобразует угол, измеренный в радианах в примерно эквивалентном угол, измеренный в градусах.
26	toRadians() Преобразует угол, измеренный в градусах, в приблизительно эквивалентный угол, измеренный в радианах.
27	random() Возвращает double значение с положительным знаком, больше чем или равно 0.0 и меньше чем 1.0 .

Поделитесь:

Method Summary

All MethodsInstance MethodsConcrete Methods

Modifier and Type	Method	Description
		Returns an effectively unlimited stream of pseudorandom values, each between zero (inclusive) and one (exclusive).
		Returns an effectively unlimited stream of pseudorandom values, each conforming to the given origin (inclusive) and bound (exclusive).
		Returns a stream producing the given number of pseudorandom values, each between zero (inclusive) and one (exclusive).
		Returns a stream producing the given number of pseudorandom values, each conforming to the given origin (inclusive) and bound (exclusive).
		Returns an effectively unlimited stream of pseudorandom values.
		Returns an effectively unlimited stream of pseudorandom values, each conforming to the given origin (inclusive) and bound (exclusive).
		Returns a stream producing the given number of pseudorandom values.
		Returns a stream producing the given number of pseudorandom values, each conforming to the given origin (inclusive) and bound (exclusive).
		Returns an effectively unlimited stream of pseudorandom values.
		Returns a stream producing the given number of pseudorandom values.
		Returns an effectively unlimited stream of pseudorandom values, each conforming to the given origin (inclusive) and bound (exclusive).
		Returns a stream producing the given number of pseudorandom , each conforming to the given origin (inclusive) and bound (exclusive).
		Generates the next pseudorandom number.
		Returns the next pseudorandom, uniformly distributed value from this random number generator’s sequence.
		Generates random bytes and places them into a user-supplied byte array.
		Returns the next pseudorandom, uniformly distributed value between and from this random number generator’s sequence.
		Returns the next pseudorandom, uniformly distributed value between and from this random number generator’s sequence.
		Returns the next pseudorandom, Gaussian («normally») distributed value with mean and standard deviation from this random number generator’s sequence.
		Returns the next pseudorandom, uniformly distributed value from this random number generator’s sequence.
		Returns a pseudorandom, uniformly distributed value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator’s sequence.
		Returns the next pseudorandom, uniformly distributed value from this random number generator’s sequence.
		Sets the seed of this random number generator using a single seed.

Игра в кости с использованием модуля random в Python

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

• Участники по очереди бросают кубики, предварительно встряхнув их;
• Алгоритм высчитывает сумму значений кубиков каждого участника и добавляет полученный результат на доску с результатами;
• Участник, у которого в результате большее количество очков, выигрывает.

Код программы для игры в кости Python:

Python

import random

PlayerOne = «Анна»
PlayerTwo = «Алекс»

AnnaScore = 0
AlexScore = 0

# У каждого кубика шесть возможных значений
diceOne =
diceTwo =

def playDiceGame():
«»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»»

for i in range(5):
#оба кубика встряхиваются 5 раз
random.shuffle(diceOne)
random.shuffle(diceTwo)
firstNumber = random.choice(diceOne) # использование метода choice для выбора случайного значения
SecondNumber = random.choice(diceTwo)
return firstNumber + SecondNumber

print(«Игра в кости использует модуль random\n»)

#Давайте сыграем в кости три раза
for i in range(3):
# определим, кто будет бросать кости первым
AlexTossNumber = random.randint(1, 100) # генерация случайного числа от 1 до 100, включая 100
AnnaTossNumber = random.randrange(1, 101, 1) # генерация случайного числа от 1 до 100, не включая 101

if( AlexTossNumber > AnnaTossNumber):
print(«Алекс выиграл жеребьевку.»)
AlexScore = playDiceGame()
AnnaScore = playDiceGame()
else:
print(«Анна выиграла жеребьевку.»)
AnnaScore = playDiceGame()
AlexScore = playDiceGame()

if(AlexScore > AnnaScore):
print («Алекс выиграл игру в кости. Финальный счет Алекса:», AlexScore, «Финальный счет Анны:», AnnaScore, «\n»)
else:
print(«Анна выиграла игру в кости. Финальный счет Анны:», AnnaScore, «Финальный счет Алекса:», AlexScore, «\n»)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

importrandom PlayerOne=»Анна» PlayerTwo=»Алекс» AnnaScore= AlexScore=   # У каждого кубика шесть возможных значений diceOne=1,2,3,4,5,6 diceTwo=1,2,3,4,5,6 defplayDiceGame() «»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»» foriinrange(5) #оба кубика встряхиваются 5 раз random.shuffle(diceOne) random.shuffle(diceTwo) firstNumber=random.choice(diceOne)# использование метода choice для выбора случайного значения SecondNumber=random.choice(diceTwo) returnfirstNumber+SecondNumber print(«Игра в кости использует модуль random\n»)   #Давайте сыграем в кости три раза foriinrange(3) # определим, кто будет бросать кости первым AlexTossNumber=random.randint(1,100)# генерация случайного числа от 1 до 100, включая 100 AnnaTossNumber=random.randrange(1,101,1)# генерация случайного числа от 1 до 100, не включая 101 if(AlexTossNumber>AnnaTossNumber) print(«Алекс выиграл жеребьевку.») AlexScore=playDiceGame() AnnaScore=playDiceGame() else print(«Анна выиграла жеребьевку.») AnnaScore=playDiceGame() AlexScore=playDiceGame() if(AlexScore>AnnaScore) print(«Алекс выиграл игру в кости. Финальный счет Алекса:»,AlexScore,»Финальный счет Анны:»,AnnaScore,»\n») else print(«Анна выиграла игру в кости. Финальный счет Анны:»,AnnaScore,»Финальный счет Алекса:»,AlexScore,»\n»)

Вывод:

Shell

Игра в кости использует модуль random

Анна выиграла жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 5 Финальный счет Алекса: 2

Анна выиграла жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 2

Алекс выиграл жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 8

1 2 3 4 5 6 7 8 9 10

Игравкостииспользуетмодульrandom   Аннавыигралажеребьевку. Аннавыигралаигрувкости.ФинальныйсчетАнны5ФинальныйсчетАлекса2   Аннавыигралажеребьевку. Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса2   Алексвыигралжеребьевку. Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса8

Вот и все. Оставить комментарии можете в секции ниже.

Наш Книговорот (bookcrossing.ru)

Выбор случайного элемента из списка choice() модуль random

Метод используется для выбора случайного элемента из списка. Набор может быть представлен в виде списка или python строки. Метод возвращает один случайный элемент последовательности.

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

Python

import random

list =
print(«random.choice используется для выбора случайного элемента из списка — «, random.choice(list))

1 2 3 4 5

importrandom list=55,66,77,88,99 print(«random.choice используется для выбора случайного элемента из списка — «,random.choice(list))

Вывод:

Shell

random.choice используется для выбора случайного элемента из списка — 55

1	random.choiceиспользуетсядлявыбораслучайногоэлементаизсписка-55

Using Java API

The Java API provides us with several ways to achieve our purpose. Let’s see some of them.

2.1. java.lang.Math

The random method of the Math class will return a double value in a range from 0.0 (inclusive) to 1.0 (exclusive). Let’s see how we’d use it to get a random number in a given range defined by min and max:

2.2. java.util.Random

Before Java 1.7, the most popular way of generating random numbers was using nextInt. There were two ways of using this method, with and without parameters. The no-parameter invocation returns any of the int values with approximately equal probability. So, it’s very likely that we’ll get negative numbers:

If we use the netxInt invocation with the bound parameter, we’ll get numbers within a range:

This will give us a number between 0 (inclusive) and parameter (exclusive). So, the bound parameter must be greater than 0. Otherwise, we’ll get a java.lang.IllegalArgumentException.

Java 8 introduced the new ints methods that return a java.util.stream.IntStream. Let’s see how to use them.

The ints method without parameters returns an unlimited stream of int values:

We can also pass in a single parameter to limit the stream size:

And, of course, we can set the maximum and minimum for the generated range:

2.3. java.util.concurrent.ThreadLocalRandom

Java 1.7 release brought us a new and more efficient way of generating random numbers via the ThreadLocalRandom class. This one has three important differences from the Random class:

• We don’t need to explicitly initiate a new instance of ThreadLocalRandom. This helps us to avoid mistakes of creating lots of useless instances and wasting garbage collector time
• We can’t set the seed for ThreadLocalRandom, which can lead to a real problem. If we need to set the seed, then we should avoid this way of generating random numbers
• Random class doesn’t perform well in multi-threaded environments

Now, let’s see how it works:

With Java 8 or above, we have new possibilities. Firstly, we have two variations for the nextInt method:

Secondly, and more importantly, we can use the ints method:

2.4. java.util.SplittableRandom

Java 8 has also brought us a really fast generator — the SplittableRandom class.

As we can see in the JavaDoc, this is a generator for use in parallel computations. It’s important to know that the instances are not thread-safe. So, we have to take care when using this class.

We have available the nextInt and ints methods. With nextInt we can set directly the top and bottom range using the two parameters invocation:

This way of using checks that the max parameter is bigger than min. Otherwise, we’ll get an IllegalArgumentException. However, it doesn’t check if we work with positive or negative numbers. So, any of the parameters can be negative. Also, we have available one- and zero-parameter invocations. Those work in the same way as we have described before.

We have available the ints methods, too. This means that we can easily get a stream of int values. To clarify, we can choose to have a limited or unlimited stream. For a limited stream, we can set the top and bottom for the number generation range:

2.5. java.security.SecureRandom

If we have security-sensitive applications, we should consider using SecureRandom. This is a cryptographically strong generator. Default-constructed instances don’t use cryptographically random seeds. So, we should either:

• Set the seed — consequently, the seed will be unpredictable
• Set the java.util.secureRandomSeed system property to true

This class inherits from java.util.Random. So, we have available all the methods we saw above. For example, if we need to get any of the int values, then we’ll call nextInt without parameters:

On the other hand, if we need to set the range, we can call it with the bound parameter:

We must remember that this way of using it throws IllegalArgumentException if the parameter is not bigger than zero.

Core team and contributors

Awesome contributors

• Adriano Machado
• Alberto Lagna
• Andrew Neal
• Arne Zelasko
• dadiyang
• Dovid Kopel
• Eric Taix
• euZebe
• Fred Eckertson
• huningd
• Johan Kindgren
• Joren Inghelbrecht
• Jose Manuel Prieto
• kermit-the-frog
• Lucas Andersson
• Michael Düsterhus
• Nikola Milivojevic
• nrenzoni
• Oleksandr Shcherbyna
• Petromir Dzhunev
• Rebecca McQuary
• Rodrigue Alcazar
• Ryan Dunckel
• Sam Van Overmeire
• Valters Vingolds
• Vincent Potucek
• Weronika Redlarska
• Konstantin Lutovich
• Steven_Van_Ophem
• Jean-Michel Leclercq
• Marian Jureczko
• Unconditional One
• JJ1216
• Sergey Chernov

Thank you all for your contributions!

Java Integer Math

Математические операции, выполняемые с целочисленными типами Java (byte, short, int и long), ведут себя немного иначе, чем обычные математические операции. Поскольку целочисленные типы не могут содержать дроби, в каждом вычислении с одним или несколькими целочисленными типами все дроби в результате обрезаются. Посмотрите на это математическое выражение:

int result = 100 / 8;

Результат этого деления будет 12,5, но так как два числа являются целыми числами, фракция .5 обрезается. Результат, следовательно, всего 12.

Округление также происходит в подрезультатах больших вычислений.

С плавающей точкой Math

Java содержит два типа данных с плавающей точкой: float и double. Они могут содержать дроби в числах. Если нужны дробные выражения в математических выражениях, вы должны использовать один из этих типов данных. Вот пример математического выражения с плавающей точкой:

double result = 100 / 8;

Несмотря на то, что переменная результата теперь имеет тип с плавающей запятой (double), конечный результат по-прежнему равен 12 вместо 12,5. Причина в том, что оба значения в математическом выражении (100 и 8) оба являются целыми числами. Таким образом, результат деления одного на другое сначала преобразуется в целое число (12), а затем присваивается переменной результата.

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

double no1 = 100;
double no2 = 8;

double result = no1 / no2;

Теперь переменная результата будет иметь значение 12,5.

В Java есть способ заставить все числа в расчете быть переменными с плавающей точкой. Вы ставите числа с большой буквы F или D. Вот пример:

double result = 100D / 8D;

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

На самом деле вы также можете сделать число длинным, добавив суффикс числа к верхнему регистру L, но long по-прежнему является целочисленным типом, поэтому он не будет сохранять дробные части в вычислениях.

Точность с плавающей точкой

Типы данных с плавающей точкой не являются точными на 100%. Вы можете столкнуться с ситуациями, когда числа со многими дробями не складываются с ожидаемым числом. Если вычисление с плавающей запятой приводит к числу с большим количеством дробей, чем может обработать число с плавающей запятой или двойное число, дроби могут быть обрезаны. Конечно, заданная точность может быть более чем достаточной для многих типов вычислений, но имейте в виду, что дроби могут фактически быть отсечены.

Посмотрите:

double resultDbl3 = 0D;
System.out.println("resultDbl3 = " + resultDbl3);

for(int i=0; i<100; i++){
    resultDbl3 += 0.01D;
}
System.out.println("resultDbl3 = " + resultDbl3);

Вывод выводится при выполнении этого кода с Java 8:

resultDbl3 = 0.0
resultDbl3 = 1.0000000000000007

Первый оператор System.out.println() правильно печатает значение 0.0, которое является начальным значением переменной resultDbl3.

Однако второй оператор System.out.println() выводит несколько странный результат. Добавление значения 0,01 к 0 всего 100 раз должно привести к значению 1,0, верно? Но каким-то образом окончательный результат 1.0000000000000007. Как видите, что-то не так во фракциях.

Обычно неточность с плавающей запятой незначительна, но все же важно знать об этом

Тригонометрические функции

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

Mathkpi

Константа Math.PI представляет собой двойное значение, значение которого очень близко к значению PI — математическому определению PI.

Math.sin()

Метод Math.sin() вычисляет значение синуса некоторого значения угла в радианах:

double sin = Math.sin(Math.PI);
System.out.println("sin = " + sin);

Math.cos()

Метод Math.cos() вычисляет значение косинуса некоторого значения угла в радианах:

double cos = Math.cos(Math.PI);
System.out.println("cos = " + cos);

Math.tan()

Метод Math.tan() вычисляет значение тангенса некоторого значения угла в радианах:

double tan = Math.tan(Math.PI);
System.out.println("tan = " + tan);

Math.asin()

Метод Math.asin() вычисляет значение синусоиды значения от 1 до -1:

double asin = Math.asin(1.0);
System.out.println("asin = " + asin);

Math.acos()

Метод Math.acos() вычисляет значение арккосинуса от 1 до -1:

double acos = Math.acos(1.0);
System.out.println("acos = " + acos);

Math.atan()

Метод Math.atan() вычисляет значение арктангенса для значения от 1 до -1:

double atan = Math.atan(1.0);
System.out.println("atan = " + atan);

Вот что говорит JavaDoc:

Если вам нужен этот метод, пожалуйста, прочитайте JavaDoc.

Math.sinh()

Метод Math.sinh() вычисляет значение гиперболического синуса значения между 1 и -1:

double sinh = Math.sinh(1.0);
System.out.println("sinh = " + sinh);

Math.cosh()

Метод Math.cosh() вычисляет значение гиперболического косинуса от 1 до -1:

double cosh = Math.cosh(1.0);
System.out.println("cosh = " + cosh);

Math.tanh()

Метод Math.tanh() вычисляет значение гиперболического тангенса значения от 1 до -1:

double tanh = Math.tanh(1.0);
System.out.println("tanh = " + tanh);

Math.toDegrees()

Метод Math.toDegrees() преобразует угол в радианах в градусы:

double degrees = Math.toDegrees(Math.PI);
System.out.println("degrees = " + degrees);

Math.toRadians()

Метод Math.toRadians() преобразует угол в градусах в радианы:

double radians = Math.toRadians(180);
System.out.println("radians = " + radians);