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

2020年9月18日

Word：改行時に勝手に番号が割り振られないようにする

Wordを使っていて思い通りに文書が書けないことは良くあります。
良くある悩みの一つは、「勝手に番号が振られてしまう」というものです。

例えば、「１．ほげ」と入力して、Enterを押下すると、以下のように勝手に番号が振られます。

「１．」と入力すると、段落が入力されたものだとWordの内部で判断されるため、このような挙動となります。

お勧めの解決法は、Shift＋Enterで改行することです。
Shift＋Enterで改行することで、「箇条書きは続いているけど次の箇条書きには移っていない」とWordの内部で判断され、内部的にも見た目的にも上手い具合になります。次の箇条書きに移りたい時は、Enterで改行すれば良いです。

なお、よく見る解決法として、箇条書きの自動設定をオフにするという方法があります。
しかし、この方法には、既定の設定を変更するのは面倒という欠点があります。
また、自動で箇条書きになるというのを理解していれば箇条書きしたい時にEnter一つで箇条書きにできるので、箇条書きの設定は必ずしも不便な設定というわけではないです。

他の解決法としては、自動的に番号が振られた後にCtrl+zで自動操作を戻し箇条書きを解除するという方法が挙げられることもあります。
この解決法を用いると見た目を整えることはできますが、改行した箇所以降は箇条書きではないとWordの内部で判断されてしまいます。
箇条書きの機能自体は理解していれば便利（例えば目次を自動で作ることができる）なので、Wordの良さを活かすという意味で言うとこの解決法もあまり良くありません。
（見た目だけ整えれば良いのであれば、それこそExcel方眼紙の方が良いという話になってしまいます）

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

SIerの業界では「Excel方眼紙は慣れているけどWordには慣れていない」という人が少なくないと感じたので、このような記事を書いてみました。

ちなみに、Word以外にも、Enterだと段落が変わりShift+Enterだと通常の改行が行われる、という挙動のソフトウェアが存在します（例えばコミュニケーションツールのConfluence）。
Shift+Enterは半ば一般常識化している面もあるので、通常の改行はShift+Enterで行うという癖を身に付けておいても良いかもしれません。

2020年9月12日

動的計画法を試してみた

動的計画法とは、再帰的なロジックを、計算結果を都度記録するロジックで代替することで、計算速度を向上させるテクニックです。
競技プログラミングのテクニックの一つなのですが、高度なアルゴリズムを実装する開発だけではなく普通の業務システム開発にも応用できそうなので、紹介します。

今回は、フィボナッチ数列の計算を例に挙げます。
再帰的に処理した場合、数列が１つ増える度に呼び出し量が２倍になるため、オーダはO^2となります。また、再帰的に関数を呼び出すとその分メモリ（スタック）を消費するため、異常終了するリスクも高くなります。
しかし、動的計画法を用いた場合は、数列が１つ増えても計算が１回増えるだけなので、オーダはOとなります。
実際に45項目を計算した結果、再帰呼び出しでは約11000ミリ秒を要しましたが、動的計画法の場合は1ミリ秒未満でした。

【スペック・動作環境】

・OS：Windows8.1 64bit
・CPU：Inter(R) Core(TM) i5-4210U CPU @ 1.70GHz 2.40GHz
・メモリ：8.00GB
・ディスク：SSD 128GB
・言語：java8
・IDE：Eclipse Oxygen

【確認用プログラム】

public class FibMain {

    public static void main(String［］ args) {

        // 再帰呼び出しの場合
        System.out.println("■再帰呼び出し");
        long startTime1 = System.currentTimeMillis();
        int result1 = fib1(45);
        long endTime1 = System.currentTimeMillis();
        System.out.println("　結果　　　　：" + result1);
        System.out.println("　要したミリ秒：" + (endTime1 - startTime1));

        // 動的計画法の場合
        System.out.println("■動的計画法");
        long startTime2 = System.currentTimeMillis();
        int result2 = fib2(45);
        long endTime2 = System.currentTimeMillis();
        System.out.println("　結果　　　　：" + result2);
        System.out.println("　要したミリ秒：" + (endTime2 - startTime2));
    }

    // 再帰呼び出し
    static int fib1(int n) {
        switch (n) {
            case 1: return 0;
            case 2: return 1;
            default: return fib1(n - 1) + fib1(n - 2);
        }
    }

    // 動的計画法
    static int fib2(int n) {
        int memo［］ = new int［1000］;
        memo［0］ = 0;
        memo［1］ = 1;
        for (int i = 2; i ＜ n; i++) {
            memo［i］ = memo［i - 1］ + memo［i - 2］;
        }
        return memo［n - 1］;
    }

}

