Javaの「Listクラス」とは？使い方と応用テクニックを徹底解説

import java.util.List; // Listの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listを生成する

    List<Integer> nums = new ArrayList<Integer>();

    // 3つの整数値をListに追加する

    // （addメソッドの詳細については後述）

    nums.add(1);

    nums.add(2);

    nums.add(3);

    // すべての要素をまとめて表示する

    System.out.println(nums);

    // 各要素にアクセスして中身を表示する

    // （getメソッドの詳細については後述）

    System.out.println(nums.get(0));

    System.out.println(nums.get(1));

    System.out.println(nums.get(2));

  }

}

1

2

3

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // パターンA：asListメソッドを使う（推奨）

    List<String> listA = new ArrayList<>(Arrays.asList(“A”, “B”, “C”));

    // パターンB：初期化時に「インスタンスイニシャライザ」を使う（非推奨）

    List<String> listB = new ArrayList<String>() {

      {

        add(“A”);

        add(“B”);

        add(“C”);

      }

    };

    // 2つのパターンのListを表示する

    System.out.println(listA);

    System.out.println(listB);

  }

}

[A, B, C]

import java.util.List; // Listの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listを生成する

    List<Integer> nums = new ArrayList<Integer>();

    // 3つの整数値をListに追加する

    nums.add(1);

    nums.add(2);

    nums.add(3);

    // すべての要素をまとめて表示する

    System.out.println(nums);

    // インデックス1の要素を変更する

    nums.set(1, 100);

    // インデックス1の要素を表示する

    System.out.println(nums.get(1));

  }

}

100

import java.util.Iterator; // Iteratorの機能を使用する

import java.util.List; // Listの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listを生成する

    List<Integer> nums = new ArrayList<Integer>();

    // 3つの整数値をListに追加する

    nums.add(1);

    nums.add(2);

    nums.add(3);

    // 「拡張for文」で全要素を表示する

    for(Integer num : nums) {

      System.out.println(num);

    }

    // 「forEachメソッド」で全要素を表示する（ラムダ式を使用する場合）

    nums.forEach(num -> System.out.println(num));

    // 「forEachメソッド」で全要素を表示する（メソッド参照を使用する場合）

    nums.forEach(System.out::println);

    // 「iterator（イテレータ）」で全要素を表示する（for文の場合）

    for(Iterator it = nums.iterator(); it.hasNext();) {

      System.out.println(it.next());

    }

    // 「iterator（イテレータ）」で全要素を表示する(while文の場合）

    Iterator<Integer> it = nums.iterator();

    while(it.hasNext()) {

      int num = it.next();

      System.out.println(num); 

    }

  }

}

2

3

1

2

3

1

2

3

1

2

3

1

2

3

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));

    // それぞれの要素を表示する

    System.out.println(nums.get(0));

    System.out.println(nums.get(1));

    System.out.println(nums.get(2));

  }

}

2

3

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));

    // すべての要素を表示する

    System.out.println(nums);

    // それぞれの要素を書き換える

    nums.set(0, 100);

    nums.set(1, 200);

    nums.set(2, 300);

    // すべての要素を表示する

    System.out.println(nums);

  }

}

[100, 200, 300]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));

    // すべての要素を表示する

    System.out.println(“リストの内容：” + nums);

    // リストのサイズを表示する

    System.out.println(“リストのサイズ：” + nums.size());

  }

}

リストのサイズ：3

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> listA = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

    // インデックス1からインデックス3の要素を抽出して別のリストを作成する

    List<Integer> listB = listA.subList(1, 4); // 第2引数に要注意

    // 最初のリストを表示する

    System.out.println(“最初のリスト：” + listA);

    // 切り取ったリストを表示する

    System.out.println(“切り取ったリスト：” + listB);

  }

}

切り取ったリスト：[2, 3, 4]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> listA = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

    // Integer型の空Listを生成する

    List<Integer> listB = new ArrayList<>();

    // 最初のリストが空かどうか判定する

    if(listA.isEmpty()) {

      System.out.println(“最初のリストは空です”);

    }

    else {

      System.out.println(“最初のリストは空ではありません”);

    }

    // 2つ目のリストが空かどうか判定する

    if(listB.isEmpty()) {

      System.out.println(“2つ目のリストは空です”);

    }

    else {

      System.out.println(“2つ目のリストは空ではありません”);

    }

  }

}

