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

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

2020年9月4日

続・singletonとstaticの違い

こちらの記事について社内外でちょっとした議論になったので、その内容をまとめてみました。
Singletonパターンを利用する理由は「外部からnewさせたくないから」だと思っていましたが、「そう書いた方がわかりやすいから」「staticではないメソッドも利用可能になるから」という理由の方が大きそうです。

【指摘】

・privateコンストラクタを持った時点でnewできない

newさせたくないだけなら、オブジェクト取得メソッドは不要。
Singletonパターンで無くても良い。

・Singletonパターンの思想の表現としてオブジェクト取得メソッドが必要

書籍ではSingletonパターンはオブジェクト取得メソッドが必要とされている。
確かに、privateでオブジェクトを１つ生成、外部にはメソッド経由で提供する、とすれば、「オブジェクトは１つのみ存在する」という思想をわかりやすく表現できる。
人によってstaticの方が分かりやすいかSingletonパターンの方が分かりやすいかは違うと思うが、オブジェクト指向に慣れた技術者であればSingletonパターンの方が設計思想が分かりやすいというのはありそう。

・Singletonパターンだとstaticではないメソッドも参照可能になる

Singletonパターンであればクラスへの参照ではなくオブジェクトへの参照となる。
そのため、staticではないメソッドの参照も可能となる。
具体的には、継承・オーバーライドができるというメリットがある。

【サンプルコード】

・StaticMemory.java

public class StaticMemory {

    // 利用者側でnewさせたくないだけならこれだけで良い
    private StaticMemory() {
    }

    private static int num = 0;

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

    public static int getNum() {
        return num;
    }

}

public class StaticMemory {

// 利用者側でnewさせたくないだけならこれだけで良い

private StaticMemory() {

}

private static int num = 0;

public static void setNum(int arg) {

num = arg;

}

public static int getNum() {

return num;

}

・SingletonMemory.java

public class SingletonMemory {

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

    protected SingletonMemory(){
    }

    public static SingletonMemory getInstance(){
        return instance;
    }

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

    public static int getNum() {
        return num;
    }

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

}

public class SingletonMemory {

private static int num = 0;

private static SingletonMemory instance = new SingletonMemory();

protected SingletonMemory(){

}

public static SingletonMemory getInstance(){

return instance;

}

public static void setNum(int arg) {

num = arg;

}

public static int getNum() {

return num;

}

public int getNumCalc() {

return num * 2;

}

・SingletonMemoryChild.java

public class SingletonMemoryChild extends SingletonMemory {

    private static SingletonMemoryChild instance = new SingletonMemoryChild();

    private SingletonMemoryChild(){
    }

    public static SingletonMemoryChild getInstance(){
        return instance;
    }

    // 下記はビルドエラー
    // @Override
    // public static int getNum() {
    //    return 100;
    //}

    @Override
    public int getNumCalc() {
        return super.getNumCalc() * 2;
    }

}

public class SingletonMemoryChild extends SingletonMemory {

private static SingletonMemoryChild instance = new SingletonMemoryChild();

private SingletonMemoryChild(){

}

public static SingletonMemoryChild getInstance(){

return instance;

}

// 下記はビルドエラー

// @Override

// public static int getNum() {

// return 100;

//}

@Override

public int getNumCalc() {

return super.getNumCalc() * 2;

}

・MemoryTestMain.java

public class MemoryTestMain {

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

        int recentNum = 0; // 最新の値

        // 普通のStaticなクラスを使った場合
        recentNum = 1;
        StaticMemory.setNum(recentNum);
        System.out.println("Static1："+StaticMemory.getNum());

        // privateコンストラクタを定義すれば使う側でオブジェクトを作れない
        // （下記はエラー）
        // StaticMemory instance2 = new StaticMemory();
        // instance2.setNum(recentNum);
        // System.out.println("new1："+instance2.getNum());

        // オブジェクト取得メソッドを利用すれば非staticメソッドも参照可能
        recentNum = 2;
        SingletonMemory.getInstance().setNum(recentNum);
        System.out.println
            ("Shingleton1："+SingletonMemory.getInstance().getNum());
        System.out.println
            ("Shingleton2："+SingletonMemory.getInstance().getNumCalc());

        // 直接参照だと非staticメソッドを参照できない
        recentNum = 3;
        SingletonMemory.setNum(recentNum);
        System.out.println
            ("直接参照1："+SingletonMemory.getNum());
        // System.out.println
        //     ("直接参照2："+SingletonMemory.getNumCalc());

