より小さい値を探すには、Mathクラスのminメソッドを使う。maxメソッドの対となるメソッドだ。

このページでは、Javaのminメソッドによる、「小さな値の取得」および「最小値の取得」についてお伝えしよう。参考にしてほしい。

Javaのどちらか小さな値の求め方

どちらか小さな値を求めるとは、負の無限大との距離がより短い値のことだ。（むしろわかりにくいかもしれないが。）

例えば、「100」と「-100」のどちらか小さな値といえば「-100」になる。

Javaでどちらか小さな値を求めるためにはminメソッドを利用する。

書き方の基本は簡単だ。

どちらか小さな値 = Math.min(対象となる数, 対象となる別の数)

Javaでの小さな値を求めるための書き方の詳細を確認していこう。

メソッドの型による違い

minメソッドの引数に指定したふたつの値のどちらか小さな値を求めるが、引数に指定できる値はdouble型・float型・int型・long型と種類がある。

double型

min(double a, double b)

float型

min(float a, float b)

int型

min(int a, int b)

long型

min(long a, long b)

Javaでどちらか小さな値を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

double型のサンプルコード

public class MinDouble {
    public static void main(String[] args) {
        double positiveValue        = 123.45;//[1]
        double positiveZero         = 0.0;//[2]
        double negativeZero         = - 0.0;//[3]
        double negativeValue        = -123.45;//[4]
        double nanValue             = Double.NaN;//[5]

        System.out.println("[6] 正のゼロ vs 正の値 : " + positiveValue + "-> "+ Math.min(positiveZero, positiveValue));
        System.out.println("[7] 正のゼロ vs 正のゼロ: " + positiveZero + "-> "+ Math.min(positiveZero, positiveZero));
        System.out.println("[8] 正のゼロ vs 負のゼロ: " + negativeZero + "-> " + Math.min(positiveZero, negativeZero));
        System.out.println("[9] 正のゼロ vs 負の値: " + negativeValue + "-> "  + Math.min(positiveZero, negativeValue));
        System.out.println("[10] 正のゼロ vs NaN(数値でない値) : " + nanValue + " -> "  + Math.min(positiveZero, nanValue));
        }
}

実行結果

[6] 正のゼロ vs 正の値 : 123.45 -> 0.0
[7] 正のゼロ vs 正のゼロ: 0.0 -> 0.0
[8] 正のゼロ vs 負のゼロ: -0.0 -> -0.0
[9] 正のゼロ vs 負の値: -123.45 -> -123.45
[10] 正のゼロ vs NaN(数値でない値) : NaN -> NaN

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは、扱うことのできる様々な値を持つ変数の比較からより小さな値を求めいている。

• [1] 正の値を変数：positiveValueに設定する。
• [2] 正のゼロを変数：positiveZeroに設定する。
• [3] 負のゼロを変数：negativeZeroに設定する。
• [4] 負の値を変数：negativeValueに設定する。
• [5] NaNを変数：nanValueに設定する。
• [6] 正のゼロとpositiveValueのどちらか小さな値を表示する。
• [7] 正のゼロとnegativeZeroのどちらか小さな値を表示する。
• [8] 正のゼロとpositiveInfinitのどちらか小さな値を表示する。
• [9] 正のゼロとnegativeValueのどちらか小さな値を表示する。
• [10] 正のゼロとnanValueを引数とするmin()メソッドの戻り値を表示する。

intのサンプルコード

public class MinInt {
    public static void main(String[] args) {
        int positiveValue        = 123;//[1]
        int negativeValue        = -123;//[2]

        System.out.println("[3] 異なる値 : "+ Math.min(positiveValue, negativeValue));
        System.out.println("[4] 同じ値: " + Math.min(negativeValue, negativeValue));
    }
}

実行結果

[3] 異なる値 : -123
[4] 同じ値: -123

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは、異なる値を持つ変数の比較と同じ値を持つ変数の比較からより小さな値を求めている。

• [1] 正の値を変数：positiveValueに設定する。
• [2] 負の値を変数：negativeValueに設定する。
• [3] 異なる値、positiveValueとnegativeValueのどちらか小さな値を表示する。
• [4] 同じ値、negativeValueとnegativeValueのどちらか小さな値を表示する。

Javaで最小値の求め方

minメソッドを使えば最小値も簡単に出すことができる。サンプルコードを確認してみよう。

サンプルコード

public class FindMinimumValue {
    public static void main(String[] args) {
        int values[] = {3, 2, 5, 0, -3};//[1]
        int min      = values[0];//[2]

        for (int index = 1; index < values.length; index ++) {//[3]
            min = Math.min(min, values[index]);//[4]
        }
        System.out.println("[5] 最小値 : "+ min);
    }
}

実行結果

[5] 最小値 : -3

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは、配列に設定したいくつかの数値の中からminメソッドを使って最小値を探している。

• [1] 配列：valuesに数値を設定する。
• [2] minを定義し、初期値に配列：valuesの最初の配列の値を設定する。
• [3] ループにより変数：indexを配列の2番目から最後までインクリメントする。
• [4] minメソッドを使って、変数：minとindexが示す配列のより小さいほうの値をminに設定する。
• [5] 最小値として変数：minを表示する。

まとめ

このページではJavaの「小さい値の求め方」「最小値の求め方」についてお伝えした。minメソッドを使えば簡単に出すことができることがおわかりいただけただろう。

minメソッド、使ってみていただければと思う。

square rootでsqrt、cube rootでcbrtだ。

実際に使い方をご紹介しよう。

Javaの平方根の求め方

Javaの平方根の基本

平方根を求めるとは、2乗するとbになるaの値をbの値から求めることだ。例えば、「9」の平方根といえば、「3」の「2」乗が「9」なので「3」になる。これを、平方根を求めるという。

Javaで平方根を求めるためにはsqrtメソッドを利用する。

書き方の基本は簡単だ。

