プログラミング – ページ 2 – サイゼントの技術ブログ

2021年9月21日

JavaScript：async・awaitの例外処理

JavaScriptのasync・awaitについては以前の記事で簡単に触れましたが、例外処理を行う場合には別途注意が必要であるため、続きの記事を書きます。

async・awaitで例外処理を行う場合、メソッドチェーンで受け取る方法と、try-catchで受け取る方法があります。
これらの方法について、紹介していこうと思います。

サンプルコードはNode.jsで実行しています。

awaitで呼び出される関数では、Promiseオブジェクトを返す必要があります。
通常はresolveで返しますが、例外処理を行う場合はrejectを返す必要があります。
これは、例外をメソッドチェーンで受け取る場合も、try-catchで受け取る場合も変わりません。

なお、rejectで返されたPromiseオブジェクトをメソッドチェーンでもtry-catchでも受け取らなかった場合は、UnhandledPromiseRejectionWarningが発生しプロセスが終了するので、注意が必要です。

rejectでPromiseオブジェクトを返された場合は、メソッドチェーン「.catch」で受け取ることが可能です。
「.catch」で受け取った場合は、「.catch」内の処理が実行され、戻り値は取得できません。
（戻り値はundefinedになります）
resolveで返された場合は、「.catch」内の処理が実行されません。

なお、メソッドチェーン「.catch」の前にメソッドチェーン「.then」を入れることで、resolveで返されたPromiseオブジェクトをこれで返すことができます。
「.then」で受け取った場合は、「.then」内の処理が実行され、戻り値は取得できません。
（戻り値はundefinedになります）
また、rejectで返された場合は、「.catch」の前に定義した「.then」内の処理が実行されません。

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

【サンプルコード】

・sample.js

function lightTask() {
  console.log("light");
}

function heavyTask() {
  // awaitで呼び出される関数ではpromiseオブジェクトを返す必要がある
  return new Promise((resolve, reject) =＞ {
    const procedure = () =＞ {
      console.log("heavy");
      // resolve(0);  // ①
      // reject(1);  // ②
    }
    setTimeout(procedure, 1000);
  });
}

// awaitを使用する関数にはasyncをつける
async function exection() {
  let result = await heavyTask()
  //               .then((code) =＞ { console.log("normal:" + code); }) // ③
  //               .catch((code) =＞ { console.error("error:" + code); }) // ④
                 ;
  console.log("code:"+result);
  lightTask();
}

exection();

function lightTask() {

console.log("light");

}

function heavyTask() {

// awaitで呼び出される関数ではpromiseオブジェクトを返す必要がある

return new Promise((resolve, reject) =＞ {

const procedure = () =＞ {

console.log("heavy");

// resolve(0); // ①

// reject(1); // ②

}

setTimeout(procedure, 1000);

});

}

// awaitを使用する関数にはasyncをつける

async function exection() {

let result = await heavyTask()

// .then((code) =＞ { console.log("normal:" + code); }) // ③

// .catch((code) =＞ { console.error("error:" + code); }) // ④

;

console.log("code:"+result);

lightTask();

}

exection();

【実行結果】

・①と③と④のコメントアウトを外した場合（resolveを.thenで受け取る）

C:\tmp＞node sample.js
heavy
normal:0
code:undefined
light

C:\tmp＞

C:\tmp＞node sample.js

heavy

normal:0

code:undefined

light

C:\tmp＞

・①と④のコメントアウトを外した場合（resolveを.thenで受け取らない）

C:\tmp＞node sample.js
heavy
code:0
light

C:\tmp＞

C:\tmp＞node sample.js

heavy

code:0

light

C:\tmp＞

・②と③と④のコメントアウトを外した場合（rejectを.catchで受け取る）

C:\tmp＞node sample.js
heavy
error:1
code:undefined
light

C:\tmp＞

C:\tmp＞node sample.js

heavy

error:1

code:undefined

light

C:\tmp＞

・参考：②と③のコメントアウトを外した場合（rejectを受け取らない）

C:\tmp＞node sample.js
heavy
(node:9180) UnhandledPromiseRejectionWarning: 1
(node:9180) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This
error originated either by throwing inside of an async function without a catch
block, or by rejecting a promise which was not handled with .catch(). To termina
te the node process on unhandled promise rejection, use the CLI flag `--unhandle
d-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejectio
ns_mode). (rejection id: 1)
(node:9180) ［DEP0018］ DeprecationWarning: Unhandled promise rejections are depre
cated. In the future, promise rejections that are not handled will terminate the
 Node.js process with a non-zero exit code.

C:\tmp＞

C:\tmp＞node sample.js

heavy

(node:9180) UnhandledPromiseRejectionWarning: 1

(node:9180) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This

error originated either by throwing inside of an async function without a catch

block, or by rejecting a promise which was not handled with .catch(). To termina

te the node process on unhandled promise rejection, use the CLI flag `--unhandle

