サイゼントの技術ブログ – Just another WordPress site

2020年10月23日

java：関数を引数として渡す

C#では、こちらの記事のようにdelegateの仕組みを利用して関数を変数として扱うことができます。
例えば、引数と引き渡してコールバック処理を実現することができます。

javaでも、8以降であれば関数型インターフェースを利用して関数を変数として扱うことができます。
以下、サンプルコードです。

【サンプルコード】

・FunctionMain.java

import java.util.function.Function;

public class FunctionMain {
    public static void main(String［］ args) {

        // Function型の変数の定義
        // 変数の中身はFunctionMainクラスのmakeEndMessage関数
        Function＜String, String＞ function = FunctionMain::makeEndMessage;

        // 関数を引数として渡す
        somethingFunc(function);
    }

    public static void somethingFunc(Function&lt;String, String> endFunc) {
        System.out.println("DoSomething");
        // 引き渡された関数を実行
        System.out.println(endFunc.apply("Something"));
    }

    // 今回引き渡す関数
    public static String makeEndMessage(String s) {
        return "End" + s;
    }

}

import java.util.function.Function;

public class FunctionMain {

public static void main(String［］ args) {

// Function型の変数の定義

// 変数の中身はFunctionMainクラスのmakeEndMessage関数

Function＜String, String＞ function = FunctionMain::makeEndMessage;

// 関数を引数として渡す

somethingFunc(function);

}

public static void somethingFunc(Function<String, String> endFunc) {

System.out.println("DoSomething");

// 引き渡された関数を実行

System.out.println(endFunc.apply("Something"));

}

// 今回引き渡す関数

public static String makeEndMessage(String s) {

return "End" + s;

}

【実行結果】

DoSomething
EndSomething

1 2	DoSomething EndSomething

上記のようにFunction型を用いるのが基本的な形なのですが、いくつか発展的な記法が存在します。

例えば、引数と戻り値が同じ型である場合は、UnaryOperator型を使用することでジェネリクスの表記を省略することができます。
（他にも、戻り値がvoidの場合に適用できるConsumer型、戻り値がboolean型の場合に適用できるPredicate型等が存在します）

また、引き渡す関数をラムダ式で表記することで、関数の定義を省略することができます。

【サンプルコード】

・FunctionMain.java

import java.util.function.UnaryOperator;

public class FunctionMain {
    public static void main(String［］ args) {

        // 引数と戻値が同じ場合はUnaryOperatorで簡略化できる
        // ラムダ式で関数の記述を簡略化できる
        UnaryOperator＜String＞ function = (x) -＞ {return "End" + x;};

        somethingFunc(function);
    }