平方根 = Math.sqrt(対象となる数値)

Javaでの平方根を求めるための書き方の詳細を確認していこう。

sqrtメソッド

sqrtメソッドの引数に指定した値の平方根を求める。引数に指定できる値はdouble型のみだ。

sqrt(double a)

Javaで平方根を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class SqrtDouble {
    public static void main(String[] args) {
        double positiveValue9       = 9.0;//[1]
        double negativeValue9       = -9.0;//[2]
        double positiveZero         = 0.0;//[3]
        double negativeZero         = - 0.0;//[4]
        double positiveInfinity     = Double.POSITIVE_INFINITY;//[5]
        double nanValue             = Double.NaN;//[6]

        System.out.println("[7] 9.0 の 平方根: " + Math.sqrt(positiveValue9 ));
        System.out.println("[8] -9.0 の 平方根: " + Math.sqrt(negativeValue9));
        System.out.println("[9] NaN の 平方根: " + Math.sqrt(nanValue));
        System.out.println("[10] 正の無限大 の 平方根: " + Math.sqrt(positiveInfinity));
        System.out.println("[11] 正のゼロ の 平方根: " + Math.sqrt(positiveZero));
        System.out.println("[12] 負のゼロ の 平方根: " + Math.sqrt(negativeZero));
    }
}

実行結果

[7] 9.0 の 平方根: 3.0
[8] -9.0 の 平方根: NaN
[9] NaN の 平方根: NaN
[10] 正の無限大 の 平方根: Infinity
[11] 正のゼロ の 平方根: 0.0
[12] 負のゼロ の 平方根: -0.0

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは、扱うことのできる様々な値を持つ変数の平方根を求めいている。

• [1] 9.0を変数：positiveValue9に設定する。
• [2] -9.0を変数：negativeValue9に設定する。
• [3] 正のゼロを変数：positiveZeroに設定する。
• [4] 負のゼロを変数：negativeZeroに設定する。
• [5] 正の無限大を変数：positiveInfinityに設定する。
• [6] NaNを変数：nanValueに設定する。
• [7] positiveValue9の平方根を表示する。
• [8] negativeValue9の平方根を表示する。
• [9] nanValueの平方根を表示する。
• [10] positiveInfinityの平方根を表示する。
• [11] positiveZeroの平方根を表示する。
• [12] negativeZeroの平方根を表示する。

Javaの立方根の求め方

Javaの立方根の基本

立方根を求めるとは、3乗するとbになるaの値をbの値から求めることだ。例えば、「27」の立方根といえば、「3」の「3」乗が「27」なので「3」になる。これを、立方根を求めるという。

Javaで立方根を求めるためにはcbrtメソッドを利用する。

書き方の基本は簡単だ。

立方根 = Math.cbrt(対象となる数値)

Javaでの立方根を求めるための書き方の詳細を確認していこう。

sqrtメソッド

sqrtメソッドの引数に指定した値から立方根を求める。引数に指定できる値はdouble型のみだ。

sqrt(double a)

Javaで立方根を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class CbrtDouble {
    public static void main(String[] args) {
        double positiveValue27      = 27.0;//[1]
        double negativeValue27      = -27.0;//[2]
        double positiveZero         = 0.0;//[3]
        double negativeZero         = - 0.0;//[4]
        double positiveInfinity     = Double.POSITIVE_INFINITY;//[5]
        double negativeInfinity     = Double.NEGATIVE_INFINITY;//[6]
        double nanValue             = Double.NaN;//[7]

        System.out.println("[8] 9.0 の 平方根: " + Math.cbrt(positiveValue27));
        System.out.println("[9] 9.0 の 平方根: " + Math.cbrt(negativeValue27));
        System.out.println("[10] NaN の 平方根: " + Math.cbrt(nanValue));
        System.out.println("[11] 正の無限大 の 平方根: " + Math.cbrt(positiveInfinity));
        System.out.println("[12] 負の無限大 の 平方根: " + Math.cbrt(negativeInfinity));
        System.out.println("[13] 正のゼロ の 平方根: " + Math.cbrt(positiveZero));
        System.out.println("[14] 負のゼロ の 平方根: " + Math.cbrt(negativeZero));
    }
}

実行結果

[8] 27.0 の 立方根: 3.0
[9] -27.0 の 立方根: -3.0
[10] NaN の 立方根: NaN
[11] 正の無限大 の 立方根: Infinity
[12] 負の無限大 の 立方根: -Infinity
[13] 正のゼロ の 立方根: 0.0
[14] 負のゼロ の 立方根: -0.0

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは、扱うことのできる様々な値を持つ変数の立方根を求めいている。

• [1] 27.0を変数：positiveValue27に設定する。
• [2] -27.0を変数：negativeValue27に設定する。
• [3] 正のゼロを変数：positiveZeroに設定する。
• [4] 負のゼロを変数：negativeZeroに設定する。
• [5] 正の無限大を変数：positiveInfinityに設定する。
• [6] 負の無限大を変数：negativeInfinityに設定する。
• [7] NaNを変数：nanValueに設定する。
• [8] positiveValue27の立方根を表示する。
• [9] negativeValue27の立方根を表示する。
• [10] nanValueの立方根を表示する。
• [11] positiveInfinityの立方根を表示する。
• [12] positiveInfinityの立方根を表示する。
• [13] negativeInfinityの立方根を表示する。
• [14] negativeZeroの立方根を表示する。

まとめ

このページでは、Javaでの平方根と立方根を算出するメソッドについてご紹介した。

学術的分野以外ではそこまで登場しないと思うので、必要になったときはこのページを再度確認してもらえればと思う。

しかし、数値解析などでよく利用されるし、知っておいて損はない。

このページではJavaでの対数の出し方をまとめている。必要なタイミングで参考にして頂ければと思う。

Javaの対数の求め方