d-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejectio

ns_mode). (rejection id: 1)

(node:9180) ［DEP0018］ DeprecationWarning: Unhandled promise rejections are depre

cated. In the future, promise rejections that are not handled will terminate the

Node.js process with a non-zero exit code.

C:\tmp＞

rejectで返されたPromiseオブジェクトはtry-catchで受け取ることも可能です。
ただし、この場合、戻り値を参照しないように注意が必要で、参照してしまうとUnhandledPromiseRejectionWarningが発生しプロセスが終了してしまいます。

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

【サンプルコード】

・sample.js

function lightTask() {
  console.log("light");
}

function heavyTask() {
  // awaitで呼び出される関数ではpromiseオブジェクトを返す必要がある
  return new Promise((resolve, reject) =＞ {
    const procedure = () =＞ {
      console.log("heavy");
      reject(1);
    }
    setTimeout(procedure, 1000);
  });
}

// awaitを使用する関数にはasyncをつける
async function exection() {
  try {
    let result = await heavyTask();
    console.log("code:"+result);
  } catch (e) {
    console.error("error:"+e);
    // console.log("code:"+result); // ⑤
  }
  lightTask();
}

exection();

function lightTask() {

console.log("light");

}

function heavyTask() {

// awaitで呼び出される関数ではpromiseオブジェクトを返す必要がある

return new Promise((resolve, reject) =＞ {

const procedure = () =＞ {

console.log("heavy");

reject(1);

}

setTimeout(procedure, 1000);

});

}

// awaitを使用する関数にはasyncをつける

async function exection() {

try {

let result = await heavyTask();

console.log("code:"+result);

} catch (e) {

console.error("error:"+e);

// console.log("code:"+result); // ⑤

}

lightTask();

}

exection();

【実行結果】

・そのまま実行した場合（rejectをtry-catchで受け取る）

C:\tmp＞node sample.js
heavy
error:1
light

C:\tmp＞

C:\tmp＞node sample.js

heavy

error:1

light

C:\tmp＞

・参考：⑤のコメントアウトを外した場合（try-catchで受け取る際に戻り値参照）

C:\tmp＞node sample.js
heavy
error:1
(node:1600) UnhandledPromiseRejectionWarning: ReferenceError: result is not defi
ned
    at exection (C:\tmp\sample.js:23:25)
    at processTicksAndRejections (internal/process/task_queues.js:97:5)
(node:1600) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This
error originated either by throwing inside of an async function without a catch
block, or by rejecting a promise which was not handled with .catch(). To termina
te the node process on unhandled promise rejection, use the CLI flag `--unhandle
d-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejectio
ns_mode). (rejection id: 1)
(node:1600) ［DEP0018］ DeprecationWarning: Unhandled promise rejections are depre
cated. In the future, promise rejections that are not handled will terminate the
 Node.js process with a non-zero exit code.

C:\tmp＞

C:\tmp＞node sample.js

heavy

error:1

(node:1600) UnhandledPromiseRejectionWarning: ReferenceError: result is not defi

ned

at exection (C:\tmp\sample.js:23:25)

at processTicksAndRejections (internal/process/task_queues.js:97:5)

(node:1600) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This

error originated either by throwing inside of an async function without a catch

block, or by rejecting a promise which was not handled with .catch(). To termina

te the node process on unhandled promise rejection, use the CLI flag `--unhandle

d-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejectio

ns_mode). (rejection id: 1)

(node:1600) ［DEP0018］ DeprecationWarning: Unhandled promise rejections are depre

cated. In the future, promise rejections that are not handled will terminate the

Node.js process with a non-zero exit code.

C:\tmp＞

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

JavaScriptのasync・await、特に例外処理は文法に少し癖があり、誤った記述をしても異常終了しないことがあるので、実際のシステム開発でも障害になりやすい所です。
awaitで待っていないように見える、例外発生時にだけ予期せぬ事象が出る、といった場合は、async・awaitの書き方が正しいか疑ってみましょう。

2021年7月20日

カプセル化によるルールの強制