    public static void somethingFunc(UnaryOperator＜String＞ endFunc) {
        System.out.println("DoSomething");
        System.out.println(endFunc.apply("Something"));
    }

}

import java.util.function.UnaryOperator;

public class FunctionMain {

public static void main(String［］ args) {

// 引数と戻値が同じ場合はUnaryOperatorで簡略化できる

// ラムダ式で関数の記述を簡略化できる

UnaryOperator＜String＞ function = (x) -＞ {return "End" + x;};

somethingFunc(function);

}

public static void somethingFunc(UnaryOperator＜String＞ endFunc) {

System.out.println("DoSomething");

System.out.println(endFunc.apply("Something"));

}

【実行結果】

DoSomething
EndSomething

1 2	DoSomething EndSomething

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

最近ではJava8以降の文法が使われる機会が多く、今回紹介したような関数型インターフェースも使われることが少なくありません。
従来のJavaと比べると書き方が独特に感じるかもしれませんが、慣れておくと実際の案件で困ることが少なくなると思います。

2020年10月16日

無名クラスとは

javaやC#では、インスタンス変数をnewする際に、後ろに中かっこを記述し定義を行うことができます。
ここで定義されるものは「無名クラス（匿名クラス）」と呼ばれ、クラス名を新たに定義することなく、インスタンス変数のクラス・インターフェースを継承・実装したクラスを定義することができます。
（ちなみに、「ラムダ式」と呼ばれる文法は「無名クラス」を応用したものになります）

以下、javaの例です。

【サンプルコード】

・AnonymousClass.java

public class AnonymousClass {
    private String STR = "Hello Class!";
    public String getSTR() {
        return STR;
    }
    public void print() {
        System.out.println(getSTR());
    }
}

public class AnonymousClass {

private String STR = "Hello Class!";

public String getSTR() {

return STR;

}

public void print() {

System.out.println(getSTR());

}

・AnonymousInterface.java

public interface AnonymousInterface {
    public void print();
}

public interface AnonymousInterface {

public void print();

}

・AnonymousMain.java

public class AnonymousMain {
    public static void main(String［］ args) {

        // 匿名クラス作成（クラスの継承）
        AnonymousClass ac = new AnonymousClass(){
            public void print() {
                System.out.println("Anonymous:" + getSTR());
            }
        };
        ac.print();

        // 匿名クラス作成（インターフェースの実装）
        AnonymousInterface ai = new AnonymousInterface() {
            public void print() {
                System.out.println("Anonymous:Hello Interface!");
            }
        };
        ai.print();
    }
}

public class AnonymousMain {

public static void main(String［］ args) {

// 匿名クラス作成（クラスの継承）

AnonymousClass ac = new AnonymousClass(){

public void print() {

System.out.println("Anonymous:" + getSTR());

}

};

ac.print();

// 匿名クラス作成（インターフェースの実装）

AnonymousInterface ai = new AnonymousInterface() {

public void print() {

System.out.println("Anonymous:Hello Interface!");

}

};

ai.print();

}

【実行結果】

Anonymous:Hello Class!
Anonymous:Hello Interface!

1 2	Anonymous:Hello Class! Anonymous:Hello Interface!

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

無名クラスは、使い捨てのクラスを作りたい時に便利です。
また、前述のラムダ式等を理解する上でも、無名クラスを理解する必要があります。

javaの入門書には出てくることが少ない文法だと思いますが、javaに慣れたらこの文法も早い内に理解することをお勧めします。

2020年10月9日

java：標準入出力の入力元・出力先を変更する

javaには
・System.setIn
・System.setOut
・System.setErr
の３つのメソッドが用意されており、これらのメソッドにより標準入出力の入力元・出力先を変更することができます。
これらのメソッドを利用することで、標準入力や標準出力を使用している処理の立ち振る舞いを外から変えることができます。

以下は、標準入力をハードコーディングで与え、標準出力・標準エラー出力を文字列として受け取りファイルに出力する例です。

【サンプルコード】

・SystemInOut.java

import java.util.Scanner;

public class SystemInOut {
    public void execute() throws InterruptedException {
        // try-with-resources
        try (Scanner sc = new Scanner(System.in)) {
            String str = sc.nextLine();
            System.out.println("入力された文字：" + str);
            Thread.sleep(500); // 標準出力してから標準エラー出力する
            System.err.println("エラー無し");
        }
    }
}

import java.util.Scanner;

public class SystemInOut {

public void execute() throws InterruptedException {

// try-with-resources

try (Scanner sc = new Scanner(System.in)) {

String str = sc.nextLine();

System.out.println("入力された文字：" + str);

Thread.sleep(500); // 標準出力してから標準エラー出力する

System.err.println("エラー無し");

}

・SystemInOutMain.java

import java.io.ByteArrayOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

public class SystemInOutMain {
    public static void main(String［］ args)
            throws InterruptedException, IOException {

        // 標準入出力のオブジェクトを退避
        InputStream orgIn = System.in;
        PrintStream orgOut = System.out;
        PrintStream orgErr = System.err;

        // 標準入力の入力元を変更
        class MyInputStream extends InputStream {
            private StringBuilder sb = new StringBuilder();

            // 標準入力したい文字を登録。nextLineに対応するため改行を付与。
            public void typeLine(String str){
                sb.append(str).append(System.getProperty("line.separator"));
            }

            // InputStreamの仕様上readメソッドの実装の必要あり
            @Override
            public int read() {
                if (sb.length() == 0) {
                    return -1; // ストリームの終わり
                }
                int result = sb.charAt(0); // 次に読み込むバイト値
                sb.deleteCharAt(0); // 読み込んだので削除
                return result;
            }
        }
        MyInputStream myIn = new MyInputStream();
        System.setIn(myIn); // 自作の標準入力オブジェクトをセット
        myIn.typeLine("hoge"); // 標準入力に相当する操作

        // 標準出力の出力先を変更
        ByteArrayOutputStream baos1 = new ByteArrayOutputStream();
        PrintStream myOut = new PrintStream(baos1);
        System.setOut(myOut);

        // 標準エラー出力の出力先を変更
        ByteArrayOutputStream baos2 = new ByteArrayOutputStream();
        PrintStream myErr = new PrintStream(baos2);
        System.setErr(myErr);

        // 標準入出力を含む処理を実行
        SystemInOut systemInOut = new SystemInOut();
        systemInOut.execute();

        // 標準出力相当の出力をStringで受け取りファイル出力
        String outStr = new String(baos1.toByteArray());
        FileWriter fw1 = new FileWriter("C:\\tmp\\test1.txt");
        fw1.write(outStr);
        fw1.close();

        // 標準エラー出力相当の出力をStringで受け取りファイル出力
        String errStr = new String(baos2.toByteArray());
        FileWriter fw2 = new FileWriter("C:\\tmp\\test2.txt");
        fw2.write(errStr);
        fw2.close();

        // 後処理
        myIn.close();
        myOut.close();
        baos1.close();
        myErr.close();
        baos2.close();
        System.setIn(orgIn);
        System.setOut(orgOut);
        System.setErr(orgErr);

        // 後処理により標準入出力の入力元・出力先が戻ることも確認済
        // systemInOut.execute();
    }
}

import java.io.ByteArrayOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintStream;

public class SystemInOutMain {

public static void main(String［］ args)

throws InterruptedException, IOException {

// 標準入出力のオブジェクトを退避

InputStream orgIn = System.in;

PrintStream orgOut = System.out;

PrintStream orgErr = System.err;

// 標準入力の入力元を変更

class MyInputStream extends InputStream {

private StringBuilder sb = new StringBuilder();

// 標準入力したい文字を登録。nextLineに対応するため改行を付与。

public void typeLine(String str){

sb.append(str).append(System.getProperty("line.separator"));

}

// InputStreamの仕様上readメソッドの実装の必要あり

@Override

public int read() {

if (sb.length() == 0) {

return -1; // ストリームの終わり

}

int result = sb.charAt(0); // 次に読み込むバイト値

sb.deleteCharAt(0); // 読み込んだので削除

return result;

}

MyInputStream myIn = new MyInputStream();

System.setIn(myIn); // 自作の標準入力オブジェクトをセット

myIn.typeLine("hoge"); // 標準入力に相当する操作

// 標準出力の出力先を変更

ByteArrayOutputStream baos1 = new ByteArrayOutputStream();

PrintStream myOut = new PrintStream(baos1);

System.setOut(myOut);

// 標準エラー出力の出力先を変更

ByteArrayOutputStream baos2 = new ByteArrayOutputStream();

PrintStream myErr = new PrintStream(baos2);

System.setErr(myErr);

// 標準入出力を含む処理を実行

SystemInOut systemInOut = new SystemInOut();

systemInOut.execute();

// 標準出力相当の出力をStringで受け取りファイル出力

String outStr = new String(baos1.toByteArray());

FileWriter fw1 = new FileWriter("C:\\tmp\\test1.txt");

fw1.write(outStr);

fw1.close();

// 標準エラー出力相当の出力をStringで受け取りファイル出力

String errStr = new String(baos2.toByteArray());

FileWriter fw2 = new FileWriter("C:\\tmp\\test2.txt");

fw2.write(errStr);

fw2.close();

// 後処理

myIn.close();

myOut.close();

baos1.close();

myErr.close();

baos2.close();

System.setIn(orgIn);

System.setOut(orgOut);

System.setErr(orgErr);

// 後処理により標準入出力の入力元・出力先が戻ることも確認済

// systemInOut.execute();

}

【処理結果】

コンソールは入出力無し

・C:\tmp\test1.txt

入力された文字：hoge

1	入力された文字：hoge

・C:\tmp\test2.txt

エラー無し

エラー無し

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

簡易なシステムやレガシーなシステムだと、標準入出力を入出力とするプログラムが少なくないと思います。
そのようなプログラムに対して、外側から立ち振る舞いを変えられるのは便利です。
例えば、JUnitでテストする時に便利だと思いますし、リファクタリングを行う一つの手段にもなり得ると思います。

役に立ちそうな技があれば今後も紹介していきたいと思います！

2020年10月2日

フローチャートを書く意義と書き方

フローチャートは、処理の流れを図に起こして整理するために使う技法です。
フローチャートを起こすことで、他の人に処理の流れを伝えやすくなるので、設計書では良く用いられます。
また、自分自身も処理の流れを理解しやすくなるので、複雑なプログラムを組む前に作ることも多いです。

特にプログラミングに慣れていない内は処理の流れを考えるのにも一苦労だと思いますので、プログラミングする前にフローチャートを書く癖を身に付けることをお勧めします。

以下、フローチャートの書き方や例を提示していきます。

１．フローチャートの例

フローチャートは、記号を線で結ぶことで作成します。
記号の中には具体的な内容を記述します。

フローチャートには詳細なものと概要を把握するものに大別できます。
詳細なフローチャートは、プログラムの１行１行を記号に落としていくようなイメージであり、すぐにプログラムに落とし込むことが難しい初学者にお勧めできるフローチャートです。
一方、概要のフローチャートは、処理の流れを俯瞰するためのものであり、実際のプログラミングでは１つ１つの記号の中で複数の処理（順次処理、分岐処理、繰り返し処理等）を記述します。設計書に用いられることが多いのはこちらのフローチャートです。

２．フローチャートの記号の意味

フローチャートで使われる記号の意味は以下の通りです。
これ以外の記号が使われることもありますが、これ以外の記号は現場や人によって微妙に書き方が異なることも少なくないので、実際のフローチャートを読んで都度記号の意味を考えた方が良いでしょう。

３．繰り返しや定義済み処理を含むフローチャートの例

前述の例では使用していない記号があったので、以下で補足します。

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

慣れない内はプログラムのロジックを考えるのに一苦労します。
いきなりプログラムを書き始めるのが難しい場合は、フローチャートを書く所から始めると良いと思います。

ちなみに、私も、難しい処理を実装する場合は自分のためにフローチャートを書きます。
つい最近も、再帰処理を含む複雑なロジックを４ページ程のフローチャートで整理していました。
慣れていてもフローチャートを書く時は書くので、慣れない内は尚更書いた方が良いのではないか、と思っています。

2020年9月25日

java：重複を排除する方法３選

今回は、javaでListの重複排除を行う方法を３つ紹介します。

１つ目の方法は、for文で自力でアルゴリズムを記述して重複排除を行う方法です。
記述が冗長になり、コーディングミスも起こりやすいことから、現在の実務ではこの方法で重複排除を行うことはないと思います。
しかし、新人研修でjavaの標準APIの学習が不十分な段階で使うケースが想定される他、実務でもCOBOLからjavaにコンバージョンしている等のレガシーな環境では見かけることがあるかもしれません。

２つ目の方法は、HashSet（順番を保証する必要がある場合はLinkedHashSet）を使用する方法です。
HashSetとは、重複を排除して要素を格納するクラスであり、自力で重複排除のアルゴリズムを記述する必要がないためコーディングミスは起こりにくいです。
コンストラクタでListとSetの相互変換も可能であることもあり、記述も簡潔になります。
実務ではHashSetを使うケースが多いと思います。

３つ目の方法は、StreamAPIを使用する方法です。
StreamAPIにはdistinctメソッドが用意されており、このメソッドを呼び出すことで重複排除が可能です。
Java8から導入された機能であり、背景に関数型プログラミングの考え方があることから、昔からjavaを書いてきた人は取っつきにくさを感じるかもしれません。
しかし、新しい物好きの現場ではStreamAPIの使用が好まれるでしょう。

以下、サンプルコードです。

【サンプルコード】

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class DistinctMain {

    public static void main(String［］ args) {

        // 重複排除前のList
        List＜Integer＞ beforeList = new ArrayList＜Integer＞();
        beforeList.add(1);
        beforeList.add(3);
        beforeList.add(2);
        beforeList.add(4);
        beforeList.add(3);
        beforeList.add(2);
        beforeList.add(1);

        // 重複排除後のList
        // 期待結果：1→3→2→4
        List＜Integer＞ afterList1;
        List＜Integer＞ afterList2;
        List＜Integer＞ afterList3;

        // for文で重複排除
        // 値を一つ一つ抽出、未抽出の値なら出力のListに詰め、抽出済の値なら無視
        afterList1 = new ArrayList＜Integer＞();
        for (int i = 0; i ＜ beforeList.size(); i++) {
            int item = beforeList.get(i);
            int j = 0;
            for (; j ＜ afterList1.size(); j++) {
                if (item == afterList1.get(j)) {
                    break;
                }
            }
            if (j == afterList1.size()) {
                afterList1.add(item);
            }
        }

        // LinkedHashSetで重複排除（HashSetだと順番が保証されない）
        // コンストラクタを利用してList→Set（重複排除）→Listの変換
        Set＜Integer＞ tmpSet = new LinkedHashSet＜Integer＞(beforeList);
        afterList2 = new ArrayList＜Integer＞(tmpSet);

        // StreamAPIで重複排除
        // Streamに変換→distinctメソッドで重複排除→Listに変換
        afterList3 = beforeList.stream()
                               .distinct()
                               .collect(Collectors.toList());

        // 重複排除結果の確認
        System.out.println("［for文で重複排除］");
        for (int item : afterList1) {
            System.out.println(item);
        }
        System.out.println("［LinkedHashSetで重複排除］");
        for (int item : afterList2) {
            System.out.println(item);
        }
        System.out.println("［StreamAPIで重複排除］");
        for (int item : afterList3) {
            System.out.println(item);
        }

    }

}

import java.util.ArrayList;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.stream.Collectors;

public class DistinctMain {

public static void main(String［］ args) {

// 重複排除前のList

List＜Integer＞ beforeList = new ArrayList＜Integer＞();

beforeList.add(1);

beforeList.add(3);

beforeList.add(2);

beforeList.add(4);

beforeList.add(3);

beforeList.add(2);

beforeList.add(1);

// 重複排除後のList

// 期待結果：1→3→2→4

List＜Integer＞ afterList1;

List＜Integer＞ afterList2;

List＜Integer＞ afterList3;

// for文で重複排除

// 値を一つ一つ抽出、未抽出の値なら出力のListに詰め、抽出済の値なら無視

afterList1 = new ArrayList＜Integer＞();

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

int item = beforeList.get(i);

int j = 0;

for (; j ＜ afterList1.size(); j++) {

if (item == afterList1.get(j)) {

break;

}

if (j == afterList1.size()) {

afterList1.add(item);

}

// LinkedHashSetで重複排除（HashSetだと順番が保証されない）

// コンストラクタを利用してList→Set（重複排除）→Listの変換

Set＜Integer＞ tmpSet = new LinkedHashSet＜Integer＞(beforeList);

afterList2 = new ArrayList＜Integer＞(tmpSet);

// StreamAPIで重複排除

// Streamに変換→distinctメソッドで重複排除→Listに変換

afterList3 = beforeList.stream()

.distinct()

.collect(Collectors.toList());

// 重複排除結果の確認

System.out.println("［for文で重複排除］");

for (int item : afterList1) {

System.out.println(item);

}

System.out.println("［LinkedHashSetで重複排除］");

for (int item : afterList2) {

System.out.println(item);

}

System.out.println("［StreamAPIで重複排除］");

for (int item : afterList3) {

System.out.println(item);

}

【実行結果】

［for文で重複排除］
1
3
2
4
［LinkedHashSetで重複排除］
1
3
2
4
［StreamAPIで重複排除］
1
3
2
4

［for文で重複排除］

［LinkedHashSetで重複排除］

［StreamAPIで重複排除］

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

新人研修で重複排除の方法が話題になったので、この記事を書いてみました。

javaは歴史の長い言語であるため、一つのことを実現するだけでも色々と書き方があります。
また、今回紹介したように、時と場合により、どのような書き方をするか使い分けすることが望ましいです。