対数を求めるとは，数値aのn乗がbだとするとaとbからnを求めることだ。例えば、「10」を底とする1000の対数といえば，「10」の「3」乗が「1000」なので「3」になる。これを、対数を求めるという。

Javaで対数を求めるためにはMathクラスのlogメソッドを利用する。

書き方の基本は簡単だ。

対数 = Math.log(対象となる数値)

ただし、底を何に設定するかで関数は変わる。Javaでの対数を求めるための書き方の詳細を確認していこう。

自然対数を求めるlogメソッド

logメソッドの基本

logメソッドは自然対数を求めるメソッドだ。ご存知の通り、自然対数とは「e」を底にしたときの対数のことである。

引数に指定した値から自然対数を求める。引数に指定できる値はdouble型のみだ。

log(double a)

Javaで対数を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class LogDouble {
    public static void main(String[] args) {
        double positiveValue1000 = 1000.0;//[1]
        double negativeValue1000 = -1000.0;//[2]
        double positiveZero         = 0.0;//[3]
        double negativeZero         = - 0.0;//[4]
        double positiveInfinity     = Double.POSITIVE_INFINITY;//[5]
        double nanValue             = Double.NaN;//[6]

        System.out.println("[7] 1000.0 の 自然対数: " + Math.log(positiveValue1000));
        System.out.println("[8] -1000.0 の 自然対数: " + Math.log(negativeValue1000));
        System.out.println("[9] NaN の 自然対数: " + Math.log(nanValue));
        System.out.println("[10] 正の無限大 の 自然対数: " + Math.log(positiveInfinity));
        System.out.println("[11] 正のゼロ の 自然対数: " + Math.log(positiveZero));
        System.out.println("[12] 負のゼロ の 自然対数: " + Math.log(negativeZero));
    }
}

実行結果

[7] 1000.0 の 自然対数: 6.907755278982137
[8] -1000.0 の 自然対数: NaN
[9] NaN の 自然対数: NaN
[10] 正の無限大 の 自然対数: Infinity
[11] 正のゼロ の 自然対数: -Infinity
[12] 負のゼロ の 自然対数: -Infinity

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは，扱うことのできる様々な値を持つ変数の対数を求めいている。

• [1] 1000.0を変数：positiveValue1000に設定する。
• [2] -1000.0を変数：negativeValue1000に設定する。
• [3] 正のゼロを変数：positiveZeroに設定する。
• [4] 負のゼロを変数：negativeZeroに設定する。
• [5] 正の無限大を変数：positiveInfinityに設定する。
• [6] NaNを変数：nanValueに設定する。
• [7] positiveValue1000の自然対数を表示する。
• [8] negativeValue1000の自然対数を表示する。
• [9] nanValueの自然対数を表示する。
• [10] positiveInfinityの自然対数を表示する。
• [11] positiveZeroの自然対数を表示する。
• [12] negativeZeroの自然対数を表示する。

常用対数を求めるlog10メソッド

log10メソッドの基本

log10メソッドの引数に指定した値から常用対数を求める。常用対数とは10を底にした対数だから、logの後に10がついた関数になっている。

引数に指定できる値はdouble型のみだ。

log10(double a)

Javaで常用対数を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class Log10Double {
    public static void main(String[] args) {
        double positiveValue1000 = 1000.0;//[1]
        double negativeValue1000 = -1000.0;//[2]
        double positiveZero         = 0.0;//[3]
        double negativeZero         = - 0.0;//[4]
        double positiveInfinity     = Double.POSITIVE_INFINITY;//[5]
        double nanValue             = Double.NaN;//[6]

        System.out.println("[7] 1000.0 の 常用対数: " + Math.log10(positiveValue1000));
        System.out.println("[8] -1000.0 の 常用対数: " + Math.log10(negativeValue1000));
        System.out.println("[9] NaN の 常用対数: " + Math.log10(nanValue));
        System.out.println("[10] 正の無限大 の 常用対数: " + Math.log10(positiveInfinity));
        System.out.println("[11] 正のゼロ の 常用対数: " + Math.log10(positiveZero));
        System.out.println("[12] 負のゼロ の 常用対数: " + Math.log10(negativeZero));
    }
}

実行結果

[7] 1000.0 の 常用対数: 3.0
[8] -1000.0 の 常用対数: NaN
[9] NaN の 常用対数: NaN
[10] 正の無限大 の 常用対数: Infinity
[11] 正のゼロ の 常用対数: -Infinity
[12] 負のゼロ の 常用対数: -Infinity

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは，扱うことのできる様々な値を持つ変数の常用対数を求めいている。

• [1] 1000.0を変数：positiveValue1000に設定する。
• [2] -1000.0を変数：negativeValue1000に設定する。
• [3] 正のゼロを変数：positiveZeroに設定する。
• [4] 負のゼロを変数：negativeZeroに設定する。
• [5] 正の無限大を変数：positiveInfinityに設定する。
• [6] NaNを変数：nanValueに設定する。
• [7] positiveValue1000の常用対数を表示する。
• [8] negativeValue1000の常用対数を表示する。
• [9] nanValueの常用対数を表示する。
• [10] positiveInfinityの常用対数を表示する。
• [11] positiveZeroの常用対数を表示する。
• [12] negativeZeroの常用対数を表示する。

引数に1を加えた値の自然対数を求めるlog1pメソッド

log1pメソッドの基本

log1pメソッドの引数に1を加えた値の自然対数を求める。1plusの意味だ。数学的には便利で、log(1.0+x) の浮動小数点評価よりも ln(1 + x) の実の結果に近くなる。

引数に指定できる値はdouble型のみだ。

log1p(double a)