オブジェクト指向を適用すると、ソースコードの重複した記述を排除でき、生産性や品質を向上することができます。
それとは別に、他の開発者にルールを強制できるメリットもあります。
カプセル化を例にして説明するのがわかりやすいので、今回はカプセル化を例に挙げてルールを強制するメリットを書いていきます。

例えば、自分は商品の金額を計算するPriceCalcクラスを作成していて、他の開発者はPriceCalcクラスを利用するUserクラスを作成しているとします。
自分としては「このロジックで金額計算して欲しい」というのがあるのですが、他の開発者にそのロジックの実装をさせるようにしてしまうと、意図が上手く伝わらなかった時に誤ったロジックで計算されてしまいます。
この状況をソースコードで表すと下記のような形になり、PriceCalcクラスは計算に必要な変数をまとめるだけ、PriceCalc側でその変数を参照して独自に業務ロジックを実装するような形となります。

public class PriceCalc {

    public ArrayList＜Integer＞ costs = new ArrayList＜Integer＞();
    public int taxRate = 0;
    :
    : 色々なメンバ変数定義
    :

}

public class PriceCalc {

public ArrayList＜Integer＞ costs = new ArrayList＜Integer＞();

public int taxRate = 0;

: 色々なメンバ変数定義

}

public class User {

    PriceCalc priceCalc = new PriceCalc();
    :
    : priceCalcオブジェクトのメンバ変数を使った複雑な業務ロジック
    :
    
}

public class User {

PriceCalc priceCalc = new PriceCalc();

: priceCalcオブジェクトのメンバ変数を使った複雑な業務ロジック

}

それでは困るので、クラス変数に付随する業務ロジックもPriceCalcクラス側に実装することにします。
変数とメソッドをひとまとまりにして一つのクラスとして提供することで、Userクラス側ではメソッドを呼び出すだけであるべき業務ロジックに基づいた計算を行うことができ、Userクラス側で業務ロジックを意識する必要が無くなります。

しかし、メンバ変数がpublicだと、Userクラス側でその変数を参照して独自に業務ロジックを実装することもできてしまいます。
自分としてはそれでは困るので、「変数を参照して独自に業務ロジックを実装しないでください」と伝えるのですが、それが上手く伝わらないと独自に業務ロジックを実装されてしまう可能性があります。
自分一人でプログラムを作っている場合は全ての変数をpublicにした方が便利だったりもしますが、複数人で開発している場合は意思疎通がうまく行かなかった場合に意図通りではないコーディングをされてしまうリスクがあります。

public class PriceCalc {

    public ArrayList＜Integer＞ costs = new ArrayList＜Integer＞();
    public int taxRate;
    :
    : 色々なメンバ変数定義
    :
    
    public void registNewCost(int cost) {
        this.costs.add(cost);
    }
    :
    : メンバ変数の設定用メソッド
    :
    
    public int getPrice(int index) {
        :
        : 複雑な業務ロジック
        :
    }

}

public class PriceCalc {

public ArrayList＜Integer＞ costs = new ArrayList＜Integer＞();

public int taxRate;

: 色々なメンバ変数定義

public void registNewCost(int cost) {

this.costs.add(cost);

}

: メンバ変数の設定用メソッド

public int getPrice(int index) {

: 複雑な業務ロジック

}

public class User {

    PriceCalc priceCalc = new PriceCalc();
    :
    : PriceCalcクラスのメソッドを使った設定
    :
    int priceOk = priceCalc.getPrice(index);
    
    // しかし用意したメソッドを使用せずに独自で計算できてしまう
    int priceNg = priceCalc.costs.get(index) * priceCalc.taxRate;
    
}

public class User {

PriceCalc priceCalc = new PriceCalc();

: PriceCalcクラスのメソッドを使った設定

int priceOk = priceCalc.getPrice(index);

// しかし用意したメソッドを使用せずに独自で計算できてしまう

int priceNg = priceCalc.costs.get(index) * priceCalc.taxRate;

}

それを防ぐためには、変数のアクセスレベルをprivate等にして、変数に自由にアクセスできないようにするのが有効です。
こうすることで、変数を参照して独自に業務ロジックを実装しようとされた場合に、コンパイルエラーとして機械的に失敗させることができます。
これが、カプセル化によるルールの強制であり、意思疎通がうまく行かなかった場合に意図通りではないコーディングをされるリスクを減らすことができます。

public class PriceCalc {

    private ArrayList＜Integer＞ costs = new ArrayList＜Integer＞();
    private int taxRate;
    :
    : 色々なメンバ変数定義
    :
    