        // Singletoneなクラスを継承したクラスを利用
        // 非staticメソッドはオーバーライドしたメソッドが呼び出される
        recentNum = 4;
        SingletonMemoryChild.getInstance().setNum(recentNum);
        System.out.println
            ("Child1："+SingletonMemoryChild.getInstance().getNum());
        System.out.println
            ("Child2："+SingletonMemoryChild.getInstance().getNumCalc());

    }

}

public class MemoryTestMain {

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

@SuppressWarnings("static-access")

public static void main(String［］ args) {

int recentNum = 0; // 最新の値

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

recentNum = 1;

StaticMemory.setNum(recentNum);

System.out.println("Static1："+StaticMemory.getNum());

// privateコンストラクタを定義すれば使う側でオブジェクトを作れない

// （下記はエラー）

// StaticMemory instance2 = new StaticMemory();

// instance2.setNum(recentNum);

// System.out.println("new1："+instance2.getNum());

// オブジェクト取得メソッドを利用すれば非staticメソッドも参照可能

recentNum = 2;

SingletonMemory.getInstance().setNum(recentNum);

System.out.println

("Shingleton1："+SingletonMemory.getInstance().getNum());

System.out.println

("Shingleton2："+SingletonMemory.getInstance().getNumCalc());

// 直接参照だと非staticメソッドを参照できない

recentNum = 3;

SingletonMemory.setNum(recentNum);

System.out.println

("直接参照1："+SingletonMemory.getNum());

// System.out.println

// ("直接参照2："+SingletonMemory.getNumCalc());

// Singletoneなクラスを継承したクラスを利用

// 非staticメソッドはオーバーライドしたメソッドが呼び出される

recentNum = 4;

SingletonMemoryChild.getInstance().setNum(recentNum);

System.out.println

("Child1："+SingletonMemoryChild.getInstance().getNum());

System.out.println

("Child2："+SingletonMemoryChild.getInstance().getNumCalc());

}

【実行結果】

Staticクラス1：1
メソッドでget1：2
メソッドでget2：4
直接参照1：3
メソッドでget1（継承）：4
メソッドでget2（継承）：16

Staticクラス1：1

メソッドでget1：2

メソッドでget2：4

直接参照1：3

メソッドでget1（継承）：4

メソッドでget2（継承）：16

この話、社内でちょっとした議論になりました。
おかげで色々理解が深まりました。

議論のきっかけを作れるというのも、技術ブログの良い所だと思いました。

2020年8月28日

java：実務で使うテクニックでfizzbuzzを解いてみた

１０年ほど前に流行ったプログラミングの問題として、fizzbuzzと呼ばれる問題があります。
この問題は、応募者のプログラミング経験の有無を見極める問題であり、問題の内容は以下の通りです。
・1から100までの数を出力する。
・3の倍数の時は代わりに”fizz”と出力する。
・5の倍数の時は代わりに”buzz”と出力する。
・3の倍数かつ5の倍数の時は代わりに”fizzbuzz”と出力する。

「実務ではfizzbuzzのようなプログラムを書くことは無いから解けなくても良い」という意見もあるようですが、個人的にはfizzbuzzで使うテクニックは実務でも使えると思っています。

以下では、実務でも使うテクニックを用いてfizzbuzzを解いてみます。
（言語はjavaです。今回の記事の趣旨上、トリッキーな解答は除外します。）

・剰余を用いた一般的な解答パターン

public class Fizzbuzz {
    public static void main(String［］ args) {
        for (int i = 1; i ＜ 101; i++) {
            if (i % (3 * 5) == 0) {
                System.out.println("fizzbuzz");
            } else if (i % 3 == 0) {
                System.out.println("fizz");
            } else if (i % 5 == 0) {
                System.out.println("buzz");
            } else {
                System.out.println(i);
            }
        }
    }
}

public class Fizzbuzz {

public static void main(String［］ args) {

for (int i = 1; i ＜ 101; i++) {

if (i % (3 * 5) == 0) {

System.out.println("fizzbuzz");

} else if (i % 3 == 0) {

System.out.println("fizz");

} else if (i % 5 == 0) {

System.out.println("buzz");

} else {

System.out.println(i);

}

恐らく、これが一番自然な解答なのではないかと思います。
剰余を用いて、「n % m == 0」と記述することで、「m毎に何かをする」という記述が可能になります。
性能の観点で、一定のデータが溜まってからまとめてログ出力やデータベース書き込みを行うことがあるのですが、そのような処理を記述する時に使えます。
その他、テストデータを生成する時にも、この書き方を用いると楽になる場合があります。
（例えば、100個データを用意し、その内偶数のデータについては特定のフラグが立ったデータにする等）

・同じ分岐の記述を避けるパターン

public class Fizzbuzz {
    public static void main(String［］ args) {
        for (int i = 1; i ＜ 101; i++) {
            String str = "";
            if (i % 3 == 0) {
                str = str + "fizz";
            }
            if (i % 5 == 0) {
                str = str + "buzz";
            }
            if (str.equals("")) {
                Integer i2 = i;
                str = i2.toString();
            }
            System.out.println(str);
        }
    }
}

public class Fizzbuzz {

public static void main(String［］ args) {

for (int i = 1; i ＜ 101; i++) {

String str = "";

if (i % 3 == 0) {

str = str + "fizz";

}

if (i % 5 == 0) {

str = str + "buzz";

}

if (str.equals("")) {

Integer i2 = i;

str = i2.toString();

}

System.out.println(str);

}

先に挙げた解答では「3の倍数の時」「5の倍数の時」の分岐が２回ずつ出現し、若干冗長なので、このように同じ分岐の記述を避ける解答もあります。
同じ分岐を複数記述すると、保守性が低下します。
（例えば、「3の倍数」を「4の倍数」としたい時に、修正漏れが発生する可能性が出てくる）
プログラマーは保守性にも気を配るべきなので、個人的にはこちらの解答の方がよりプログラマーっぽいと思っています。

・除算と乗算を組み合わせるパターン

public class Fizzbuzz {
    public static void main(String［］ args) {
        for (int i = 1; i ＜ 101; i++) {
            String str = "";
            if ((i / 3 * 3) == i) {
                str = str + "fizz";
            }
            if ((i / 5 * 5) == i) {
                str = str + "buzz";
            }
            if (str.equals("")) {
                Integer i2 = i;
                str = i2.toString();
            }
            System.out.println(str);
        }
    }
}

public class Fizzbuzz {

public static void main(String［］ args) {

for (int i = 1; i ＜ 101; i++) {

String str = "";

if ((i / 3 * 3) == i) {

str = str + "fizz";

}

if ((i / 5 * 5) == i) {

str = str + "buzz";

}

if (str.equals("")) {

Integer i2 = i;

str = i2.toString();

}

System.out.println(str);

}

剰余を使わずとも、整数型は小数点以下切り捨てになるということを知っていれば、このような解答を記述することもできます。
除算で小数点以下の切り捨てが発生する場合、同じ数で乗算を行っても元の数に戻らないので、それを利用しています。
除算による切り捨てを実務で用いる場合もあり、例えば100未満の位を切り捨てしたい場合は、「n = n / 100 * 100」と記述したりします。逆に切り上げたい場合は、「n = (n + 99) / 100 * 100」となります。
現代のプログラミング言語では切り捨てや切り上げを行う便利な関数が用意されているのでこのような書き方をすることは少ないですが、このような書き方を知らないと他の人のプログラムを読んでいて困ることがあるので、知っておいた方が無難です。

・カウンターを持たせるパターン

public class Fizzbuzz {
    public static void main(String［］ args) {
        int fizzCounter = 0;
        int buzzCounter = 0;
        for (int i = 1; i ＜ 101; i++) {
            fizzCounter++;
            buzzCounter++;
            String str = "";
            if (fizzCounter == 3) {
                str = str + "fizz";
                fizzCounter = 0;
            }
            if (buzzCounter == 5) {
                str = str + "buzz";
                buzzCounter = 0;
            }
            if (str.equals("")) {
                Integer i2 = i;
                str = i2.toString();
            }
            System.out.println(str);
        }
    }
}

public class Fizzbuzz {

public static void main(String［］ args) {

int fizzCounter = 0;

int buzzCounter = 0;

for (int i = 1; i ＜ 101; i++) {

fizzCounter++;

buzzCounter++;

String str = "";

if (fizzCounter == 3) {

str = str + "fizz";

fizzCounter = 0;

}

if (buzzCounter == 5) {

str = str + "buzz";

buzzCounter = 0;

}

if (str.equals("")) {

Integer i2 = i;

str = i2.toString();

}

System.out.println(str);

}

fizz用のカウンターとbuzz用のカウンターを持たせて、カウンターを上手く制御すると、剰余や切り捨てを利用しなくても解答を記述できます。
実務では、カウンターの数字自体に意味がある場合にこのような書き方をします。
例えば、「ログ1→ログ2→ログ3→ログ1…とローテーションさせたい」という場合に、「ログ1」「ログ2」「ログ3」の数字部分にカウンターの値をそのまま用いることができます。

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

今回紹介した問題は難しくないものですが、その解き方で個性やテクニックを発揮することができそうなので、今回は色々と解答を紹介してみました。
実務で役に立つ問題があれば、これからも紹介していきたいと思います！

カテゴリー: java

無名クラスとは

【サンプルコード】

・AnonymousClass.java

・AnonymousInterface.java

・AnonymousMain.java

【実行結果】

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

【サンプルコード】

・SystemInOut.java

・SystemInOutMain.java

【処理結果】

・C:\tmp\test1.txt

・C:\tmp\test2.txt

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

【サンプルコード】

【実行結果】

続・singletonとstaticの違い

【指摘】

・privateコンストラクタを持った時点でnewできない

・Singletonパターンの思想の表現としてオブジェクト取得メソッドが必要

・Singletonパターンだとstaticではないメソッドも参照可能になる

【サンプルコード】

・StaticMemory.java

・SingletonMemory.java

・SingletonMemoryChild.java

・MemoryTestMain.java

【実行結果】

java：実務で使うテクニックでfizzbuzzを解いてみた

・剰余を用いた一般的な解答パターン

・同じ分岐の記述を避けるパターン

・除算と乗算を組み合わせるパターン

・カウンターを持たせるパターン