java – ページ 9 – サイゼントの技術ブログ

2019年12月14日

javaでのFacadeパターン

Facadeクラスとは、使い方が複雑になっているクラス群をまとめ、使いやすい形のインターフェースとして外部に提供するクラスのことを指します。
デザインパターンでは、このFacadeクラスを利用するパターンをFacadeパターンと呼びます。
（ちなみに、Facadeは「窓口」を意味する単語です）

サンプルコードとして、RPGのダメージ計算を模したプログラムを作成してみました。
RPGのダメージ計算は複雑で、そのRPGに詳しくない人が正しく計算式を実装するのは困難なのですが、Facadeクラスを用いることにより、Facadeクラスの利用者は詳しい知識を持たずとも正しく計算式を実装することが可能となります。

【サンプルコード】

・PhysicsBaseDamageCalc.java

public final class PhysicsBaseDamageCalc {

    private int baseDamage = 0;

    public PhysicsBaseDamageCalc(int physicsPower) {
        baseDamage = physicsPower / 2; //攻撃力の半分がダメージ
    }

    public int getBaseDamage() {
        return baseDamage;
    }

}

public final class PhysicsBaseDamageCalc {

private int baseDamage = 0;

public PhysicsBaseDamageCalc(int physicsPower) {

baseDamage = physicsPower / 2; //攻撃力の半分がダメージ

}

public int getBaseDamage() {

return baseDamage;

}

・MagicBaseDamageCalc.java

public final class MagicBaseDamageCalc {

    private int baseDamage = 0;

    public MagicBaseDamageCalc(int magicID) {
        if (magicID == 0) { //魔法「FireL1」
            baseDamage = 15;
        } else if (magicID == 1) { //魔法「FireL2」
            baseDamage = 60;
        } else if (magicID == 2) { //魔法「FireL3」
            baseDamage = 120;
        } else { //例外処理
            System.out.println("指定された魔法ＩＤは未実装です");
            System.exit(1);
        }
    }

    public int getBaseDamage() {
        return baseDamage;
    }

}

public final class MagicBaseDamageCalc {

private int baseDamage = 0;

public MagicBaseDamageCalc(int magicID) {

if (magicID == 0) { //魔法「FireL1」

baseDamage = 15;

} else if (magicID == 1) { //魔法「FireL2」

baseDamage = 60;

} else if (magicID == 2) { //魔法「FireL3」

baseDamage = 120;

} else { //例外処理

System.out.println("指定された魔法ＩＤは未実装です");

System.exit(1);

}

public int getBaseDamage() {

return baseDamage;

}

・DamageRandomize.java

import java.util.Random;

public final class DamageRandomize {

    private int damage = 0;

    public DamageRandomize(int baseDamage) {
        // 7/8、8/8、9/8の何れかの値をかけてランダム化
        damage = baseDamage * (new Random().nextInt(3) + 7) / 8;
    }

    public int getDamage() {
        return damage;
    }
}

import java.util.Random;

public final class DamageRandomize {

private int damage = 0;

public DamageRandomize(int baseDamage) {

// 7/8、8/8、9/8の何れかの値をかけてランダム化

damage = baseDamage * (new Random().nextInt(3) + 7) / 8;

}

public int getDamage() {

return damage;

}

・DamageCalcFacade.java

public final class DamageCalcFacade {

    private int damage = 0;

    public DamageCalcFacade (int physicsPower,int magicID) {
        int baseDamage = 0;
        if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃
            baseDamage = new PhysicsBaseDamageCalc(physicsPower)
                              .getBaseDamage();
        } else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃
            baseDamage = new MagicBaseDamageCalc(magicID)
                              .getBaseDamage();
        } else { //例外処理
            System.out.println("不正なダメージ計算です");
            System.exit(1);
        }
        damage = new DamageRandomize(baseDamage).getDamage();
    }

    public int getDamage() {
        return damage;
    }
}

public final class DamageCalcFacade {

private int damage = 0;

public DamageCalcFacade (int physicsPower,int magicID) {

int baseDamage = 0;

if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃

baseDamage = new PhysicsBaseDamageCalc(physicsPower)

.getBaseDamage();

} else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃

baseDamage = new MagicBaseDamageCalc(magicID)

.getBaseDamage();

} else { //例外処理

System.out.println("不正なダメージ計算です");

System.exit(1);

}

damage = new DamageRandomize(baseDamage).getDamage();

}

public int getDamage() {

return damage;

}

・DamageCalcMain.java

public class DamageCalcMain {
    public static void main(String[] args){

        int physicsPower = -1;
        int magicID = -1;
        int damage = 0;

        // 引数から物理攻撃力、魔法ＩＤを取得
        if (args.length == 2) {
            physicsPower = Integer.parseInt(args[0]);
            magicID = Integer.parseInt(args[1]);
        }

        // ダメージ計算→計算式を知らないとこのように実装できない
        /*
        int baseDamage = 0;
        if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃
            baseDamage = new PhysicsBaseDamageCalc(physicsPower)
                              .getBaseDamage();
        } else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃
            baseDamage = new MagicBaseDamageCalc(magicID)
                              .getBaseDamage();
        } else { //例外処理
            System.out.println("不正なダメージ計算です");
            System.exit(1);
        }
        damage = new DamageRandomize(baseDamage).getDamage();
        */

        // 利用者側で複雑な計算式を考えたくないので、Facadeクラスに任せる
        damage = new DamageCalcFacade(physicsPower,magicID).getDamage();

        System.out.println("ダメージは"+damage);
        System.exit(0);

    }
}

public class DamageCalcMain {

public static void main(String[] args){

int physicsPower = -1;

int magicID = -1;

int damage = 0;

// 引数から物理攻撃力、魔法ＩＤを取得

if (args.length == 2) {

physicsPower = Integer.parseInt(args[0]);

magicID = Integer.parseInt(args[1]);

}

// ダメージ計算→計算式を知らないとこのように実装できない

int baseDamage = 0;

if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃

baseDamage = new PhysicsBaseDamageCalc(physicsPower)

.getBaseDamage();

} else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃

baseDamage = new MagicBaseDamageCalc(magicID)

.getBaseDamage();

} else { //例外処理

System.out.println("不正なダメージ計算です");

System.exit(1);

}

damage = new DamageRandomize(baseDamage).getDamage();

// 利用者側で複雑な計算式を考えたくないので、Facadeクラスに任せる

damage = new DamageCalcFacade(physicsPower,magicID).getDamage();

System.out.println("ダメージは"+damage);

System.exit(0);

}