    public void registNewCost(int cost) {
        this.costs.add(cost);
    }
    :
    : メンバ変数の設定用メソッド
    :
    
    public int getPrice(int index) {
        :
        : 複雑な業務ロジック
        :
    }

}

public class PriceCalc {

private ArrayList＜Integer＞ costs = new ArrayList＜Integer＞();

private int taxRate;

: 色々なメンバ変数定義

public void registNewCost(int cost) {

this.costs.add(cost);

}

: メンバ変数の設定用メソッド

public int getPrice(int index) {

: 複雑な業務ロジック

}

public class User {

    PriceCalc priceCalc = new PriceCalc();
    :
    : PriceCalcクラスのメソッドを使った設定
    :
    int priceOk = priceCalc.getPrice(index);
    
    // 下記はコンパイルエラー
    // int priceNg = priceCalc.costs.get(index) * priceCalc.taxRate;
    
}

public class User {

PriceCalc priceCalc = new PriceCalc();

: PriceCalcクラスのメソッドを使った設定

int priceOk = priceCalc.getPrice(index);

// 下記はコンパイルエラー

// int priceNg = priceCalc.costs.get(index) * priceCalc.taxRate;

}

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

一人で開発する時と複数人で開発する時では、気を付けるべきポイントが変わることがあります。
オブジェクト指向の考え方の一つである「カプセル化」も、単なる慣習として捉えるのではなく、複数人で開発する場合にルールを規定するものとして捉えることで、実務で有効に使えるのではないかと思います。

2021年6月15日

java：ソートキーが複数存在する場合、一時的なフォーマット変更ではなく独自Comparatorで対応するべき

複数のソートキーが存在するオブジェクトの配列について、固定長のフォーマットに直すことでソートキーを１つにできます。
しかし、フォーマットを直して１つのキーでソートできるようにするよりも、独自Comparatorを定義して複数のキーでソートした方が高速なので、そのようなケースでは独自Comparatorを定義して対応するべきです。

単純にフォーマット変更でコストがかかるだけでなく、ソート処理自体も複数のキーでソートした方が高速です。
複数のキーを１つのキーにまとめてソートする場合は必ずキー全体を見る必要がありますが、複数のキーでソートする場合はキーの一部を見るだけでソートできる場合があるので、複数のキーでソートした方が高速になるのだと思います。

以下、テスト結果です。

【ソースコード】

・SortTest.java

import java.util.ArrayList;
import java.util.Collections;

public class SortTest {

