DEV Community: TANIAOKA, Akihiro

VSCodeでデフォルトのターミナルをPowerShellからGit Bashに変更するには

TANIAOKA, Akihiro — Mon, 03 Jun 2024 13:26:48 +0000

VSCodeでデフォルトのターミナルをPowerShellからGit Bashに変更するには、以下の手順を行います。

VSCodeを開く

VSCodeを起動します。
設定を開く

メニューバーから File -> Preferences -> Settings を選択するか、ショートカットキー Ctrl + , を使用して設定を開きます。
設定を編集

設定画面の右上にあるアイコンから Open Settings (JSON) を選択し、設定ファイル（settings.json）を開きます。
settings.jsonに以下のコードを追加

   "terminal.integrated.shell.windows": "C:\\Program Files\\Git\\bin\\bash.exe"

これは、Git Bashの実行ファイルのパスです。インストール場所が異なる場合は、そのパスを指定してください。

変更を保存 ファイルを保存します。これでVSCodeのターミナルがGit Bashに変更されます。

また、設定ファイルを使わずにGUIからも変更できます：

設定を開く

同じく File -> Preferences -> Settings を選択します。
検索バーに「terminal.integrated.shell.windows」と入力

表示された設定項目に、Git Bashのパス C:\\Program Files\\Git\\bin\\bash.exe を入力します。

これで、次回ターミナルを開くとGit Bashが起動するようになります。

perplexity

VSCodeでデフォルトのターミナルをPowerShellからGit Bashに変更する手順は以下の通りです。

VSCodeを開き、Ctrl+Shift+Pでコマンドパレットを開きます。
「Terminal: Select Default Profile」と入力し、そのコマンドを選択します。
表示されたリストから「Git Bash」を選択します。[1][4]

または、設定ファイル(settings.json)を直接編集する方法もあります。

Ctrl+,でSettings画面を開くか、Ctrl+Shift+Pでコマンドパレットを開き、「Preferences: Open Settings (JSON)」と入力して選択します。[3]
"terminal.integrated.defaultProfile.windows": "Git Bash"を追加します。[1]

これで、VSCodeを再起動するか新しいターミナルを開くと、デフォルトでGit Bashが起動するようになります。

補足として、Git Bashを使う理由は、WindowsでGitを操作する際に便利だからです。PowerShellではGitコマンドが使えない、あるいは不自然な動作をすることがあるためです。[2]

Citations:
[1] https://zaki-hmkc.hatenablog.com/entry/2023/03/23/002945
[2] https://ralacode.com/blog/post/use-git-bash-on-vscode/
[3] https://qiita.com/daikiozawa/items/48a9fe0e2898c7dd78ae
[4] https://zenn.dev/unsoluble_sugar/articles/362a17a7f57020
[5] https://zenn.dev/valmet083/articles/389fc86c072ed8

４章17

TANIAOKA, Akihiro — Fri, 24 May 2024 23:50:16 +0000

以下はあなたのJavaプログラムにコメントアウトを追加して分かりやすくしたものです。このプログラムの実行結果が「12」になる理由を説明します。

public class Main {
    public static void main(String[] args) {
        int total = 0; // 合計を保存する変数を初期化

        // 外側のループ: i を 0 から 4 まで繰り返す
        a: for (int i = 0; i < 5; i++) {
            // 内側のループ: j を 0 から 4 まで繰り返す
            b: for (int j = 0; j < 5; j++) {
                // i が偶数の場合、外側のループの次のイテレーションに進む
                if (i % 2 == 0) continue a;
                // j が 3 以上の場合、内側のループを終了
                if (3 < j) break b;
                // total に j の値を加える
                total += j;
            }
        }

        // 合計を出力
        System.out.println(total);
    }
}

では、コードの流れを見てみましょう。

total 変数を 0 で初期化します。
外側のループ (a) は i の値を 0 から 4 まで繰り返します。
内側のループ (b) は j の値を 0 から 4 まで繰り返します。
内側のループで、もし i が偶数 (0, 2, 4) の場合、continue a によって外側のループの次のイテレーションに進みます。
もし j が 3 より大きい場合、break b によって内側のループを終了します。
total に j の値を加算します。

具体的な計算の流れを確認します：