【実行結果】

ダメージは52

ダメージは52

　※第１引数に-1、第２引数に1を指定した場合

いかがでしたでしょうか。

デザインパターンはオブジェクト指向プログラミングのプログラミング手法をまとめたものなのですが、このFacadeパターンは手続き型言語にも応用が可能です。
複雑な処理を共通クラス・共通関数・共通スクリプト等のような形で切り出して利用者側に意識させないようにする、というのは現場でも良く使う手法なので、覚えておいて損はありません。

では、また次回！

2019年12月7日

javaでのスレッド制御（joinとsynchronized）

javaでは、スレッドを立てて処理を並列に行うことができます。
しかし、並列に処理を行う際、処理順を制御しなければならないことがあります。

処理順の制御方法として基本的な方法として、joinを使う方法とsynchronizedを使う方法があります。
joinを使うことで、スレッドが終わるのを待つことができます。
また、synchronizedを使うことで、複数のスレッドが同じ処理を同時に行わないように制御することができます。

以下は、joinやsynchronizedを使って制御を行うサンプルコードです。
１つのスレッドで５回の処理を行うサンプルであり、そのスレッドを２つ立てます。
また、スレッド間で同一のオブジェクト（staticなオブジェクト）を共有しており、そのオブジェクトでは合計何回処理が行われたのかをカウントしています。

制御を行わない場合は、どちらのスレッドが先に処理するのかが定まりません。また、共有オブジェクトでのカウントを２つのスレッドで同時に行うためにカウントも上手く行きません。
joinによる制御を行う場合は、スレッド１の５回の処理が終わってからスレッド２の処理に移る、という制御が可能になります。
synchronizedによる制御を行う場合は、スレッド１とスレッド２が同時に動いても、共有オブジェクトでのカウントは同時には行われず、上手くカウントすることができます。

【サンプルコード】

・ThreadMain.java