Javaで引数+1の自然対数を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class Log1pDouble{
    public static void main(String[] args) {
        double positiveValue1000 = 1000.0;//[1]
        double negativeValue1000 = -1000.0;//[2]
        double positiveZero         = 0.0;//[3]
        double negativeZero         = - 0.0;//[4]
        double positiveInfinity     = Double.POSITIVE_INFINITY;//[5]
        double nanValue             = Double.NaN;//[6]

        System.out.println("[7] 1000.0 の +1自然対数: " + Math.log1p(positiveValue1000));
        System.out.println("[8] -1000.0 の +1自然対数: " + Math.log1p(negativeValue1000));
        System.out.println("[9] NaN の +1自然対数: " + Math.log1p(nanValue));
        System.out.println("[10] 正の無限大 の +1自然対数: " + Math.log1p(positiveInfinity));
        System.out.println("[11] 正のゼロ の +1自然対数: " + Math.log1p(positiveZero));
        System.out.println("[12] 負のゼロ の +1自然対数: " + Math.log1p(negativeZero));
    }
}

実行結果

[7] 1000.0 の +1自然対数: 6.90875477931522
[8] -1000.0 の +1自然対数: NaN
[9] NaN の +1自然対数: NaN
[10] 正の無限大 の +1自然対数: Infinity
[11] 正のゼロ の +1自然対数: 0.0
[12] 負のゼロ の +1自然対数: -0.0

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは，扱うことのできる様々な値を持つ変数に1を加えた自然対数を求めいている。

• [1] 1000.0を変数：positiveValue1000に設定する。
• [2] -1000.0を変数：negativeValue1000に設定する。
• [3] 正のゼロを変数：positiveZeroに設定する。
• [4] 負のゼロを変数：negativeZeroに設定する。
• [5] 正の無限大を変数：positiveInfinityに設定する。
• [6] NaNを変数：nanValueに設定する。
• [7] positiveValue1000の+1自然対数を表示する。
• [8] negativeValue1000の+1自然対数を表示する。
• [9] nanValueの+1自然対数を表示する。
• [10] positiveInfinityの+1自然対数を表示する。
• [11] positiveZeroの+1自然対数を表示する。
• [12] negativeZeroの+1自然対数を表示する。

その他の対数はどうやって求めるか？

任意の底を持つ対数を求めるためのメソッドはない。対数の底の変換公式を使って求めることになる。

例えば底が5、真数が20であれば次のようになる。

double value = Math.log(20.0) / Math.log(5.0);

まとめ

このページではJavaで対数logを求めるためのメソッドについてまとめてきた。いかがだっただろうか？

logメソッドだけを知っているだけでも十分だが、便利な他二つのメソッドもできれば掴んでおこう。

それぞれMathクラスのceilメソッド、floorメソッド、roundメソッドを使用していくが、詳細をご紹介していこう。

Javaの切り上げの求め方

Javaによる切り上げ

切り上げとは，対象の数値より大きいか等しい整数値の中で、対象の数値との距離が最も小さい整数値を求めることだ。反対に難しいかもしれない。

例えば，「10.4」の小数点以下を切り上げると，「11」になる。これを，切り上げを求めるという。

Javaで切り上げを求めるためにはceilメソッドを利用する。

書き方の基本は簡単だ。

切り上げ = Math.ceil(対象となる数値)

Javaでの切り上げるための書き方の詳細を確認していこう。

ceilメソッド

ceilメソッドの引数に指定した値から切り上げを求める。引数に指定できる値はdouble型のみだ。

ceil(double a)

Javaで切り上げを求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class CeilDouble {
    public static void main(String[] args) {
        double positiveValue100        = 10.0;//[1]
        double positiveValue104        = 10.4;//[2]
        double positiveValue105        = 10.5;//[3]
        double negativeValue100        = -10.0;//[4]
        double negativeValue105 = -10.5;//[5]
        double negativeValue106 = -10.6;//[6]
        double positiveInfinity        = Double.POSITIVE_INFINITY;//[7]
        double positiveZero            = 0.0;//[8]
        double negativeZero            = - 0.0;//[9]
        double negativeInfinity        = Double.NEGATIVE_INFINITY;//[10]
        double nanValue                = Double.NaN;//[11]
        double negativeValue005        = - 0.5;//[12]

        System.out.println("[13] 10.0 : " + Math.ceil(positiveValue100));
        System.out.println("[14] 10.4 : " + Math.ceil(positiveValue104));
        System.out.println("[15] 10.5 : " + Math.ceil(positiveValue105));
        System.out.println("[16] -10.0 : " + Math.ceil(negativeValue100));
        System.out.println("[17] -10.5 : " + Math.ceil(negativeValue105));
        System.out.println("[18] -10.6 : " + Math.ceil(negativeValue106));
        System.out.println("[19] NaN(数値でない値) : " + Math.ceil(nanValue));
        System.out.println("[20] 正の無限大 : " + Math.ceil(positiveInfinity));
        System.out.println("[21] 負の無限大 : " + Math.ceil(negativeInfinity));
        System.out.println("[22] 正のゼロ : " + Math.ceil(positiveZero));
        System.out.println("[23] 負のゼロ : " + Math.ceil(negativeZero));
        System.out.println("[24] -0.5 : " + Math.ceil(negativeValue005));
    }
}

実行結果

[13] 10.0 : 10.0
[14] 10.4 : 11.0
[15] 10.5 : 11.0
[16] -10.0 : -10.0
[17] -10.5 : -10.0
[18] -10.6 : -10.0
[19] NaN(数値でない値) : NaN
[20] 正の無限大 : Infinity
[21] 負の無限大 : -Infinity
[22] 正のゼロ : 0.0
[23] 負のゼロ : -0.0
[24] -0.5 : -0.0

サンプルプログラムの説明

それでは簡単にプログラムの解説をしていこう。

このプログラムは，扱うことのできる様々な値を持つ変数の切り上げを求めいている。