i = 0: 偶数なので continue a によりスキップ
i = 1:
- j = 0: total += 0 → total = 0
- j = 1: total += 1 → total = 1
- j = 2: total += 2 → total = 3
- j = 3: total += 3 → total = 6
- j = 4: break b により内側ループ終了
i = 2: 偶数なので continue a によりスキップ
i = 3:
- j = 0: total += 0 → total = 6
- j = 1: total += 1 → total = 7
- j = 2: total += 2 → total = 9
- j = 3: total += 3 → total = 12
- j = 4: break b により内側ループ終了
i = 4: 偶数なので continue a によりスキップ

最終的に total は 12 になります。よって、正しい答えは B の「12が表示される」です。

3章１２

TANIAOKA, Akihiro — Fri, 24 May 2024 23:05:05 +0000

==演算子とequals()メソッドの違いについて詳しく説明します。同一性（identity）と同値性（equality）の違いも含めて説明します。

同一性（identity）

==演算子は、オブジェクトの参照を比較します。
これは、2つの変数が同じオブジェクトを指しているかどうかをチェックします。

例：

String a = "sample";
String b = "sample";
String c = new String("sample");

System.out.println(a == b); // true
System.out.println(a == c); // false

この例では、aとbは同じ文字列リテラルを指しているので、a == bはtrueになります。一方、cは新しいオブジェクトを作成しているので、a == cはfalseになります。

同値性（equality）

equals()メソッドは、オブジェクトの内容を比較します。
これは、2つのオブジェクトが同じ値を持っているかどうかをチェックします。

例：

String a = "sample";
String b = "sample";
String c = new String("sample");

System.out.println(a.equals(b)); // true
System.out.println(a.equals(c)); // true

この例では、aとbは同じ内容を持っているので、a.equals(b)はtrueになります。同様に、cも同じ内容を持っているので、a.equals(c)もtrueになります。

まとめ

==演算子は、2つの参照が同じオブジェクトを指しているかどうかを確認します。
equals()メソッドは、2つのオブジェクトが同じ内容を持っているかどうかを確認します。

例を通じた理解

String a = "example";
String b = "example";
String c = new String("example");

System.out.println(a == b);      // true (同一の文字列リテラルを指している)
System.out.println(a == c);      // false (異なるオブジェクトを指している)
System.out.println(a.equals(b)); // true (内容が同じ)
System.out.println(a.equals(c)); // true (内容が同じ)

このように、==は参照の比較、equals()は内容の比較です。同一性は同じオブジェクトであること、同値性は内容が同じであることを意味します。

この違いを理解することが、Javaのオブジェクト比較において非常に重要です。

１３章２６

TANIAOKA, Akihiro — Fri, 24 May 2024 05:48:23 +0000

4行目のエラーを回避するには、変数 num を static にする必要があります。test メソッドは static であるため、static メソッド内で static でないメンバー変数を直接参照することはできません。以下のように修正します：

public class Main {
    static int num;

    private static void test() {
        num++;
        System.out.println(num);
    }

    public static void main(String[] args) {
        Main.test();
        Main.test();
    }
}

この修正により、プログラムは正しくコンパイルされ、実行時に 1 と 2 が表示されます。

１２章３３

TANIAOKA, Akihiro — Fri, 24 May 2024 01:24:11 +0000

以下に、2つの回避方法をそれぞれ別々のコードとして示し、コメントアウトで解説を追加します。

方法1: `keys.clear();`を削除して例外を回避

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    // HashMapを作成してキーと値を格納するための静的マップ
    static Map<String, String> map = new HashMap<>();

    // 不変リストを使用 (例外が発生する可能性のあるリスト)
    static List<String> keys = List.of("A", "B", "C");

    // 値の配列を定義
    static String[] values = {"1", "2", "3"};

    // 静的初期化ブロックでキーと値をマップに追加
    static {
        for (int i = 0; i < keys.size(); i++) {
            map.put(keys.get(i), values[i]);
        }
    }

    public static void main(String[] args) {
        // 例外が発生するkeys.clear()の呼び出しを削除
        // keys.clear(); // この行を削除することで例外を回避

        // values配列を空にする
        values = new String[0];

        // マップのサイズ、キーリストのサイズ、values配列の長さを出力。3,3,0
        System.out.println(map.size() + "," + keys.size() + "," + values.length);
    }
}