2つ目のリストは空です

import java.util.List; // Listの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listを生成する

    List<Integer> nums = new ArrayList<>();

    // Listに3つの値を末尾に追加する

    nums.add(1);

    nums.add(2);

    nums.add(3);

    // リストの内容を表示する

    System.out.println(nums);

    // Listに場所を指定して3つの値を挿入する

    nums.add(0,100); // インデックス0に100を挿入する

    nums.add(3,200); // インデックス3に200を挿入する

    // リストの内容を表示する

    System.out.println(nums);

  }

}

[100, 1, 2, 200, 3]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> listA = new ArrayList<>(Arrays.asList(1, 2, 3));

    List<Integer> listB = new ArrayList<>(Arrays.asList(4, 5, 6));

    List<Integer> listC = new ArrayList<>(Arrays.asList(7, 8, 9));

    // ListAの末尾にListBを追加する

    listA.addAll(listB);

    // リストの内容を表示する

    System.out.println(listA);

    // ListAのインデックス3にListCを追加する

    listA.addAll(3, listC);

    // リストの内容を表示する

    System.out.println(listA);

  }

}

[1, 2, 3, 7, 8, 9, 4, 5, 6]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

    // リストの内容を表示する

    System.out.println(nums);

    // リストからインデックス1の要素を削除する

    nums.remove(1);

    // リストの内容を表示する

    System.out.println(nums);

    // リストからインデックス3の要素を削除する

    nums.remove(3);

    // リストの内容を表示する

    System.out.println(nums);

  }

}

[A, C, D, E]

[A, C, D]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 5, 2, 4, 3));

    // リストの内容を表示する

    System.out.println(nums);

    // リストから要素「3」のインデックスを取得する

    int index = nums.indexOf(3);

    // インデックスが正常値であれば、リストから要素を削除する

    if(index != -1) {

      nums.remove(index);

    }

    // リストの内容を表示する

    System.out.println(nums);

  }

}

[1, 5, 2, 4]

（toListメソッドでリストに変換する）

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> listA = new ArrayList<>(Arrays.asList(1, 1, 2, 3, 3));

    // 元のリストの内容を表示する

    System.out.println(listA);

    // リストから重複要素を取り除き、新たなリストを作成する

    List<Integer> listB = listA.stream().distinct().toList();

    // 新しいリストの内容を表示する

    System.out.println(listB);

  }

}

[1, 2, 3]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> listA = 

        new ArrayList<>(Arrays.asList(1, 2, 3, 3, 5, 6, 8));

    // もうひとつのInteger型Listの生成と初期化を行う

    List<Integer> listB = 

        new ArrayList<>(Arrays.asList(1, 3, 5, 7, 9));

    // リストの内容を表示する

    System.out.println(“リストA” + listA);

    System.out.println(“リストB” + listB);

    // listAからListBとの共通要素以外を削除する

    listA.retainAll(listB);

    // リストの内容を表示する

    System.out.println(“削除後 ” + listA);

  }

}

リストB[1, 3, 5, 7, 9]

削除後 [1, 3, 3, 5]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

    // リストの内容を表示する

    System.out.println(“clear前” + nums);

    // リストを削除する

    nums.clear();

    // リストの内容を表示する

    System.out.println(“clear後” + nums);

  }

}

clear後[]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // String型Listを生成する

    List<String> list = 

        new ArrayList<>(Arrays.asList(“猫”, “犬”, “虎”, “狼”, “猿”));

    // リストから「虎」を検索する

    if(list.contains(“虎”)) {

      System.out.println(“虎を発見！”);

    }

    else {

      System.out.println(“虎は見つかりませんでした…”);

    }

    // リストから「ライオン」を検索する

    if(list.contains(“ライオン”)) {

      System.out.println(“ライオンを発見！”);

    }

    else {

      System.out.println(“ライオンは見つかりませんでした…”);

    }

  }

}

ライオンは見つかりませんでした…