• [1] 10.0を変数：positiveValue100に設定する。
• [2] 10.4を変数：positiveValue104に設定する。
• [3] 10.5を変数：positiveValue105に設定する。
• [4] -10.0を変数：negativeValue100に設定する。
• [5] -10.5を変数：negativeValue105に設定する。
• [6] -10.6を変数：negativeValue106に設定する。
• [7] 正の無限大を変数：positiveInfinityに設定する。
• [8] 正のゼロを変数：positiveZeroに設定する。
• [9] 負のゼロを変数：negativeZeroに設定する。
• [10] 正の無限大を変数：negativeInfinityに設定する。
• [11] NaNを変数：nanValueに設定する。
• [12] -0.5を変数：negativeValue005に設定する。
• [13] positiveValue100の切り上げを表示する。
• [14] positiveValue104の切り上げを表示する。
• [15] positiveValue105の切り上げを表示する。
• [16] negativeValue100の切り上げを表示する。
• [17] negativeValue105の切り上げを表示する。
• [18] negativeValue106の切り上げを表示する。
• [19] positiveInfinityの切り上げを表示する。
• [20] positiveZeroの切り上げを表示する。
• [21] negativeZeroの切り上げを表示する。
• [22] negativeInfinityの切り上げを表示する。
• [23] nanValueの切り上げを表示する。
• [24] negativeValue005の切り上げを表示する。

Javaの切捨ての求め方

Javaによる切捨て

切捨てを求めるとは，対象の数値より小さいか等しい整数値の中で，対象の数値との距離が最も小さい整数値を求めることだ。例えば，「10.02」を切捨てると，「10.00」になる。これを，切捨てを求めるという。

Javaで切捨てを求めるためにはfloorメソッドを利用する。

書き方の基本は簡単だ。

切捨て = Math.floor(対象となる数値)

Javaでの切捨てを求めるための書き方の詳細を確認していこう。

floorメソッド

floorメソッドの引数に指定した値から切捨てを求める。引数に指定できる値はdouble型のみだ。

floor(double a)

Javaで切捨てを求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class FloorDouble {
    public static void main(String[] args) {
        double positiveValue100        = 10.0;//[1]
        double positiveValue104        = 10.4;//[2]
        double positiveValue105        = 10.5;//[3]
        double negativeValue100        = -10.0;//[4]
        double negativeValue105        = -10.5;//[5]
        double negativeValue106        = -10.6;//[6]
        double positiveInfinity        = Double.POSITIVE_INFINITY;//[7]
        double positiveZero            = 0.0;//[8]
        double negativeZero            = - 0.0;//[9]
        double negativeInfinity        = Double.NEGATIVE_INFINITY;//[10]
        double nanValue                = Double.NaN;//[11]

        System.out.println("[12] 10.0 : " + Math.floor(positiveValue100));
        System.out.println("[13] 10.4 : " + Math.floor(positiveValue104));
        System.out.println("[14] 10.5 : " + Math.floor(positiveValue105));
        System.out.println("[15] -10.0 : " + Math.floor(negativeValue100));
        System.out.println("[16] -10.5 : " + Math.floor(negativeValue105));
        System.out.println("[17] -10.6 : " + Math.floor(negativeValue106));
        System.out.println("[18] NaN(数値でない値) : " + Math.floor(nanValue));
        System.out.println("[19] 正の無限大 : " + Math.floor(positiveInfinity));
        System.out.println("[20] 負の無限大 : " + Math.floor(negativeInfinity));
        System.out.println("[21] 正のゼロ : " + Math.floor(positiveZero));
        System.out.println("[22] 負のゼロ : " + Math.floor(negativeZero));
    }
}

実行結果

[12] 10.0 : 10.0
[13] 10.4 : 10.0
[14] 10.5 : 10.0
[15] -10.0 : -10.0
[16] -10.5 : -11.0
[17] -10.6 : -11.0
[18] NaN(数値でない値) : NaN
[19] 正の無限大 : Infinity
[20] 負の無限大 : -Infinity
[21] 正のゼロ : 0.0
[22] 負のゼロ : -0.0

サンプルプログラムの説明

それでは簡単にプログラムの解説をしていこう。このプログラムは，扱うことのできる様々な値を持つ変数の切捨てを求めいている。

• [1] 10.0を変数：positiveValue100に設定する。
• [2] 10.4を変数：positiveValue104に設定する。
• [3] 10.5を変数：positiveValue105に設定する。
• [4] -10.0を変数：negativeValue100に設定する。
• [5] -10.5を変数：negativeValue105に設定する。
• [6] -10.6を変数：negativeValue106に設定する。
• [7] 正の無限大を変数：positiveInfinityに設定する。
• [8] 正のゼロを変数：positiveZeroに設定する。
• [9] 負のゼロを変数：negativeZeroに設定する。
• [10] 正の無限大を変数：negativeInfinityに設定する。
• [11] NaNを変数：nanValueに設定する。
• [12] positiveValue100の切捨てを表示する。
• [13] positiveValue105の切捨てを表示する。
• [14] positiveValue106の切捨てを表示する。
• [15] negativeValue100の切捨てを表示する。
• [16] negativeValue104の切捨てを表示する。
• [17] negativeValue105の切り上げを表示する。
• [18] positiveInfinityの切り上げを表示する。
• [19] positiveZeroの切り上げを表示する。
• [20] negativeZeroの切り上げを表示する。
• [21] negativeInfinityの切り上げを表示する。
• [22] nanValueの切り上げを表示する。

Javaの四捨五入の求め方

Javaによる四捨五入

四捨五入を求めるとは，対象の数値との距離が最も小さい整数値を求めることだ。対象の数値が二つの整数値の中間にあるときは，二つの内の大きいほうの整数値になる。例えば，「10.4」を四捨五入すると，「10.0」になる。また，「10.5」を四捨五入すると，「11.0」になる。これを，四捨五入を求めるという。

Javaで四捨五入を求めるためにはroundメソッドを利用する。

書き方の基本は簡単だ。

四捨五入 = Math.round(対象となる数値)