    public static void main(String［］ args) {

        // ソート対象のArrayListの作成
        // 一意な10,000,000個のデータを作成
        // それをランダムにソートする
        ArrayList＜SortTestRecord＞ array1 = new ArrayList＜＞();
        for (int i = 0; i &lt; 1000000; i++) {
            array1.add(new SortTestRecord((i / 100000) % 10,
                                          (i / 10000) % 10,
                                          (i / 1) % 10000));
        }
        Collections.shuffle(array1);
        ArrayList＜SortTestRecord＞ array2 = new ArrayList＜＞(array1);

        // ３つのソートキーによりソートする場合
        long startTime1 = System.currentTimeMillis();
        SortTestComparator comparator = new SortTestComparator();
        Collections.sort(array1, comparator);
        long endTime1 = System.currentTimeMillis();

        // フォーマット変更して１つのソートキーでソートする場合
        long startTime2 = System.currentTimeMillis();
        ArrayList＜String＞ array2tmp = new ArrayList＜＞();
        for (int i = 0; i ＜ array2.size(); i++) {
            array2tmp.add(String.format("%02d", array2.get(i).getSortkey1()) +
                          String.format("%03d", array2.get(i).getSortkey2()) +
                          String.format("%05d", array2.get(i).getSortkey3()));
        }
        long startTime2inside = System.currentTimeMillis();
        Collections.sort(array2tmp);
        long endTime2inside = System.currentTimeMillis();
        array2 = new ArrayList＜＞();
        for (int i = 0; i ＜ array2tmp.size(); i++) {
            array2.add(new SortTestRecord(
                    Integer.parseInt(array2tmp.get(i).substring(0,2)),
                    Integer.parseInt(array2tmp.get(i).substring(2,5)),
                    Integer.parseInt(array2tmp.get(i).substring(5,10))));
        }
        long endTime2 = System.currentTimeMillis();

        // 結果確認
        System.out.println("［サンプル出力］");
        System.out.println("（1つ目、123,457つ目、1,000,000つ目を出力）");
        array1.get(0).print();
        array1.get(123456).print();
        array1.get(999999).print();
        System.out.println();
        System.out.println("［配列の差異箇所出力］");
        int diffCount = 0;
        for (int i = 0; i ＜ 1000000; i++) {
            if (array1.get(i).getSortkey1() != array2.get(i).getSortkey1() ||
                array1.get(i).getSortkey2() != array2.get(i).getSortkey2() ||
                array1.get(i).getSortkey3() != array2.get(i).getSortkey3()) {
                System.out.println((i + 1) + "つ目の要素の内容を出力");
                array1.get(i).print();
                array2.get(i).print();
                diffCount++;
            }
        }
        if (diffCount == 0) {
            System.out.println("差異無し。");
        }
        System.out.println();
        System.out.println("［処理時間］");
        System.out.println("・３つのソートキーによりソートを実施");
        System.out.println((endTime1 - startTime1) + " ms");
        System.out.println("・フォーマット変更を行いソートを実施");
        System.out.println((endTime2 - startTime2) + " ms");
        System.out.println("　（内、ソート部分だけの時間）");
        System.out.println("　" + (endTime2inside - startTime2inside) + " ms");

    }

}

import java.util.ArrayList;

import java.util.Collections;

public class SortTest {

public static void main(String［］ args) {

// ソート対象のArrayListの作成

// 一意な10,000,000個のデータを作成

// それをランダムにソートする

ArrayList＜SortTestRecord＞ array1 = new ArrayList＜＞();

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

array1.add(new SortTestRecord((i / 100000) % 10,

(i / 10000) % 10,

(i / 1) % 10000));

}

Collections.shuffle(array1);

ArrayList＜SortTestRecord＞ array2 = new ArrayList＜＞(array1);

// ３つのソートキーによりソートする場合

long startTime1 = System.currentTimeMillis();

SortTestComparator comparator = new SortTestComparator();

Collections.sort(array1, comparator);

long endTime1 = System.currentTimeMillis();

// フォーマット変更して１つのソートキーでソートする場合

long startTime2 = System.currentTimeMillis();

ArrayList＜String＞ array2tmp = new ArrayList＜＞();

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

array2tmp.add(String.format("%02d", array2.get(i).getSortkey1()) +

String.format("%03d", array2.get(i).getSortkey2()) +

String.format("%05d", array2.get(i).getSortkey3()));

}

long startTime2inside = System.currentTimeMillis();

Collections.sort(array2tmp);

long endTime2inside = System.currentTimeMillis();

array2 = new ArrayList＜＞();

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

array2.add(new SortTestRecord(

Integer.parseInt(array2tmp.get(i).substring(0,2)),

Integer.parseInt(array2tmp.get(i).substring(2,5)),

Integer.parseInt(array2tmp.get(i).substring(5,10))));

}

long endTime2 = System.currentTimeMillis();

// 結果確認

System.out.println("［サンプル出力］");

System.out.println("（1つ目、123,457つ目、1,000,000つ目を出力）");

array1.get(0).print();

array1.get(123456).print();

array1.get(999999).print();

System.out.println();

System.out.println("［配列の差異箇所出力］");

int diffCount = 0;

for (int i = 0; i ＜ 1000000; i++) {

if (array1.get(i).getSortkey1() != array2.get(i).getSortkey1() ||

array1.get(i).getSortkey2() != array2.get(i).getSortkey2() ||

array1.get(i).getSortkey3() != array2.get(i).getSortkey3()) {

System.out.println((i + 1) + "つ目の要素の内容を出力");

array1.get(i).print();

array2.get(i).print();

diffCount++;

}

if (diffCount == 0) {

System.out.println("差異無し。");

}

System.out.println();

System.out.println("［処理時間］");

System.out.println("・３つのソートキーによりソートを実施");

System.out.println((endTime1 - startTime1) + " ms");

System.out.println("・フォーマット変更を行いソートを実施");

System.out.println((endTime2 - startTime2) + " ms");

System.out.println("　（内、ソート部分だけの時間）");

System.out.println("　" + (endTime2inside - startTime2inside) + " ms");

}

・SortTestRecord.java

public class SortTestRecord {

    private int sortkey1 = 0;
    private int sortkey2 = 0;
    private int sortkey3 = 0;

    // コンストラクタ
    SortTestRecord(int sortkey1, int sortkey2, int sortkey3) {
        this.sortkey1 = sortkey1;
        this.sortkey2 = sortkey2;
        this.sortkey3 = sortkey3;
    }