解説:

方法1: keys.clear();を削除して例外を回避
- keysリストはList.of("A", "B", "C")を使用して不変リストとして作成されています。
- 不変リストのため、変更操作（例：clear()）はサポートされておらず、keys.clear();を呼び出すとUnsupportedOperationExceptionが発生します。
- この例外を回避するために、keys.clear();の行を削除しました。

map.size() は 3（マップには3つのキーと値のペアが格納されています）
keys.size() は 3（keysリストは不変であり、変更されないので3つの要素を持っています）
values.length は 0（values配列は空に変更されました）

方法2: 可変リストを使用して例外を回避

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MainWithMutableKeys {
    // HashMapを作成してキーと値を格納するための静的マップ
    static Map<String, String> map = new HashMap<>();

    // 可変リストを使用 (例外を回避するためのリスト)
    static List<String> keys = new ArrayList<>(List.of("A", "B", "C"));

    // 値の配列を定義
    static String[] values = {"1", "2", "3"};

    // 静的初期化ブロックでキーと値をマップに追加
    static {
        for (int i = 0; i < keys.size(); i++) {
            map.put(keys.get(i), values[i]);
        }
    }

    public static void main(String[] args) {
        // 可変リストの場合、keys.clear()は正常に動作する
        keys.clear(); // この行は正常に動作

        // values配列を空にする
        values = new String[0];

        // マップのサイズ、キーリストのサイズ、values配列の長さを出力。3,0,0
        System.out.println(map.size() + "," + keys.size() + "," + values.length);
    }
}

解説:

方法2: 可変リストを使用して例外を回避
- keysリストをnew ArrayList<>(List.of("A", "B", "C"))を使用して可変リストとして作成します。
- これにより、keys.clear();が正常に動作し、例外は発生しません。
- keys.clear();を呼び出しても問題なくリストをクリアすることができます。

map.size() は 3（マップには3つのキーと値のペアが格納されています）
keys.size() は 0（keys.clear();によってkeysリストが空になります）
values.length は 0（values配列は空に変更されました）

12章３２

TANIAOKA, Akihiro — Fri, 24 May 2024 01:10:49 +0000

このコードは正しいです。抽象クラス Item には、一つの抽象メソッド calcPrice と、一つの具体的なメソッド print が含まれています。この構文は問題ありません。具体的なメソッド print には実装が含まれており、抽象メソッド calcPrice には abstract キーワードが付いています。

最終的なコードは以下の通りです：

abstract class Item {
    public abstract int calcPrice(Item item);
    public void print(Item item) { 
        /* do something */ 
    }
}

この形式であれば、抽象クラスの定義として正しく、Javaコンパイラもエラーを出さないでしょう。

追記

はい、このコードにはいくつかの間違いがあります。抽象クラス Item には抽象メソッドが含まれていますが、抽象メソッドには abstract キーワードが必要です。また、抽象メソッドは実装を持たないため、セミコロンで終わる必要があります。

修正したコードは以下のようになります：

abstract class Item {
    public abstract int calcPrice(Item item);
    public abstract void print(Item item);
}

このように、メソッドの前に abstract キーワードを追加し、メソッドの中身を削除してセミコロンで終わるようにします。

１２章４

TANIAOKA, Akihiro — Fri, 24 May 2024 00:17:35 +0000

このコードスニペットでは、変数 i は実質的に final とは言えません。なぜなら、変数 i はラムダ式内で参照される前に再代入されているためです。具体的には、i がラムダ式内で使用される前に i++ によってその値が変更されています。このため、コンパイル時にエラーが発生します。

以下は該当する部分を示します：

void sample() {
    int i = 0;
    Supplier<Integer> foo = () -> i;
    i++; // ここで i の値が変更されるため、実質的に final ではなくなる
    System.out.println(foo.get());
}

このコードは、コンパイル時に以下のエラーが発生します：

local variables referenced from a lambda expression must be final or effectively final

ラムダ式で参照される変数 i が実質的に final と見なされるためには、その値が再代入されないことが必要です。したがって、再代入されるコードを削除または変更する必要があります。

修正例：

void sample() {
    final int i = 0;
    Supplier<Integer> foo = () -> i;
    // i++; // この行を削除
    System.out.println(foo.get());
}