（要素がリストにない場合は「-1」）

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

    // 要素「3」のインデックスを取得する

    int index = nums.indexOf(3);

    // 取得したインデックスを表示する

    System.out.println(index);

    // 要素「0」のインデックスを取得する

    index = nums.indexOf(0);

    // 取得したインデックスを表示する

    System.out.println(index);

  }

}

-1

（要素がリストにない場合は「-1」）

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 1, 2, 3, 1));

    // 要素「1」の最後のインデックスを取得する

    int index = nums.lastIndexOf(1);

    // 取得したインデックスを表示する

    System.out.println(index);

    // 要素「0」の最後のインデックスを取得する

    index = nums.lastIndexOf(0);

    // 取得したインデックスを表示する

    System.out.println(index);

  }

}

-1

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

import java.util.Collections; // Collectionsの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums =

        new ArrayList<>(Arrays.asList(8, 2, 5, 7, 6, 1, 9, 3, 4));

    // ソート前のリストの内容を表示する

    System.out.println(nums);

    // リストを昇順でソートする

    Collections.sort(nums);

    // ソート後のリストの内容を表示する

    System.out.println(nums);

  }

}

[1, 2, 3, 4, 5, 6, 7, 8, 9]

（今回はCollections.reverseOrderで固定）

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

import java.util.Collections; // Collectionsの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums =

        new ArrayList<>(Arrays.asList(8, 2, 5, 7, 6, 1, 9, 3, 4));

    // ソート前のリストの内容を表示する

    System.out.println(nums);

    // リストを降順でソートする

    Collections.sort(nums, Collections.reverseOrder());

    // ソート後のリストの内容を表示する

    System.out.println(nums);

  }

}

[9, 8, 7, 6, 5, 4, 3, 2, 1]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

import java.util.Collections; // Collectionsの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums =

        new ArrayList<>(Arrays.asList(8, 2, 5, 7, 6, 1, 9, 3, 4));

    // ソート前のリストの内容を表示する

    System.out.println(nums);

    // リストを昇順でソートする

    Collections.sort(nums);

    // ソート後のリストの内容を表示する

    System.out.println(nums);

    // リストを逆順に並び替える

    Collections.reverse(nums);

    // ソート後のリストの内容を表示する

    System.out.println(nums);

  }

}

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[9, 8, 7, 6, 5, 4, 3, 2, 1]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));

    // 最初のリストの内容を表示する

    System.out.println(“最初” + nums);

    // 内部でリストを編集する関数を呼び出す

    test(nums);

    // もう一度リストの内容を表示する

    System.out.println(“メソッド呼び出し後：” + nums);

  }

  public static void test(List<Integer> list) {

    // メソッド内でリストの内容を変更する

    list.remove(0); // リストの先頭要素を取り除く

    list.add(100); // リストの末尾に要素「100」を追加する

    // メソッド内でのリストの内容を表示する

    System.out.println(“メソッド内：” + list);

  }

}

メソッド内：[2, 3, 100]

メソッド呼び出し後：[2, 3, 100]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));

    // 最初のリストの内容を表示する

    System.out.println(“最初” + nums);

    // 新しいリスト変数に「ディープコピー」する

    List<Integer> copy = new ArrayList<>(nums);

    // 内部でリストを編集する関数を呼び出す

    test(copy);

    // もう一度リストの内容を表示する

    System.out.println(“メソッド呼び出し後：” + nums);

  }

  public static void test(List<Integer> list) {

    // メソッド内でリストの内容を変更する

    list.remove(0); // リストの先頭要素を取り除く

    list.add(100); // リストの末尾に要素「100」を追加する

    // メソッド内でのリストの内容を表示する

    System.out.println(“メソッド内：” + list);

  }

}

メソッド内：[2, 3, 100]