Javaでの四捨五入を求めるための書き方の詳細を確認していこう。

メソッドの型による違い

roundメソッドの引数に指定した値から四捨五入を求める。引数に指定できる値はdouble型・float型と種類がある。

double型

round(double a)

float型

round(float a)

Javaで四捨五入を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class RoundDouble {
    public static void main(String[] args) {
        double positiveValue100        = 10.0;//[1]
        double positiveValue104        = 10.4;//[2]
        double positiveValue105        = 10.5;//[3]
        double negativeValue100        = -10.0;//[4]
        double negativeValue105        = -10.5;//[5]
        double negativeValue106        = -10.6;//[6]
        double positiveInfinity        = Double.POSITIVE_INFINITY;//[7]
        double longMaximumValue        = Long.MAX_VALUE;//[8]
        double longMinimumValue        = Long.MIN_VALUE;//[9]
        double negativeInfinity        = Double.NEGATIVE_INFINITY;//[10]
        double nanValue                = Double.NaN;//[11]

        System.out.println("[12] 10.0 : " + Math.round(positiveValue100));
        System.out.println("[13] 10.4 : " + Math.round(positiveValue104));
        System.out.println("[14] 10.5 : " + Math.round(positiveValue105));
        System.out.println("[15] -10.0 : " + Math.round(negativeValue100));
        System.out.println("[16] -10.5 : " + Math.round(negativeValue105));
        System.out.println("[17] -10.6 : " + Math.round(negativeValue106));
        System.out.println("[18] NaN(数値でない値) : " + Math.round(nanValue));
        System.out.println("[19] 正の無限大 : " + Math.round(positiveInfinity));
        System.out.println("[20] Long.MAX_VALUE : " + Math.round(longMaximumValue));
        System.out.println("[21] Long.MIN_VALUE : " + Math.round(longMinimumValue));
        System.out.println("[22] 負の無限大 : " + Math.round(negativeInfinity));
    }
}

実行結果

[12] 10.0 : 10
[13] 10.4 : 10
[14] 10.5 : 11
[15] -10.0 : -10
[16] -10.5 : -10
[17] -10.6 : -11
[18] NaN(数値でない値) : 0
[19] 正の無限大 : 9223372036854775807
[21] Long.MAX_VALUE : 9223372036854775807
[22] Long.MIN_VALUE : -9223372036854775808
[20] 負の無限大 : -9223372036854775808

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは，扱うことのできる様々な値を持つ変数の四捨五入を求めいている。

• [1] 10.0を変数：positiveValue100に設定する。
• [2] 10.4を変数：positiveValue104に設定する。
• [3] 10.5を変数：positiveValue105に設定する。
• [4] -10.0を変数：negativeValue100に設定する。
• [5] -10.5を変数：negativeValue105に設定する。
• [6] -10.6を変数：negativeValue106に設定する。
• [7] 正の無限大を変数：positiveInfinityに設定する。
• [8] 正のゼロを変数：positiveZeroに設定する。
• [9] 負のゼロを変数：negativeZeroに設定する。
• [10] 正の無限大を変数：negativeInfinityに設定する。
• [11] NaNを変数：nanValueに設定する。
• [12] positiveValue100の四捨五入を表示する。
• [13] positiveValue104の四捨五入を表示する。
• [14] positiveValue105の四捨五入を表示する。
• [15] negativeValue100の四捨五入を表示する。
• [16] negativeValue105の四捨五入を表示する。
• [17] negativeValue106の四捨五入を表示する。
• [18] positiveInfinityの四捨五入を表示する。
• [19] positiveZeroの四捨五入を表示する。
• [20] negativeZeroの四捨五入を表示する。
• [21] negativeInfinityの四捨五入を表示する。
• [22] nanValueの四捨五入を表示する。

まとめ

切り上げのceilメソッド、切捨てのfloorメソッド、四捨五入のroundメソッドについてご紹介してきた。

一番使うのはroundだろうか。floorもよく使う。いちいち調べるのも手間なので、覚えてしまおう。

例えば、年利0.8%の預金の複利を計算したいときなど累乗を使うはずだ。

JavaではMathクラスのpowメソッドを利用して計算ができる。

Javaの累乗の求め方

累乗とは、ひとつの数値を繰り返し乗じることだ。例えば、「2」の「3」乗といえば、2 x 2 x 2となるので計算結果は「8」になる。これを、累乗を求めるという。

Javaで累乗を求めるためにはpowメソッドを利用する。

書き方の基本は簡単だ。

累乗 = Math.pow(底, 指数)

「底」の「指数」乗になる。

Javaでの累乗を求めるための書き方の詳細を確認していこう。

powメソッド

powメソッドの引数に指定したふたつの値から累乗を求めるが、引数に指定できる値はdouble型のみだ。

pow(double a, double b)

Javaで累乗を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

public class PowDouble {
    public static void main(String[] args) {
        double positiveValue1       = 1.0;//[1]
        double positiveValue2       = 2.0;//[2]
        double positiveValue3       = 3.0;//[3]
        double negativeValue3       = -3.0;//[4]
        double positiveZero         = 0.0;//[5]
        double negativeZero         = - 0.0;//[6]
        double nanValue             = Double.NaN;//[7]

        System.out.println("[8] 2.0 の 3.0 乗: " + Math.pow(positiveValue2, positiveValue3));
        System.out.println("[9] 2.0 x 2.0 x 2.0: " + (positiveValue2 * positiveValue2 * positiveValue2));
        System.out.println("[10] 2.0 の -3.0 乗: " + Math.pow(positiveValue2, negativeValue3));
        System.out.println("[11] (1.0 / 2.0) x (1.0 / 2.0) x (1.0 / 2.0) : " + ((1.0 / positiveValue2) * (1.0 / positiveValue2) * (1.0 / positiveValue2)));
        System.out.println("[12] 2.0 の 正のゼロ 乗: " + Math.pow(positiveValue2, positiveZero));
        System.out.println("[13] 2.0 の 負のゼロ 乗: " + Math.pow(positiveValue2, negativeZero));
        System.out.println("[14] 2.0 の 1.0 乗: " + Math.pow(positiveValue2, positiveValue1));
        System.out.println("[15] 2.0 の NaN 乗: " + Math.pow(positiveValue2, nanValue));
        System.out.println("[16] NaN の 3.0 乗: " + Math.pow(nanValue, positiveValue3));    }
}