もしくは、

void sample() {
    int i = 0;
    Supplier<Integer> foo = () -> i;
    System.out.println(foo.get());
    i++; // ラムダ式の後に i を変更
}

このように、ラムダ式内で使用する変数が変更されないようにすることで、実質的に final として扱われ、コンパイルエラーを回避できます。

１３章42

TANIAOKA, Akihiro — Wed, 22 May 2024 07:15:11 +0000

このJavaのプログラムを分解して、なぜ答えがCなのかを説明します。

まず、プログラムを見てみましょう。

クラス Sample

public class Sample implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("C");
    }
}

このクラスはAutoCloseableインターフェースを実装しており、closeメソッドがオーバーライドされています。このcloseメソッドは、クラスが閉じられるときに呼び出され、「C」を出力します。

クラス Main

public class Main {
    public static void main(String[] args) {
        try (Sample s = new Sample()) {
            throw new Exception();
        } catch (Exception e) {
            System.out.println("A");
        } finally {
            System.out.println("B");
        }
    }
}

ここでは、try-with-resources文を使用しています。この文では、tryブロックが終了すると自動的にリソースが閉じられます。

プログラムの実行順序

tryブロックに入る。
Sampleクラスのインスタンスを作成し、sに代入する。
tryブロック内でExceptionがスローされる。
Exceptionがスローされると、まずリソース（ここではs）が閉じられる。このとき、closeメソッドが呼び出され、「C」が出力される。
その後、catchブロックが実行され、「A」が出力される。
最後に、finallyブロックが実行され、「B」が出力される。

まとめ

最初にtryブロック内で例外がスローされると、リソースが閉じられる（closeメソッドが呼び出される）ため、「C」が出力されます。
その後、catchブロックで「A」が出力されます。
最後にfinallyブロックで「B」が出力されます。

したがって、出力は順に「C」「A」「B」となります。よって、答えはCになります。

１３章25

TANIAOKA, Akihiro — Wed, 22 May 2024 02:49:03 +0000

いいえ、MainクラスではSampleクラスのインスタンスを作成して、その際にコンストラクタを呼び出してvalueフィールドを初期化しています。つまり、Mainクラスで特別にvalueフィールドを初期化する必要はありません。すべてがコンストラクタで行われます。

以下がその例です：

package ex25.a;

public class Sample {
    public String value; // フィールドの宣言
    public Sample(String value) { // コンストラクタで初期化
        this.value = value;
    }
}

package ex25.b;
import ex25.a.Sample;

public class Main {
    public static void main(String[] args) {
        Sample s = new Sample("Hello Java"); // コンストラクタ呼び出し
        System.out.println(s.value); // 初期化されたvalueを出力
    }
}

Mainクラスでは、次のステップを実行しています：

Sampleクラスのインスタンスを作成する際に、コンストラクタSample(String value)を呼び出し、"Hello Java"という値を渡しています。
Sampleクラスのコンストラクタは、この値をvalueフィールドに割り当てます。
System.out.println(s.value);で、初期化されたvalueフィールドの値を出力します。

したがって、Mainクラスで追加の初期化を行う必要はありません。このままで正しく動作し、"Hello Java"が出力されます。

１３章4

TANIAOKA, Akihiro — Tue, 21 May 2024 00:44:51 +0000

Javaプログラムは2つのクラス、TrashとCacheTrashを定義しています。これらのクラスはリスト管理の基本的な操作を実装しており、CacheTrashはTrashを拡張しています。以下にコードにコメントを追加して説明します。

import java.util.ArrayList;
import java.util.List;

// Trashクラスは文字列のリストを管理する基本クラス
public class Trash {
    // 文字列のリスト
    List<String> list = new ArrayList<>();

    // コンストラクタ：新しい文字列をリストに追加する
    protected Trash(String val) {
        add(val);
    }

    // 文字列がリストに存在するかどうかを常にtrueで返す
    public boolean test(String val) {
        return true;
    }

    // 文字列をリストから削除する
    public void delete(String val) {
        list.remove(val);
    }

    // 文字列をリストに追加する
    public final void add(String val) {
        list.add(val);
    }
}

// CacheTrashクラスはTrashクラスを拡張し、削除された文字列を一時的に保存する
public class CacheTrash extends Trash {
    // 削除された文字列を一時的に保存する変数
    private String tmp = null;