    // getter
    public int getSortkey1() {
        return this.sortkey1;
    }

    // getter
    public int getSortkey2() {
        return this.sortkey2;
    }

    // getter
    public int getSortkey3() {
        return this.sortkey3;
    }

    // プリント用クラス
    public void print() {
        System.out.println(sortkey1 + "," + sortkey2 + "," + sortkey3);
    }

}

public class SortTestRecord {

private int sortkey1 = 0;

private int sortkey2 = 0;

private int sortkey3 = 0;

// コンストラクタ

SortTestRecord(int sortkey1, int sortkey2, int sortkey3) {

this.sortkey1 = sortkey1;

this.sortkey2 = sortkey2;

this.sortkey3 = sortkey3;

}

// getter

public int getSortkey1() {

return this.sortkey1;

}

// getter

public int getSortkey2() {

return this.sortkey2;

}

// getter

public int getSortkey3() {

return this.sortkey3;

}

// プリント用クラス

public void print() {

System.out.println(sortkey1 + "," + sortkey2 + "," + sortkey3);

}

・SortTestComparator.java

import java.util.Comparator;

public class SortTestComparator implements Comparator＜SortTestRecord＞ {

    @Override
    public int compare(SortTestRecord o1, SortTestRecord o2) {
        if (o1.getSortkey1() ＜ o2.getSortkey1()){
            return -1;
        } else if (o1.getSortkey1() ＞ o2.getSortkey1()){
            return 1;
        } else if (o1.getSortkey2() ＜ o2.getSortkey2()){
            return -1;
        } else if (o1.getSortkey2() ＞ o2.getSortkey2()){
            return 1;
        } else {
            return o1.getSortkey3() - o2.getSortkey3();
        }
    }

}

import java.util.Comparator;

public class SortTestComparator implements Comparator＜SortTestRecord＞ {

@Override

public int compare(SortTestRecord o1, SortTestRecord o2) {

if (o1.getSortkey1() ＜ o2.getSortkey1()){

return -1;

} else if (o1.getSortkey1() ＞ o2.getSortkey1()){

return 1;

} else if (o1.getSortkey2() ＜ o2.getSortkey2()){

return -1;

} else if (o1.getSortkey2() ＞ o2.getSortkey2()){

return 1;

} else {

return o1.getSortkey3() - o2.getSortkey3();

}

【結果（１回目）】

［サンプル出力］
（1つ目、123,457つ目、1,000,000つ目を出力）
0,0,0
1,2,3456
9,9,9999

［配列の差異箇所出力］
差異無し。

［処理時間］
・３つのソートキーによりソートを実施
2750 ms
・フォーマット変更を行いソートを実施
19105 ms
　（内、ソート部分だけの時間）
　3827 ms

［サンプル出力］

（1つ目、123,457つ目、1,000,000つ目を出力）

0,0,0

1,2,3456

9,9,9999

［配列の差異箇所出力］

差異無し。

［処理時間］

・３つのソートキーによりソートを実施

2750 ms

・フォーマット変更を行いソートを実施

19105 ms

　（内、ソート部分だけの時間）

　3827 ms

【結果（２回目）】

［サンプル出力］
（1つ目、123,457つ目、1,000,000つ目を出力）
0,0,0
1,2,3456
9,9,9999

［配列の差異箇所出力］
差異無し。

［処理時間］
・３つのソートキーによりソートを実施
1692 ms
・フォーマット変更を行いソートを実施
13627 ms
　（内、ソート部分だけの時間）
　3350 ms

［サンプル出力］

（1つ目、123,457つ目、1,000,000つ目を出力）

0,0,0

1,2,3456

9,9,9999

［配列の差異箇所出力］

差異無し。

［処理時間］

・３つのソートキーによりソートを実施

1692 ms

・フォーマット変更を行いソートを実施

13627 ms

　（内、ソート部分だけの時間）

　3350 ms

【結果（３回目）】

［サンプル出力］
（1つ目、123,457つ目、1,000,000つ目を出力）
0,0,0
1,2,3456
9,9,9999

［配列の差異箇所出力］
差異無し。

［処理時間］
・３つのソートキーによりソートを実施
2177 ms
・フォーマット変更を行いソートを実施
15333 ms
　（内、ソート部分だけの時間）
　3224 ms

［サンプル出力］

（1つ目、123,457つ目、1,000,000つ目を出力）

0,0,0

1,2,3456

9,9,9999

［配列の差異箇所出力］

差異無し。

［処理時間］

・３つのソートキーによりソートを実施

2177 ms

・フォーマット変更を行いソートを実施

15333 ms

　（内、ソート部分だけの時間）

　3224 ms

【結果まとめ】

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

昔に固定長フォーマットに直してまとめてソートするという手法を実務で見かけたので試してみましたが、この手法はやめた方が良さそうなことがわかりました。
ソート処理自体も複数のキーでソートした方が高速だというのは意外でした。

2021年6月9日

Java：任意の順番でのソート

JavaのCollection型（サブクラスにList型等がある）は、Collections.sortメソッドでソートすることが可能です。
Collections.sortメソッドは、第一引数にソートしたいCollection型のオブジェクト、第二引数にComparator型のオブジェクトを渡します。
第二引数のComparator型のオブジェクトにより、ソート順が決まります。

Collections.sortメソッドでは、Comparator型のcompareメソッドを利用してソートを行います。
ソート順を定義するためには、Comparator型を実装したクラスを独自に作成し、compareメソッドをオーバーライドして独自のロジックを記述する必要があります。
compareメソッドの説明は以下です。
https://docs.oracle.com/javase/jp/8/docs/api/java/util/Comparator.html#compare-T-T-
簡単に言うと、compareメソッドの第一引数と第二引数について、戻り値がマイナスの値の場合は「第一引数→第二引数」の順番に並び、戻り値がプラスの値の場合は「第二引数→第一引数」の順番に並びます。

これを利用して、任意の順番でソートを行うサンプルが以下になります。

【サンプルコード】

・MySortMain.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class MySortMain {

    public static void main(String［］ args) {

        // ソート対象のリストを作成する
        List＜String＞ list = new ArrayList&lt;>();
        list.add("メグリネ　ルカ");
        list.add("ハツネ　ミク");
        list.add("カガミネ　レン");
        list.add("カガミネ　リン");

        // ソート（文字コード順）
        Comparator＜String＞ mySort1 = new MySort1();
        Collections.sort(list, mySort1);
        System.out.println("［文字コード順のソート］");
        for (String str : list) {
            System.out.println(str);
        }

        // ソート（独自ソート順）
        Comparator＜String＞ mySort2 = new MySort2();
        Collections.sort(list, mySort2);
        System.out.println("");
        System.out.println("［独自ソート順のソート］");
        for (String str : list) {
            System.out.println(str);
        }

    }

}

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

public class MySortMain {

public static void main(String［］ args) {

// ソート対象のリストを作成する

List＜String＞ list = new ArrayList<>();

list.add("メグリネ　ルカ");

list.add("ハツネ　ミク");

list.add("カガミネ　レン");

list.add("カガミネ　リン");

// ソート（文字コード順）

Comparator＜String＞ mySort1 = new MySort1();

Collections.sort(list, mySort1);

System.out.println("［文字コード順のソート］");

for (String str : list) {

System.out.println(str);

}

// ソート（独自ソート順）

Comparator＜String＞ mySort2 = new MySort2();

Collections.sort(list, mySort2);

System.out.println("");

System.out.println("［独自ソート順のソート］");

for (String str : list) {

System.out.println(str);

}

・MySort1.java

import java.util.Comparator;

// 今回はString型を対象としているが、独自型にも同じ方法で対応できる
public class MySort1 implements Comparator＜String＞ {

        @Override
        public int compare(String o1, String o2) {
            // o1の文字コードからo2の文字コードを減算した値を返すメソッド
            return o1.compareTo(o2);
        }

}

import java.util.Comparator;

// 今回はString型を対象としているが、独自型にも同じ方法で対応できる

public class MySort1 implements Comparator＜String＞ {

@Override

public int compare(String o1, String o2) {

// o1の文字コードからo2の文字コードを減算した値を返すメソッド

return o1.compareTo(o2);

}

・MySort2.java

import java.util.Comparator;

// 今回はString型を対象としているが、独自型にも同じ方法で対応できる
public class MySort2 implements Comparator＜String＞ {

    @Override
    public int compare(String o1, String o2) {
        return mySortOrder(o1) - mySortOrder(o2);
    }

    // 独自のソート順の定義
    public int mySortOrder(String str) {
        if (str.equals("ハツネ　ミク")) { return 1; }
        else if (str.equals("カガミネ　リン")) { return 2; }
        else if (str.equals("カガミネ　レン")) { return 3; }
        else if (str.equals("メグリネ　ルカ")) { return 4; }
        else {return 5;}
    }

}

import java.util.Comparator;

// 今回はString型を対象としているが、独自型にも同じ方法で対応できる

public class MySort2 implements Comparator＜String＞ {

@Override

public int compare(String o1, String o2) {

return mySortOrder(o1) - mySortOrder(o2);

}

// 独自のソート順の定義

public int mySortOrder(String str) {

if (str.equals("ハツネ　ミク")) { return 1; }

else if (str.equals("カガミネ　リン")) { return 2; }

else if (str.equals("カガミネ　レン")) { return 3; }

else if (str.equals("メグリネ　ルカ")) { return 4; }

else {return 5;}

}

【実行結果】

［文字コード順のソート］
カガミネ　リン
カガミネ　レン
ハツネ　ミク
メグリネ　ルカ

［独自ソート順のソート］
ハツネ　ミク
カガミネ　リン
カガミネ　レン
メグリネ　ルカ

［文字コード順のソート］

カガミネ　リン

カガミネ　レン

ハツネ　ミク

メグリネ　ルカ

［独自ソート順のソート］

ハツネ　ミク

カガミネ　リン

カガミネ　レン

メグリネ　ルカ

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

javaで独自順のソート処理をする機会があったので、実装方法を簡単に書いてみました。
Comparatorインターフェースのcompareメソッドを実装すること、compareメソッドの戻り値によりソート順を定義すること、を抑えれば、何をしているか理解できると思います。

2021年6月1日

Base64の説明とjavaでのエンコード・デコードの例

Base64とは、テキストデータやバイナリデータ（画像ファイル、PDFファイル等）を表現する方式の一つです。
以下の64種類の文字と末尾のパディング文字（=）を用いて表現するのが特徴です。
・アルファベット（a～z, A～Z）
・数字（0～9）
・一部の記号（+, /）

この表現方式は、一部の文字しか使用できないプロトコルでデータの送受信を行いたい場合に有用であり、ASCII文字しか送受信できないプロトコルでもデータの送受信が可能になります。
有名な所で言うと、電子メール（SMTP）でBase64が使われています。
また、APIでのデータ送受信でも良く使われます。

ここで、Base64のエンコード・デコードをイメージしやすくするため、２バイト文字（日本語）をJava8 の java.util.Base64を用いてエンコード・デコードしてみます。

【サンプルコード】

・Base64Test.java

import java.util.Base64;

public class Base64Test {

    public static void main(String［］ args) {

        // 元の文字列（２バイト文字）
        final String orgStr = "こんにちは！";

        // Base64へのエンコード
        String encodedStr =
            Base64.getEncoder().encodeToString(orgStr.getBytes());

        // Base64からのデコード
        String decodedStr =
            new String(Base64.getDecoder().decode(encodedStr));

        System.out.println("元の文字列　　　　　 : " + orgStr);
        System.out.println("Base64へのエンコード : " + encodedStr);
        System.out.println("Base64からのデコード : " + decodedStr);

    }

}

import java.util.Base64;

public class Base64Test {

public static void main(String［］ args) {

// 元の文字列（２バイト文字）

final String orgStr = "こんにちは！";

// Base64へのエンコード

String encodedStr =

Base64.getEncoder().encodeToString(orgStr.getBytes());

// Base64からのデコード

String decodedStr =

new String(Base64.getDecoder().decode(encodedStr));

System.out.println("元の文字列　　　　　 : " + orgStr);

System.out.println("Base64へのエンコード : " + encodedStr);

System.out.println("Base64からのデコード : " + decodedStr);

}

【実行結果】

元の文字列　　　　　 : こんにちは！
Base64へのエンコード : 44GT44KT44Gr44Gh44Gv77yB
Base64からのデコード : こんにちは！

元の文字列　　　　　 : こんにちは！

Base64へのエンコード : 44GT44KT44Gr44Gh44Gv77yB

Base64からのデコード : こんにちは！

なお、今回の記事では触れませんが、バイナリファイルを1バイトずつエンコード・デコードすることで、バイナリデータにも対応できます。
また、Base64のエンコード・デコードの方式は公開されており、人気の言語ではライブラリも存在しているので、他の言語でも実装可能です。

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

Base64については入門書で触れられることが少なく、情報処理技術者試験でも午前問題で稀に出題される程度なので、実務で初めて耳にする方は少なくないと思います。
「Base64を使えば画像や動画もASCII文字（1バイト文字）で表現できる」というざっくりな知識だけでも覚えておけば、実務でもスムーズにコミュニケーションできるかと思います。