実行結果

[8] 2.0 の 3.0 乗: 8.0
[9] 2.0 x 2.0 x 2.0: 8.0
[10] 2.0 の -3.0 乗: 0.125
[11] (1.0 / 2.0) x (1.0 / 2.0) x (1.0 / 2.0) : 0.125
[12] 2.0 の 正のゼロ 乗: 1.0
[13] 2.0 の 負のゼロ 乗: 1.0
[14] 2.0 の 1.0 乗: 2.0
[15] 2.0 の NaN 乗: NaN
[16] NaN の 3.0 乗: NaN

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは、扱うことのできる様々な値を持つ変数の組み合わせによる累乗を求めいている。

• [1] 1.0を変数：positiveValue1に設定する。
• [2] 2.0を変数：positiveValue2に設定する。
• [3] 3.0変数：positiveValue3に設定する。
• [4] -3.0変数：negativeValue3に設定する。
• [5] 0.0変数：positiveZeroに設定する。
• [6] -0.0変数：negativeZeroに設定する。
• [7] NaNを変数：nanValueに設定する。
• [8] positiveValue2のpositiveValue3乗を表示する。
• [9] positiveValue2 * positiveValue2 * positiveValue2を表示する。
• [10] positiveValue2のnegativeValue3乗を表示する。
• [11] (1.0 / positiveValue2) * (1.0 / positiveValue2) * (1.0 / positiveValue2)を表示する。
• [12] positiveValue2のpositiveZero乗を表示する。
• [13] positiveValue2のnegativeZero乗を表示する。
• [14] positiveValue2のpositiveValue1乗を表示する。
• [15] positiveValue2のnanValue乗を表示する。
• [16] nanValue,のpositiveValue3乗を表示する。

まとめ

このページではJavaの累乗を算出するためにpowメソッドをご紹介した。

簡単なので、いつでも使えるようにしておこう。

大きい値を探すには、Mathクラスのmaxメソッドを使う。

このページでは、Javaのmaxメソッドによる、「大きな値の取得」および「最大値の取得」についてお伝えしよう。参考にしてほしい。

Javaによる「どちらか大きな値」の求め方

Javaで数値を比べて、より大きな値を取得するにはmaxメソッドを利用する。

書き方の基本は簡単だ。

どちらか大きな値 = Math.max(対象となる数, 対象となる別の数)

次のようになる。

Math.max(1,2) //出力2

Javaでmaxメソッドの利用方法を確認していこう。

メソッドの型による違い

maxメソッドの引数に指定したふたつの値のどちらか大きな値を求めるが、引数に指定できる値はdouble型・float型・int型・long型と種類がある。

double型

max(double a, double b)

float型

max(float a, float b)

int型

max(int a, int b)

long型

max(long a, long b)

Javaでどちらか大きな値を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

double型

サンプルコード

public class MaxDouble {
    public static void main(String[] args) {
        double positiveValue        = 123.45;//[1]
        double positiveZero         = 0.0;//[2]
        double negativeZero         = - 0.0;//[3]
        double negativeValue        = -123.45;//[4]
        double nanValue             = Double.NaN;//[5]

        System.out.println("[6] 正のゼロ vs 正の値 : " + positiveValue + " -> "+ Math.max(positiveZero, positiveValue));
        System.out.println("[7] 正のゼロ vs 正のゼロ: " + positiveZero + " -> "+ Math.max(positiveZero, positiveZero));
        System.out.println("[8] 正のゼロ vs 負のゼロ: " + negativeZero + " -> " + Math.max(positiveZero, negativeZero));
        System.out.println("[9] 正のゼロ vs 負の値: " + negativeValue + " -> "  + Math.max(positiveZero, negativeValue));
        System.out.println("[10] 正のゼロ vs NaN(数値でない値) : " + nanValue + " -> "  + Math.max(positiveZero, nanValue));
    }
}

実行結果

[6] 正のゼロ vs 正の値 : 123.45 -> 123.45
[7] 正のゼロ vs 正のゼロ: 0.0 -> 0.0
[8] 正のゼロ vs 負のゼロ: -0.0 -> 0.0
[9] 正のゼロ vs 負の値: -123.45 -> 0.0
[10] 正のゼロ vs NaN(数値でない値) : NaN -> NaN

サンプルプログラムの説明

それでは簡単にプログラムの解説をしていこう。

このプログラムは、扱うことのできる様々な値を持つ変数の比較からより大きな値を求めいている。

• [1] 正の値を変数：positiveValueに設定する。
• [2] 正のゼロを変数：positiveZeroに設定する。
• [3] 負のゼロを変数：negativeZeroに設定する。
• [4] 負の値を変数：negativeValueに設定する。
• [5] NaNを変数：nanValueに設定する。

出力は次の通りだ。

• [6] 正のゼロとpositiveValueのどちらか大きな値を表示する。
• [7] 正のゼロとnegativeZeroのどちらか大きな値を表示する。
• [8] 正のゼロとpositiveInfinitのどちらか大きな値を表示する。
• [9] 正のゼロとnegativeValueのどちらか大きな値を表示する。
• [10] 正のゼロとnanValueを引数とするmax()メソッドの戻り値を表示する。

int型

サンプルコード