    // コンストラクタ：親クラスのコンストラクタをnullで呼び出す
    public CacheTrash() {
        super(null);
    }

    // 文字列がリストに存在するかどうかをチェックする
    public boolean test(String val) {
        return list.contains(val);
    }

    // 文字列を削除し、一時変数に保存する
    public void delete(String val) {
        this.tmp = val;
    }

    // 一時変数に保存された文字列を親クラスのdeleteメソッドでリストから削除する
    public void flush() {
        super.delete(tmp);
    }
}

クラス `Trash`

list: 文字列のリストを保持する。
Trash(String val): コンストラクタで与えられた文字列をリストに追加する。
test(String val): 文字列が存在するかをチェックするメソッド（常にtrueを返す）。
delete(String val): 文字列をリストから削除する。
add(String val): 文字列をリストに追加する。

クラス `CacheTrash`

tmp: 一時的に削除された文字列を保持するための変数。
CacheTrash(): コンストラクタで親クラスのコンストラクタをnullで呼び出す。
test(String val): 文字列がリストに存在するかをチェックする（list.contains(val)を使用）。
delete(String val): 文字列を一時変数に保存する（リストからは削除しない）。
flush(): 一時変数に保存された文字列を親クラスのdeleteメソッドでリストから削除する。

このプログラムは基本的なリスト操作を行うクラスと、それを拡張して一時的に削除された文字列を保持するクラスを示しています。

１２章77

TANIAOKA, Akihiro — Mon, 20 May 2024 23:30:23 +0000

以下にコードにコメントを追加して、なぜコンパイルエラーが発生するのか説明します。

// Sampleクラス
public class Sample {
    public void test() {
        System.out.println("Sample#test()");
    }
}

// SubSampleクラス。Sampleクラスを継承している。
public class SubSample extends Sample {
    @Override
    public void test() {
        System.out.println("SubSample#test()");
    }
}

// Mainクラス
public class Main {
    public static void main(String[] args) {
        // SubSample型の変数subを作成し、SubSampleのインスタンスを割り当てる
        SubSample sub = new SubSample();

        // Sample型の変数sampleを作成し、SubSampleのインスタンスを割り当てる
        Sample sample = new SubSample();

        // subにsampleを代入する。sampleはSample型であり、subはSubSample型である。
        // ここで型の不一致が発生するため、コンパイルエラーが発生する。
        sub = sample;

        // 代入後のsubは実際にはSample型のインスタンスを参照している。
        // しかし、Javaの動的バインディングによりSubSample#test()が呼び出される。
        sub.test();

        // sampleは元々SubSampleのインスタンスを参照しているので、SubSample#test()が呼び出される。
        sample.test();
    }
}

コンパイルエラーの詳細

sub = sample; の行でコンパイルエラーが発生するのは、subがSubSample型であり、sampleがSample型であるためです。Javaでは、サブクラス型の変数にスーパークラス型のオブジェクトを直接代入することはできません。このため、型の不一致が発生し、コンパイルエラーとなります。

追記

2つの修正方法のうち、どちらがベターかは状況によりますが、以下の点を考慮して判断することができます。

修正方法1: 型を一致させる

// Sampleクラス
public class Sample {
    public void test() {
        System.out.println("Sample#test()");
    }
}

// SubSampleクラス。Sampleクラスを継承している。
public class SubSample extends Sample {
    @Override
    public void test() {
        System.out.println("SubSample#test()");
    }
}

// Mainクラス
public class Main {
    public static void main(String[] args) {
        // Sample型の変数subを作成し、SubSampleのインスタンスを割り当てる
        Sample sub = new SubSample();

        // Sample型の変数sampleを作成し、SubSampleのインスタンスを割り当てる
        Sample sample = new SubSample();

        // subにsampleを代入する。両方ともSample型なので問題ない。
        sub = sample;

        // subはSubSampleのインスタンスを参照しているため、SubSample#test()が呼び出される。
        sub.test();

        // sampleもSubSampleのインスタンスを参照しているため、SubSample#test()が呼び出される。
        sample.test();
    }
}

修正方法2: ダウンキャストを使用する

// Sampleクラス
public class Sample {
    public void test() {
        System.out.println("Sample#test()");
    }
}