public class ThreadMain {
    public static void main(String[] args) {

        // スレッドのインスタンスを作成
        ThreadBody test1 = new ThreadBody("スレッド１");
        ThreadBody test2 = new ThreadBody("スレッド２");

        // スレッド１の実行
        test1.start();

        // ①スレッド１が終了するまで待機
        /*
        try {
            test1.join();
        } catch (InterruptedException e) {
            // 例外処理
            e.printStackTrace();
        }
        */

        // スレッド２の実行
        test2.start();
    }
}

public class ThreadMain {

public static void main(String[] args) {

// スレッドのインスタンスを作成

ThreadBody test1 = new ThreadBody("スレッド１");

ThreadBody test2 = new ThreadBody("スレッド２");

// スレッド１の実行

test1.start();

// ①スレッド１が終了するまで待機

try {

test1.join();

} catch (InterruptedException e) {

// 例外処理

e.printStackTrace();

}

// スレッド２の実行

test2.start();

}

・ThreadBody.java

public class ThreadBody extends Thread{

    private String threadName = null;
    private static ThreadCounter threadCounter = new ThreadCounter();

    ThreadBody(String threadName){
        this.threadName = threadName;
    }

    public void run(){
        for (int i = 0; i &lt; 5; i++) {
                threadCounter.countUp();
                System.out.println(threadName+"の"+(i+1)+"回目の処理");
        }
    }
}

public class ThreadBody extends Thread{

private String threadName = null;

private static ThreadCounter threadCounter = new ThreadCounter();

ThreadBody(String threadName){

this.threadName = threadName;

}

public void run(){

for (int i = 0; i < 5; i++) {

threadCounter.countUp();

System.out.println(threadName+"の"+(i+1)+"回目の処理");

}

・ThreadCounter.java

public class ThreadCounter {

    private int count;

    public void countUp() {
        // ②複数スレッドで同時実行されないよう同期を取る
        // synchronized (this) {
            // 1000ミリ秒スリープ
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
            System.out.println("処理回数："+count);
        // }
    }
}

public class ThreadCounter {

private int count;

public void countUp() {

// ②複数スレッドで同時実行されないよう同期を取る

// synchronized (this) {

// 1000ミリ秒スリープ

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

count++;

System.out.println("処理回数："+count);

// }

}

【実行結果】

・そのまま実行した場合

処理回数：2
処理回数：2
スレッド１の1回目の処理
スレッド２の1回目の処理
処理回数：3
処理回数：4
スレッド１の2回目の処理
スレッド２の2回目の処理
処理回数：6
処理回数：6
スレッド２の3回目の処理
スレッド１の3回目の処理
処理回数：8
処理回数：8
スレッド２の4回目の処理
スレッド１の4回目の処理
処理回数：10
処理回数：10
スレッド２の5回目の処理
スレッド１の5回目の処理

処理回数：2

スレッド１の1回目の処理

スレッド２の1回目の処理

処理回数：3

処理回数：4

スレッド１の2回目の処理

スレッド２の2回目の処理

処理回数：6

スレッド２の3回目の処理

スレッド１の3回目の処理

処理回数：8

スレッド２の4回目の処理

スレッド１の4回目の処理

処理回数：10

スレッド２の5回目の処理

スレッド１の5回目の処理

・①のコメントアウトを外した場合(join)

処理回数：1
スレッド１の1回目の処理
処理回数：2
スレッド１の2回目の処理
処理回数：3
スレッド１の3回目の処理
処理回数：4
スレッド１の4回目の処理
処理回数：5
スレッド１の5回目の処理
処理回数：6
スレッド２の1回目の処理
処理回数：7
スレッド２の2回目の処理
処理回数：8
スレッド２の3回目の処理
処理回数：9
スレッド２の4回目の処理
処理回数：10
スレッド２の5回目の処理

処理回数：1

スレッド１の1回目の処理

処理回数：2

スレッド１の2回目の処理

処理回数：3

スレッド１の3回目の処理

処理回数：4

スレッド１の4回目の処理

処理回数：5

スレッド１の5回目の処理

処理回数：6

スレッド２の1回目の処理

処理回数：7

スレッド２の2回目の処理

処理回数：8

スレッド２の3回目の処理

処理回数：9

スレッド２の4回目の処理

処理回数：10

スレッド２の5回目の処理

・②のコメントアウトを外した場合(synchronized)

処理回数：1
スレッド１の1回目の処理
処理回数：2
スレッド２の1回目の処理
処理回数：3
スレッド１の2回目の処理
処理回数：4
スレッド２の2回目の処理
処理回数：5
スレッド１の3回目の処理
処理回数：6
スレッド２の3回目の処理
処理回数：7
スレッド１の4回目の処理
処理回数：8
スレッド２の4回目の処理
処理回数：9
スレッド１の5回目の処理
処理回数：10
スレッド２の5回目の処理

処理回数：1

スレッド１の1回目の処理

処理回数：2

スレッド２の1回目の処理

処理回数：3

スレッド１の2回目の処理

処理回数：4

スレッド２の2回目の処理

処理回数：5

スレッド１の3回目の処理

処理回数：6

スレッド２の3回目の処理

処理回数：7

スレッド１の4回目の処理

処理回数：8

スレッド２の4回目の処理

処理回数：9

スレッド１の5回目の処理

処理回数：10

スレッド２の5回目の処理

いかがでしたでしょうか。

性能要件を満たすためにスレッドが必要になることがあるのですが、その際にスレッド制御の方法を知らないと処理の同期が取れずに障害になってしまうことが多いです。
今スレッドを使っていなかったとしても、いつ使うようになるかわかりませんので、こういったスレッド制御の方法を知っておいて損はありません。

では、また次回！

2019年12月1日

単なるstaticとsingletoneパターンの違い

オブジェクト指向プログラミングのプログラミング手法で、「singleton（シングルトン）」と呼ばれる手法があります。
この手法は、プロジェクト内で共通的に使われるインスタンスを１つだけ予め作成し、外部のクラスにはそのインスタンスを使用させる、という手法です。

この手法を学んだ時に「インスタンスを１つにすれば良いなら、クラス変数やメソッドをstaticにするだけで良いのでは？」と思ったので、試しにテストコードを書いてみました。
単純なstaticでは使用者側で好きにインスタンスを作成できる（実態としては１つ）のですが、singletonとしてインスタンスを作成すれば使用者側でのインスタンス作成を防ぎ、明示的にインスタンスを１つにできることを確認しました。

【テストコード】

・StaticMemory.java

public class StaticMemory {

    private static int num = 0;

    public static void setNum(int arg) {
        num = arg;
    }

    public static int getNum() {
        return num;
    }

}

public class StaticMemory {

private static int num = 0;

public static void setNum(int arg) {

num = arg;

}

public static int getNum() {

return num;

}

・SingletoneMemory.java

public class SingletoneMemory {

    private static int num = 0;
    private static SingletoneMemory instance = new SingletoneMemory();

    private SingletoneMemory(){
        // インスタンスを生成
    }

    public static SingletoneMemory getInstance(){
        return instance;
    }

    public static void setNum(int arg) {
        num = arg;
    }

    public static int getNum() {
        return num;
    }

}

public class SingletoneMemory {

private static int num = 0;

private static SingletoneMemory instance = new SingletoneMemory();

private SingletoneMemory(){

// インスタンスを生成

}

public static SingletoneMemory getInstance(){

return instance;

}

public static void setNum(int arg) {

num = arg;

}

public static int getNum() {

return num;

}

・MemoryTestMain.java

public class MemoryTestMain {

    // 要件：最新の値をメモリに保持したい
    @SuppressWarnings("static-access")
    public static void main(String[] args) {

        int recentNum = 0; // 最新の値

        // 普通のStaticなクラスを使った場合
        recentNum = 1;
        StaticMemory.setNum(recentNum);

        // 使う側がオブジェクトを作れてしまう
        StaticMemory instance1 = new StaticMemory();
        recentNum = 2;
        instance1.setNum(recentNum);

        StaticMemory instance2 = new StaticMemory();
        recentNum = 3;
        instance2.setNum(recentNum);

        // Staticなので実際には何れのオブジェクトも同じアドレスを指す
        System.out.println("元のStaticクラス："+StaticMemory.getNum());
        System.out.println("作ったオブジェクト１："+instance1.getNum());
        System.out.println("作ったオブジェクト２："+instance2.getNum());

        // Singletoneなクラスを使った場合
        // オブジェクトがprivateなので外部から作れない（下記はエラー）
        // SingletoneMemory instance3 = new SingletoneMemory();

        // 唯一のオブジェクトを取得する必要がある
        recentNum = 4;
        SingletoneMemory.getInstance().setNum(recentNum);
        System.out.println
        ("Singletoneクラス："+SingletoneMemory.getInstance().getNum());

    }

}

public class MemoryTestMain {

// 要件：最新の値をメモリに保持したい

@SuppressWarnings("static-access")

public static void main(String[] args) {

int recentNum = 0; // 最新の値

// 普通のStaticなクラスを使った場合

recentNum = 1;

StaticMemory.setNum(recentNum);

// 使う側がオブジェクトを作れてしまう

StaticMemory instance1 = new StaticMemory();

recentNum = 2;

instance1.setNum(recentNum);

StaticMemory instance2 = new StaticMemory();

recentNum = 3;

instance2.setNum(recentNum);

// Staticなので実際には何れのオブジェクトも同じアドレスを指す

System.out.println("元のStaticクラス："+StaticMemory.getNum());

System.out.println("作ったオブジェクト１："+instance1.getNum());

System.out.println("作ったオブジェクト２："+instance2.getNum());

// Singletoneなクラスを使った場合

// オブジェクトがprivateなので外部から作れない（下記はエラー）

// SingletoneMemory instance3 = new SingletoneMemory();

// 唯一のオブジェクトを取得する必要がある

recentNum = 4;

SingletoneMemory.getInstance().setNum(recentNum);

System.out.println

("Singletoneクラス："+SingletoneMemory.getInstance().getNum());

}

【実行結果】

元のStaticクラス：3
作ったオブジェクト１：3
作ったオブジェクト２：3
Singletoneクラス：4

元のStaticクラス：3

作ったオブジェクト１：3

作ったオブジェクト２：3

Singletoneクラス：4

いかがでしたでしょうか。

「singleton」は、GoFの23個のデザインパターンの内の1つに数えられる手法です。
デザインパターンはオブジェクト指向プログラミングのプログラミング手法をまとめたものであり、効率的なプログラミングを行う上で有効ですので、これからも紹介していくと思います。

では、また次回！

2019年11月2日

java：イミュータブルなクラスを作る方法

「イミュータブル」とは「不変」という意味で、オブジェクト指向の世界では「状態（クラス変数）がオブジェクト生成時から変更されないこと」を指します。
有名所では、Stringがイミュータブルなクラスとして知られています。

イミュータブルなクラスを自作するためには、以下の条件を満たすようにクラスを作成する必要があります。

①クラス変数はprivateで定義する

クラス変数が外のクラスから直接書き換えられるのを防ぐため

②setterメソッドを定義しない

クラス変数を書き換えるメソッドは定義しない

③クラスをfinalで定義する

サブクラスでクラス変数を書き換えられるのを防ぐため

④ミュータブルなオブジェクトへの参照を含んでいない

ミュータブルなオブジェクトを変更する処理を記述しないようにするため

クラスをイミュータブルにするメリットとしては、内部の状態の変化を気にする必要が無くなるために処理を追いやすくなるというのがあります。
関数型プログラミングにも通じる考え方なのですが、オブジェクト生成より後で内部の状態が書き変わることがないため、クラスのメソッドが返す値が一定となり、内部の状態の変化を気にしながらトレースする必要がなくなります。
また、
hoge2 = hoge1;
のようなオブジェクトのアドレスのコピーが使いやすくなります。
イミュータブルではないクラスでこのコピー方法を用いると、hoge2の状態の変化がhoge1にも影響してしまい（hoge1とhoge2で同じアドレスを指しているため）、思わぬ影響が出ることがあります。
しかし、イミュータブルなクラスであれば、状態を変化させようと思えば新たにオブジェクトを作り直して新たなメモリ領域を確保しなければならないので、hoge2の状態を変化させても（オブジェクトを作り直しても）hoge1へ影響するのを防ぐことができます。
イミュータブルではないクラスでも、オブジェクトの中身全体をコピーすれば思わぬ影響を防ぐことはできるのですが、オブジェクトのアドレスをコピーする場合と比べてメモリ使用量が増え処理も遅くなります。

以下で、イミュータブルなクラスを定義してそれを使用するサンプルコードを示します。

【サンプルコード】

・ImmutableCalc.java

// ③クラスをfinalで定義する
public final class ImmutableCalc {

    // ④ミュータブルなオブジェクトへの参照を含んでいない

    // ①クラス変数はprivateで定義する
    private int num = 0;

    // オブジェクト生成時のみ状態が変化する
    public ImmutableCalc(int num) {
        this.num = num;
    }

    // ②setterメソッドを定義しない
    public int singleCalc() {
        return num;
    }

    public int doubleCalc() {
        return num * 2;
    }

    public int tripleCalc() {
        return num * 3;
    }

}

// ③クラスをfinalで定義する

public final class ImmutableCalc {

// ④ミュータブルなオブジェクトへの参照を含んでいない

// ①クラス変数はprivateで定義する

private int num = 0;

// オブジェクト生成時のみ状態が変化する

public ImmutableCalc(int num) {

this.num = num;

}

// ②setterメソッドを定義しない

public int singleCalc() {

return num;

}

public int doubleCalc() {

return num * 2;

}

public int tripleCalc() {

return num * 3;

}

・ImmutableTestMain.java

public class ImmutableTestMain {

    public static void main(String[] args) {

        // イミュータブルなクラスのオブジェクトを作成
        ImmutableCalc hoge1 = new ImmutableCalc(1);

        // オブジェクトのアドレスをコピー
        // オブジェクトの中身をコピーするよりメモリ使用量が減り処理も速い
        ImmutableCalc hoge2 = hoge1;

        // 値を書き換えるにはnewして新たにメモリ領域を確保するしかない
        hoge2 = new ImmutableCalc(2);

        // hoge2の変更がhoge1に影響を与えない
        // アドレスをコピーするテクニックを安心して使える
        System.out.println("hoge1:"+hoge1.singleCalc());
        System.out.println("hoge2:"+hoge2.singleCalc());

        // オブジェクト生成時にしか値が書き変わらないので処理を追いやすい
        System.out.println("hoge1_double:"+hoge1.doubleCalc());
        System.out.println("hoge1_triple:"+hoge1.tripleCalc());

    }

}

public class ImmutableTestMain {

public static void main(String[] args) {

// イミュータブルなクラスのオブジェクトを作成

ImmutableCalc hoge1 = new ImmutableCalc(1);

// オブジェクトのアドレスをコピー

// オブジェクトの中身をコピーするよりメモリ使用量が減り処理も速い

ImmutableCalc hoge2 = hoge1;

// 値を書き換えるにはnewして新たにメモリ領域を確保するしかない

hoge2 = new ImmutableCalc(2);

// hoge2の変更がhoge1に影響を与えない

// アドレスをコピーするテクニックを安心して使える

System.out.println("hoge1:"+hoge1.singleCalc());

System.out.println("hoge2:"+hoge2.singleCalc());

// オブジェクト生成時にしか値が書き変わらないので処理を追いやすい

System.out.println("hoge1_double:"+hoge1.doubleCalc());

System.out.println("hoge1_triple:"+hoge1.tripleCalc());

}

【実行結果】

hoge1:1
hoge2:2
hoge1_double:2
hoge1_triple:3

hoge1:1

hoge2:2

hoge1_double:2

hoge1_triple:3

いかがでしたでしょうか。

オブジェクトの内部の状態を意識する手法には多くの技術者が慣れ親しんでいると思いますし、オブジェクトのアドレスのコピーも便利ですが、それが思わぬ影響を及ぼすこともあります。
思わぬ影響を防ぐために、イミュータブルなクラスを作成する手法は覚えておいて損はないでしょう。

これからも役に立つ情報を発信していきたいと思います！

2019年9月14日

java8：関数型インターフェースの背景にある考え方

【前置き】

Java8から関数型インターフェースが使用可能になりました。
具体的に「ラムダ式」「Stream」「Optional」「Files」と言った方がわかりやすいでしょうか。

関数型インターフェースの使用を半ば強制されるフレームワークが登場していたり（例：Apache Spark）、関数型インターフェースでJavaを書く開発者も増えてきたので、目にすることも多くなってきたかと思います。

関数型インターフェースは関数型プログラミングをサポートするものであるため、従来からJavaでサポートされていたオブジェクト指向プログラミングとは発想が異なります。
そのため、従来のJavaを学習してきた方にとっては抵抗感を感じるものであると思います。

今回の記事では、抵抗感を少しでも減らすために、関数型プログラミングの考え方を簡単に紹介したいと思います。

【サンプルコード】

言葉で説明するよりも先にサンプルコードを見た方がわかりやすいと思うので、サンプルコードを先に紹介します。
年齢のリストから30代の人数を数える、というプログラムです。
ごく短いプログラムですので、お付き合いください。

・FunctionTest.java

import java.util.Arrays;
import java.util.List;

public class FunctionalTest {

    public static void main(String[] args) {
        Integer[] age = {38, 26, 40, 32, 36};
        List＜Integer＞ list = Arrays.asList(age);

        System.out.println("手続き型として記述");
        int count = 0;
        for (int i = 0; i ＜ list.size(); i++) {
            int individualAge = list.get(i);
            if (individualAge ＞= 30 ＆＆ individualAge ＜= 39) {
                count++;
            }
        }
        System.out.println(count);

        System.out.println("関数型インターフェースを使用");
        System.out.println(list.stream()
                               .filter(x -＞ x ＞= 30 ＆＆ x ＜= 39)
                               .count());

    }
}

import java.util.Arrays;

import java.util.List;

public class FunctionalTest {

public static void main(String[] args) {

Integer[] age = {38, 26, 40, 32, 36};

List＜Integer＞ list = Arrays.asList(age);

System.out.println("手続き型として記述");

int count = 0;

for (int i = 0; i ＜ list.size(); i++) {

int individualAge = list.get(i);

if (individualAge ＞= 30 ＆＆ individualAge ＜= 39) {

count++;

}

System.out.println(count);

System.out.println("関数型インターフェースを使用");

System.out.println(list.stream()

.filter(x -＞ x ＞= 30 ＆＆ x ＜= 39)

.count());

}

・実行結果

手続き型として記述
3
関数型インターフェースを使用
3

手続き型として記述

関数型インターフェースを使用

【関数型プログラミングの考え方】

関数型プログラミングでは、以下のことを実現しようとしています。
色々難しい用語（例えば「副作用」等）はあるのですが、今回は用語を使わずに簡潔にまとめます。

・内部状態(State)を排除する

最も本質的な考え方です。

関数型プログラミングでは、内部状態を排除することを目的としています。
「内部状態」とは、上記のコードで言うと「count」や「i」を指します。

内部状態が入りこんでしまうと、内部状態により関数の結果が変わってしまうため、内部状態を把握する必要が出てきてしまい、可読性が悪化します。
（把握のために「count」や「i」をトレースする必要が出てきてしまう）
把握しきれずに意図しないバグを出してしまうことも珍しくありません。
内部状態を排除して、品質を上げよう、という発想です。

また、コンピュータにとっては内部状態は重要ですが、人間にとってはやりたいことを実現できれば良く、内部状態は重要ではありません。
重要ではない記述を削減することでコードを完結にしたい、という発想もあります。

Java8のラムダ式では、ラムダ式の外部で定義された変数の値をラムダ式の内部で変更することを禁止されています（コンパイルエラーになる）。
その背景には、内部状態の排除があると思っています。

・自然言語に近い形で処理を記述する

これは、コードが簡潔になった結果生じた副次的な考え方かもしれません。

関数型プログラミングでは、関数を組み合わせることにより処理を実現します。
関数を次々とつなぎ合わせるように記述することで、ソースコードが自然言語に近い形になります。
わかりやすく言えば、ソースコード自体がコメントのようになります。

例えば、サンプルコードでは「年齢のリストから30代の人数を数える」という処理を行おうとしています。
従来のプログラミングでは、これを実現するためにforループとかカウント用の変数を使用しており、何をしているのか把握するためには、内部状態をトレースして意図を汲み取る必要があります。
しかし、関数型プログラミングでは、
「list.stream().filter(x -> x >= 30 && x <= 39).count()」→
「listを30＜=x＜=39でfilterしてcountする」
と読めるため、
「年齢のリストから30代の人数を数える」
という処理であることを自然に把握することができます。

いかがでしたでしょうか。

IT業界、特にSIer業界だと、情報処理技術者試験を軸にして知識を身に付けることが多いかと思います。
しかし、情報処理技術者試験では手続き型プログラミングやオブジェクト指向プログラミングを中心とした出題で、関数型プログラミングが扱われることは全く言って良いほどありません。
そのためとっつきにくさは拭えないと思いますが、先進的な企業を中心に関数型プログラミングを取り入れる企業も出てきています。
これからのことを考えると、せめて、関数型プログラミングに対する抵抗感は払拭するべきではないかと思っています。

今回はこれで締めくくりたいと思います。
では、また来週！