メソッド呼び出し後：[1, 2, 3]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // String型配列の生成と初期化を行う

    String[] array =  {“AAA”, “BBB”, “CCC”};

    // arrayの内容を表示する

    System.out.println(“array：” + Arrays.toString(array));

    // 上記の配列をString型リスト「listA」に変換する

    List<String> listA = Arrays.asList(array);

    // listAの内容を表示する

    System.out.println(“listA：” + listA);

    // しかし、リストのサイズを変更しようとすると、

    // 「UnsupportedOperationException」が出る！

    // コメントアウトして試してみてください

    //listA.add(“DDD”);

    // サイズを変更可能なリストにするためにコンストラクタを使用する

    // 上記の配列をString型リスト「listB」に変換する

    // 実は、これは冒頭で紹介した「リストの初期化方法」と同じこと

    List<String> listB = new ArrayList<>(Arrays.asList(array));

    // listBの内容を表示する

    System.out.println(“listB：” + listB);

    // このように、リストのサイズ変更も問題なく可能！

    listB.add(“DDD”);

    // listBの内容を表示する

    System.out.println(“listB：” + listB);

  }

}

listA：[AAA, BBB, CCC]

listB：[AAA, BBB, CCC]

listB：[AAA, BBB, CCC, DDD]

import java.util.List; // Listの機能を使用する

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // String型List配列の生成と初期化を行う

    List<String> list = 

      new ArrayList<>(Arrays.asList(“AAA”, “BBB”, “CCC”));

    // listの内容を表示する

    System.out.println(“list：” + list);

    // リストのデータを格納するための配列を生成する

    // 配列のサイズは必ずリストのsizeメソッドで指定する

    String[] array = new String[list.size()];

    // リストをString型配列に変換する

    list.toArray(array);

    // arrayの内容を表示する

    System.out.println(“array：” + Arrays.toString(array));

  }

}

array：[AAA, BBB, CCC]

import java.util.List; // Listの機能を使用する

public class Test {

  public static void main(String[] args) {

    int numX  = 10; // 一次元方向の要素数

    int numY  = 5;  // 二次元方向の要素数

    int count = 0;  // 要素カウント用変数

    // ジェネリクスの型名をList<>にして二次元リストを宣言する    

    List<List<Integer>> list = new ArrayList<>();

    // 二次元目の要素をnumY個生成する

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

      // リスト内にリストを生成していくイメージ

      list.add(new ArrayList<Integer>());

    }

    // 先ほど生成した二次元目に一次元目を追加していく

    for(List<Integer> y : list) {

      // 一次元目の要素をnumX個生成する

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

        y.add(count++); // 要素のデータは順番に1ずつ増やす

      }

    }

    // 二重の拡張forループで二次元リストの全要素を表示する

    for(List<Integer> y : list) {

      for(Integer x : y) {

        System.out.printf(“%2d “, x); // 書式設定で2桁表示にする

      }

      System.out.println(); // 改行する

    }

    System.out.println(); // 改行する

    // 適当な場所の要素を「-1」にする

    // まずgetで二次元目を取得し、次にsetで一次元目のインデックスを値を指定

    // イメージを掴むためにいろいろ変更してみてください

    list.get(1).set(2, -1); // 配列形式ならlist[1][2] = -1

    list.get(2).set(8, -1); // 配列形式ならlist[2][8] = -1

    list.get(3).set(6, -1); // 配列形式ならlist[3][6] = -1

    list.get(4).set(0, -1); // 配列形式ならlist[4][0] = -1

    // 改めてすべての要素を表示する

    for(List<Integer> y : list) {

      for(Integer x : y) {

        System.out.printf(“%2d “, x); // 書式設定で2桁表示にする

      }

      System.out.println(); // 改行する

    }

  }

}

10 11 12 13 14 15 16 17 18 19 

20 21 22 23 24 25 26 27 28 29 

30 31 32 33 34 35 36 37 38 39 

40 41 42 43 44 45 46 47 48 49 

 0  1  2  3  4  5  6  7  8  9 

10 11 -1 13 14 15 16 17 18 19 

20 21 22 23 24 25 26 27 -1 29 

30 31 32 33 34 35 -1 37 38 39 

-1 41 42 43 44 45 46 47 48 49 

import java.util.Arrays; // Arraysの機能を使用する

public class Test {

  public static void main(String[] args) {

    // Integer型Listの生成と初期化を行う

    ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));

    // 最初のリストの中身を表示する

    System.out.println(list);

    // cloneメソッドでリストをディープコピーする

    ArrayList<Integer> copy = (ArrayList<Integer>) list.clone();

    // コピーしたリストの中身を表示する

    System.out.println(copy);

  }

}

[1, 2, 3]