public class FibMain {

public static void main(String［］ args) {

// 再帰呼び出しの場合

System.out.println("■再帰呼び出し");

long startTime1 = System.currentTimeMillis();

int result1 = fib1(45);

long endTime1 = System.currentTimeMillis();

System.out.println("　結果　　　　：" + result1);

System.out.println("　要したミリ秒：" + (endTime1 - startTime1));

// 動的計画法の場合

System.out.println("■動的計画法");

long startTime2 = System.currentTimeMillis();

int result2 = fib2(45);

long endTime2 = System.currentTimeMillis();

System.out.println("　結果　　　　：" + result2);

System.out.println("　要したミリ秒：" + (endTime2 - startTime2));

}

// 再帰呼び出し

static int fib1(int n) {

switch (n) {

case 1: return 0;

case 2: return 1;

default: return fib1(n - 1) + fib1(n - 2);

}

// 動的計画法

static int fib2(int n) {

int memo［］ = new int［1000］;

memo［0］ = 0;

memo［1］ = 1;

for (int i = 2; i ＜ n; i++) {

memo［i］ = memo［i - 1］ + memo［i - 2］;

}

return memo［n - 1］;

}

【実行結果】

■再帰呼び出し
　結果　　　　：701408733
　要したミリ秒：11033
■動的計画法
　結果　　　　：701408733
　要したミリ秒：0

■再帰呼び出し

　結果　　　　：701408733

　要したミリ秒：11033

■動的計画法

　結果　　　　：701408733

　要したミリ秒：0

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

業務システム開発に携わっている身としては競技プログラミングは少し縁遠い存在なのですが、再帰呼び出しは業務システム開発でも使うことがあります。
（直近ではGUIの開発で使いましたし、現在趣味で作っているプログラムでも再帰呼び出しの箇所が存在します）
再帰呼び出しを使用するとどうしても重くなったり異常終了したりすることがあるので、そのような場合に動的計画法の使用を検討できると実装の幅が広がると思いました。

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」の数字部分にカウンターの値をそのまま用いることができます。

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

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

2020年8月21日2020年8月22日

型推論とは

型推論とは、メソッド内のローカル変数を初期値付きで（右辺がある状態で）宣言する際に、通常の型宣言の代わりに”var”という仮の型を使用できるという文法です。
“var”を用いた際は、コンパイル時に自動で型を判断し、その型への置き換えが行われます。

C#では3.0(2007/11)から導入されており、現在ではお馴染みの文法と言えるでしょう。
Javaでは長らく導入されていませんでしたが、10(2018/03)でついに導入されました。
今後はJavaの案件でも目にすることが増えると思います。

型推論を用いることで、冗長な型宣言をすっきりさせることができます。
C#の例で言うと、下記のコードで、定義時に”List”と型を指定している箇所は、”var”に書き変えることができます。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloWorld
{
    class Program
    {
        static void Main(string［］ args)
        {
            //List＜string＞ list = new List＜string＞();
            var list = new List＜string＞();
            list.Add("Hello ");
            list.Add("World");
            list.Add("!");
            foreach(string str in list)
            {
                Console.Write(str);
            }
            Console.WriteLine("");
            Console.ReadKey(true);
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace HelloWorld

{

class Program

{

static void Main(string［］ args)

{

//List＜string＞ list = new List＜string＞();

var list = new List＜string＞();

list.Add("Hello ");

list.Add("World");

list.Add("!");

foreach(string str in list)

{

Console.Write(str);

}

Console.WriteLine("");

Console.ReadKey(true);

}

また、ソース修正で型を変えるような場合にも、”var”と記述した部分は変更する必要がなくなるので、ソース修正が楽になるというメリットもあります。

型はコンパイル時に決まるため、実行時に動的に型が変わることはありません。
例えば、下記のようなコードはコンパイルエラーになります。
（(22,20): error CS0029: 型 ‘int’ を型 ‘System.Collections.Generic.List’ に暗黙的に変換できません。）
誤って意図しない型を代入しようとした場合はコンパイル時にエラーとして検知できるので、その意味では安心して使えます。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloWorld
{
    class Program
    {
        static void Main(string［］ args)
        {
            var list = new List＜string＞();
            list.Add("Hello ");
            list.Add("World");
            list.Add("!");
            foreach(string str in list)
            {
                Console.Write(str);
            }
            Console.WriteLine("");
            list = 1 + 2; // 途中でintのような使い方をするとコンパイルエラー
            Console.WriteLine(list.ToString());
            Console.ReadKey(true);
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace HelloWorld

{

class Program

{

static void Main(string［］ args)

{

var list = new List＜string＞();

list.Add("Hello ");

list.Add("World");

list.Add("!");

foreach(string str in list)

{

Console.Write(str);

}

Console.WriteLine("");

list = 1 + 2; // 途中でintのような使い方をするとコンパイルエラー

Console.WriteLine(list.ToString());

Console.ReadKey(true);

}

ちなみに、「型推論」と似た概念として「動的型付け」というものがあるのですが、こちらは途中で異なる型を代入すると変数の型そのものが変わり処理が続行されます。
例えば、JavaScriptでは動的型付けが採用されており、予約語も”var”を用いるため、「型推論」と混同されがちです。
「動的型付け」の方は誤って意図しない型を代入しても実行するまで気付くことができず、実行時に出るエラーが分かりにくいものだったり、そもそもエラーが出ないこともあるので、注意が必要です。

以上のように便利な型推論ですが、可読性を落とすデメリットもあります。
具体的に言うと、変数宣言時の型が一目瞭然ではない場合に用いると可読性を落とします。

例えば、下記のコードで変数宣言時の型を知るためには、”MyFunc”の仕様を知っている必要があります。
“MyFunc”のような独自の関数でなくても、チーム内での知名度が低い関数を用いる場合は注意が必要です。

var hoge = MyFunc();

1	var hoge = MyFunc();

また、”int”や”string”のような基本的な型に対して用いるのも、元々型宣言が冗長ではないという意味で型推論を使用するメリットが少ないので、他の開発者に違和感を抱かせてしまう可能性があります。

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

「型推論」は便利ながらも、「動的型付け」のように実行時エラーを引き起こす原因を作ることはないので、安心して使える文法だと思います。
その使いやすさからJavaでも今後目にする機会が増えると思うので、このような文法があるということは頭に入れておいて損はないと思います。

Javaのバージョンは今でも上がり続けているので、新しい便利な文法があればこれからも紹介したいと思います！