// SubSampleクラス。Sampleクラスを継承している。
public class SubSample extends Sample {
    @Override
    public void test() {
        System.out.println("SubSample#test()");
    }
}

// Mainクラス
public class Main {
    public static void main(String[] args) {
        // SubSample型の変数subを作成し、SubSampleのインスタンスを割り当てる
        SubSample sub = new SubSample();

        // Sample型の変数sampleを作成し、SubSampleのインスタンスを割り当てる
        Sample sample = new SubSample();

        // subにsampleをキャストして代入する。これにより型の不一致が解消される。
        sub = (SubSample) sample;

        // subはSubSampleのインスタンスを参照しているため、SubSample#test()が呼び出される。
        sub.test();

        // sampleもSubSampleのインスタンスを参照しているため、SubSample#test()が呼び出される。
        sample.test();
    }
}

比較と推奨

修正方法1のメリット

コードの読みやすさ: 型のキャストを行わないため、コードがシンプルで理解しやすい。
安全性: ダウンキャストによるClassCastExceptionのリスクがない。

修正方法1のデメリット

柔軟性の欠如: subをSample型にすると、他のSubSample特有のメソッドを呼び出すことができなくなる。

修正方法2のメリット

柔軟性: subをSubSample型として保持するため、SubSample特有のメソッドも使用できる。

修正方法2のデメリット

安全性のリスク: ダウンキャストは実行時にClassCastExceptionを引き起こす可能性があるため、キャストする前に型を確認する必要がある。
コードの複雑化: キャスト操作はコードの読みやすさを低下させる可能性がある。

結論

修正方法1を推奨します。特に、キャストが不要であり、コードがよりシンプルかつ安全であるためです。ただし、subをSubSample型として使用する必要がある場合や、SubSample特有のメソッドを呼び出す必要がある場合は、修正方法2を検討してください。

最終的な選択は、アプリケーションの設計や要件に依存します。もしサブクラスの特定の機能を利用する必要があるなら、キャストを使用する方法が適切です。さもなければ、コードのシンプルさと安全性を優先して、型を一致させる方法が望ましいです。

12章７４

TANIAOKA, Akihiro — Mon, 20 May 2024 23:14:54 +0000

このJavaのプログラムは、以下のことを試みています。しかし、コードにはいくつかの問題があり、期待される動作は実現できません。

String[] str配列をサイズ2で初期化します。
各要素に対して、"e" + インデックス番号の文字列を結合しようとしていますが、これが正しく動作しません。

以下に、コードの各部分にコメントを付けて説明します。

public class Main {
    public static void main(String[] args) {
        // 文字列の配列をサイズ2で初期化
　　　　　　　　　　　　　　 //下記の２つのインスタンスがつくられる。
        // str[0] -> null
        // str[1] -> null
        String[] str = new String[2];
        int i = 0;

        // 配列の各要素に "e" + インデックス番号を結合するループ
        for (String s : str) {
            // str[i]に "e" + i を結合（実際にはこの操作は何も行わない）
            str[i].concat("e" + i);
            i++;
        }

        // 配列の各要素を出力するループ
        for (i = 0; i < str.length; i++) {
            System.out.println(str[i]); // すべての要素はnullのまま
        }
    }
}

問題点

str[i].concat("e" + i);は文字列を結合しますが、str[i]自体は変更されません。文字列はイミュータブル（不変）なので、concatメソッドは新しい文字列を返しますが、元のstr[i]を変更するわけではありません。
String[] strは初期化時点では各要素がnullなので、str[i].concat("e" + i);を呼び出すとNullPointerExceptionが発生します。

修正方法

以下のように修正すると、正しく動作します。

public class Main {
    public static void main(String[] args) {
        // 文字列の配列をサイズ2で初期化

        String[] str = new String[2];
        int i = 0;

        // 配列の各要素に "e" + インデックス番号を代入
        for (int j = 0; j < str.length; j++) {
            str[j] = "e" + j;
        }

        // 配列の各要素を出力するループ
        for (i = 0; i < str.length; i++) {
            System.out.println(str[i]); // 正しく "e0" と "e1" が出力される
        }
    }
}

この修正により、配列の各要素に"e"とインデックス番号を結合した文字列が代入され、期待通りの出力が得られます。