public class MaxInt {
    public static void main(String[] args) {
        int positiveValue        = 123;//[1]
        int negativeValue        = -123;//[2]

        System.out.println("[3] 異なる値 : "+ Math.max(positiveValue, negativeValue));
        System.out.println("[4] 同じ値: " + Math.max(negativeValue, negativeValue));
    }
}

実行結果

[3] 異なる値 : 123
[4] 同じ値: -123

サンプルプログラムの説明

プログラムの解説をしていこう。

このプログラムは、異なる値を持つ変数の比較と同じ値を持つ変数の比較からより大きな値を求めいている。

• [1] 正の値を変数：positiveValueに設定する。
• [2] 負の値を変数：negativeValueに設定する。
• [3] 異なる値、positiveValueとnegativeValueのどちらか大きな値を表示する。
• [4] 同じ値、negativeValueとnegativeValueのどちらか大きな値を表示する。

Javaで最大値の求め方

Javaで最大値を求めるためには、次のようにmaxメソッドをループで回していく。サンプルコードを確認してみてほしい。

サンプルコード

public class FindMaximumValue {
    public static void main(String[] args) {
        int values[] = {3, 2, 5, 0, -3};//[1]
        int max      = values[0];//[2]

        for (int index = 1; index < values.length; index ++) {//[3]
            max = Math.max(max, values[index]);//[4]
        }
        System.out.println("[5] 最大値 : "+ max);
    }
}}

実行結果

[5] 最大値 : 5

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

このプログラムは、配列に設定したいくつかの数値の中からmax関数を使って最大値を探している。

• [1] 配列：valuesに数値を設定する。
• [2] maxを定義し、初期値に配列：valuesの最初の配列の値を設定する。
• [3] ループにより変数：indexを配列の2番目から最後までインクリメントする。
• [4] maxメソッドを使って、変数：maxとindexが示す配列のより大きいほうの値をmaxに設定する。
• [5] 最大値として変数：maxを表示する。

配列をオブジェクトに変えて、java.util.Collections.maxメソッドを使えば、ループを回す必要がなくなるが、いかんせんあまり利用されていない。しかし、これくらいは知っておくといいだろう。

まとめ

このページでは、JavaでのMathクラスのmaxメソッドによる大きな値の取得と最大値の取得についてお伝えした。

これらはプログラムを組む上で、よく登場するものだ。ぜひ理解をしておこう。

数値計算系のプログラムはもちろんのこと、ただ「値と値の差」だけを知りたいときなど、絶対値は登場してくる。

このページではJavaで絶対値を計算する方法をお伝えする。

Javaの絶対値の求め方

絶対値とは、0からの距離だ。例えば、「3」も「-3」も0からの距離は「3」になる。これを絶対値という。

Javaで絶対値を求めるためにはMathクラスのabsメソッドを利用する。書き方の基本は簡単だ。

絶対値の値 = Math.abs(対象となる数)

下記で、Javaでの絶対値を求める書き方の詳細を確認していこう。

メソッドの型による違い

abs関数の引数に指定した値の絶対値を求めるが、引数に指定できる値はdouble型・float型・int型・long型と種類がある。

double型

abs(double a)

float型

abs(float a)

int型

abs(int a)

long型

abs(long a)

Javaで絶対値を求めるサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

サンプルコード

public class AbsDouble {
    public static void main(String[] args) {
        double positiveInfinity     = Double.POSITIVE_INFINITY;//[1]
        double positiveValue        = 12.34;//[2]
        double positiveZero         = 0.0;//[3]
        double negativeZero         = - 0.0;//[4]
        double negativeValue        = -12.34;//[5]
        double negativeInfinity     = Double.NEGATIVE_INFINITY;//[6]
        double nanValue             = Double.NaN;//[7]

        System.out.println("[8] 正の無限大 : " + positiveInfinity + "-> "+ Math.abs(positiveInfinity));
        System.out.println("[9] 正の値 : " + positiveValue + "-> "+ Math.abs(positiveValue));
        System.out.println("[10] 正のゼロ : " + positiveZero + "-> "+ Math.abs(positiveZero));
        System.out.println("[11] 負のゼロ : " + negativeZero + "-> " + Math.abs(negativeZero));
        System.out.println("[12] 負の値 : " + negativeValue + "-> "  + Math.abs(negativeValue));
        System.out.println("[13] 負の無限大 : " + negativeInfinity + "-> "  + Math.abs(negativeInfinity));
        System.out.println("[14] NaN(数値でない値) : " + nanValue + "-> "  + Math.abs(nanValue));
    }
}

実行結果

[8] 正の無限大 : Infinity -> Infinity
[9] 正の値 : 12.34 -> 12.34
[10] 正のゼロ : 0.0 -> 0.0
[11] 負のゼロ : -0.0 -> 0.0
[12] 負の値 : -12.34 -> 12.34
[13] 負の無限大 : -Infinity -> Infinity
[14] NaN(数値でない値) : NaN -> NaN

サンプルプログラムの説明

それでは簡単にプログラムの解説をする。

設定側

• [1] 正の無限大を変数：positiveInfinityに設定する
• [2] 正の値を変数：positiveValueに設定する
• [3] 正のゼロを変数：positiveZeroに設定する
• [4] 負のゼロを変数：negativeZeroに設定する
• [5] 負の値を変数：negativeValueに設定する
• [6] 負の無限大を変数：negativeInfinityに設定する
• [7] NaNを変数：nanValueに設定する

表示側

• [8] positiveInfinityの値と絶対値を表示する
• [9] positiveValueの値と絶対値を表示する
• [10] negativeZeroの値と絶対値を表示する
• [11] positiveInfinitの値と絶対値を表示する
• [12] negativeValueの値と絶対値を表示する
• [13] negativeInfinityの値と絶対値を表示する
• [14] nanValueの値と絶対値を表示する

まとめ

このページではJavaの絶対値についてまとめてみた。

様々な場面で登場する関数なので、ぜひ覚えてしまおう。