Javaのコレクションフレームワークを使ったリストの分割と結合方法を徹底解説

Javaのコレクションフレームワークは、データ構造を扱うための強力なツールを提供します。その中でもリストは、データの順序付けや重複を許容するため、多くの場面で利用される基本的なコレクションです。しかし、実際のアプリケーション開発では、単にリストを使うだけでなく、リストを効率的に分割したり、複数のリストを結合したりする必要が出てきます。これらの操作は、大量のデータを管理する際や特定の条件でデータを処理する際に非常に役立ちます。本記事では、Javaでのリストの分割と結合の方法について、基本的な概念から実際の使用例までを詳しく解説し、効率的なデータ操作のためのテクニックを習得できるようにします。

リストの基本的な操作方法

Javaのリストは、コレクションフレームワークの一部として提供されるインターフェースであり、要素の順序を保持することができます。ArrayListやLinkedListといった実装クラスを使うことで、さまざまなリスト操作を行うことが可能です。基本的な操作には、要素の追加（add）、削除（remove）、更新（set）、および検索（get）が含まれます。これらのメソッドを使いこなすことで、リスト内のデータを動的に変更し、アプリケーションの要求に応じて柔軟に対応することができます。以下のコード例では、これらの基本操作の使い方を説明します。

リストの作成と要素の追加

リストの作成には、一般的にArrayListやLinkedListを使用します。これらのクラスは、Listインターフェースを実装しており、以下のように要素を追加することができます。

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

要素の取得と更新

リスト内の特定の位置にある要素を取得するには、getメソッドを使用し、要素を更新するにはsetメソッドを使用します。

String firstFruit = fruits.get(0); // "Apple"を取得
fruits.set(1, "Grapes"); // "Banana"を"Grapes"に更新

要素の削除

リストから要素を削除するには、removeメソッドを使用します。このメソッドは、削除された要素を返します。

fruits.remove("Orange"); // "Orange"を削除

これらの基本操作を理解することは、リストを効率的に操作し、データを柔軟に管理するための第一歩です。次のセクションでは、これらの基本操作を基にしてリストを分割する方法について詳しく見ていきます。

リストの分割方法とは

リストの分割とは、元のリストを複数の部分リストに分ける操作を指します。この操作は、大規模なデータセットを扱う際にデータを小さなチャンクに分けて処理する場合や、特定の条件に基づいてリストを複数のグループに分けたい場合に非常に有用です。Javaのコレクションフレームワークでは、さまざまな方法でリストを分割することができます。

手動によるリストの分割

最も基本的なリストの分割方法は、ループを使用して手動でリストを分割することです。例えば、指定したサイズの部分リストに分割する場合、以下のような方法を使用できます。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int partitionSize = 3;
List<List<Integer>> partitions = new ArrayList<>();

for (int i = 0; i < numbers.size(); i += partitionSize) {
    partitions.add(numbers.subList(i, Math.min(i + partitionSize, numbers.size())));
}

このコードでは、元のリストを3つの要素ごとに分割し、新しいリストpartitionsに格納しています。

条件に基づくリストの分割

リストを条件に基づいて分割する場合もあります。例えば、偶数と奇数でリストを分けたい場合、以下のようにします。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> evenNumbers = new ArrayList<>();
List<Integer> oddNumbers = new ArrayList<>();

for (Integer number : numbers) {
    if (number % 2 == 0) {
        evenNumbers.add(number);
    } else {
        oddNumbers.add(number);
    }
}

このコードでは、numbersリストを走査し、偶数の要素はevenNumbersリストに、奇数の要素はoddNumbersリストに追加しています。

分割の利点と注意点

リストを分割することで、データを並列処理したり、特定の条件に基づいてデータを処理したりする際の柔軟性が向上します。しかし、分割によってリストのメモリ使用量が増える可能性があるため、大量のデータを扱う際には注意が必要です。次のセクションでは、Javaのコレクションフレームワークで提供されるツールを使って、より効率的にリストを分割する方法を紹介します。

Javaのコレクションフレームワークの概要

Javaのコレクションフレームワークは、データの管理と操作を簡単かつ効率的に行うためのクラスとインターフェースのセットです。このフレームワークは、リスト、セット、マップなどのデータ構造を提供し、これらを通じてデータの格納、検索、操作を行うことができます。特にリストは、順序を保持し、重複する要素を許容するため、動的なデータの管理に適しています。

コレクションフレームワークの主要インターフェース

Javaのコレクションフレームワークには、以下の主要なインターフェースがあります：

• List: 順序付きの要素のコレクションで、重複を許容します。ArrayListやLinkedListが代表的な実装クラスです。
• Set: ユニークな要素のコレクションで、順序を持たないことが一般的です。HashSetやTreeSetがその例です。
• Map: キーと値のペアで構成されるコレクションです。HashMapやTreeMapなどのクラスが実装しています。

リストに関連するクラスとその使い方

リストを操作するために、Javaでは主にArrayListとLinkedListが使用されます。

• ArrayList: 動的配列を基にしたリストで、要素へのランダムアクセスが高速です。リストのサイズ変更が頻繁に行われない場合に適しています。
• LinkedList: 双方向リンクリストを基にしたリストで、要素の追加や削除が高速です。特にリストの途中での挿入や削除が頻繁に行われる場合に適しています。

これらのクラスを使うことで、リストの操作（追加、削除、検索、更新）が効率的に行えるようになります。また、Collectionsユーティリティクラスには、リストをソートしたり、逆順にしたりするための便利なメソッドも多数用意されています。

リスト操作における注意点

リストを操作する際には、特に以下の点に注意が必要です：

• スレッドセーフ: ArrayListやLinkedListはスレッドセーフではないため、マルチスレッド環境で使用する場合は適切な同期が必要です。
• メモリ使用量: 大規模なリストを扱う際は、メモリ使用量に注意し、必要に応じてArrayListの初期容量を指定するなどの最適化が求められます。

次のセクションでは、subListメソッドを使用して、リストの一部を効率的に抽出する方法について詳しく解説します。

`subList`メソッドによるリストの部分抽出

subListメソッドは、JavaのListインターフェースが提供するメソッドで、元のリストの一部を抜き出して新しいビューを作成するのに非常に便利です。このメソッドを使うことで、リストの一部分だけを操作したい場合に効率的に部分リストを作成できます。

`subList`メソッドの使い方

subListメソッドは、開始インデックス（inclusive）と終了インデックス（exclusive）を指定して、指定した範囲の要素を含む部分リストを返します。以下は、subListメソッドを使用した簡単な例です。

List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve"));
List<String> subNames = names.subList(1, 4); // インデックス1から3までの要素を取得
System.out.println(subNames); // 出力: [Bob, Charlie, David]

この例では、元のnamesリストからインデックス1から3までの要素を抜き出し、新しい部分リストsubNamesを作成しています。

ビューとしての部分リスト

subListメソッドで作成される部分リストは、元のリストのビューです。そのため、部分リストで行った変更は元のリストにも反映されます。この点は、リストを操作する際の重要な特徴となります。

subNames.set(1, "Catherine"); // 部分リストの要素を変更
System.out.println(names); // 出力: [Alice, Bob, Catherine, David, Eve]

この例では、subNamesでの変更がnamesにも影響を与えていることが分かります。

`subList`メソッドの利点と注意点

subListメソッドを使うことで、メモリの効率を保ちながら部分的なデータ操作が可能になります。しかし、いくつか注意すべき点があります。

• 親リストの変更に注意: 部分リストの作成後に親リストが変更されると、ConcurrentModificationExceptionが発生する可能性があります。親リストに対する構造的変更（例：addやremoveメソッドの使用）は避けるべきです。
• メモリの最適化: 部分リストは元のリストへの参照を保持するため、元のリストが大きい場合でも部分リストのメモリ使用量は増加しません。

次のセクションでは、Java 8以降で導入されたストリームAPIを使って、さらに効率的にリストを分割する方法を見ていきます。

ストリームAPIを使ったリストの分割

Java 8で導入されたストリームAPIは、リストを含むコレクションの操作を簡潔で効率的に行うための強力なツールです。ストリームAPIを使うと、リストを条件に基づいて動的に分割するなどの高度な操作を、簡潔なコードで実装できます。特に、大規模なデータセットに対して並列処理を行いたい場合や、条件に基づいたデータのフィルタリングを行いたい場合に便利です。

ストリームを使ったリストの条件による分割

ストリームAPIを使うと、リストの要素を条件に基づいて簡単に分割することができます。例えば、偶数の要素と奇数の要素でリストを分割したい場合、以下のようにストリームAPIを使用します。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

Map<Boolean, List<Integer>> partitioned = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

List<Integer> evenNumbers = partitioned.get(true);
List<Integer> oddNumbers = partitioned.get(false);

System.out.println("偶数: " + evenNumbers); // 出力: 偶数: [2, 4, 6, 8, 10]
System.out.println("奇数: " + oddNumbers); // 出力: 奇数: [1, 3, 5, 7, 9]

このコードでは、partitioningByメソッドを使用して、リストを偶数と奇数で分けています。このように、ストリームAPIを使うと、条件に基づいてリストを分割する操作が非常に簡単に実装できます。

特定のサイズごとのリスト分割

ストリームAPIでは、リストを特定のサイズごとに分割することも可能です。この場合、Collectors.groupingByとインデックスを利用して、リストをチャンクに分けることができます。

int chunkSize = 3;
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<List<Integer>> partitioned = new ArrayList<>(numbers.stream()
    .collect(Collectors.groupingBy(i -> (i - 1) / chunkSize))
    .values());

System.out.println(partitioned); // 出力: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

ここでは、リストのインデックスを使ってchunkSizeごとにリストを分割しています。ストリームAPIの柔軟性により、さまざまな条件でリストを簡単に分割することができます。

ストリームAPIの利点と注意点

ストリームAPIを使うことで、リスト操作をより宣言的かつ効率的に行うことができます。これにより、コードの可読性が向上し、バグの少ないプログラムを実装できます。しかし、以下の点に注意が必要です：

• 性能: ストリームAPIは多くの場合効率的ですが、特に大規模なデータセットを扱う際は、内部のオーバーヘッドに注意が必要です。性能が問題となる場合は、parallelStream()を使用して並列処理を検討してください。
• スレッドセーフ: 並列処理を行う場合、リスト操作がスレッドセーフであることを確認する必要があります。特に、共有されるリストに対する変更は慎重に行うべきです。

次のセクションでは、リストを結合する方法について解説し、データの統合を効率的に行うためのテクニックを紹介します。

リストの結合方法とは

リストの結合とは、複数のリストを一つのリストにまとめる操作を指します。この操作は、異なるデータソースから取得したデータを一つにまとめたり、関連する情報を統合する際に非常に役立ちます。Javaのコレクションフレームワークには、リストを結合するためのさまざまな方法が用意されています。これらの方法を使い分けることで、データ操作を効率的に行うことができます。

手動によるリストの結合

最も基本的なリストの結合方法は、addAllメソッドを使用して手動でリストを結合することです。例えば、二つのリストを結合するには、以下のようにします。

List<String> list1 = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));
List<String> list2 = new ArrayList<>(Arrays.asList("Date", "Fig", "Grape"));

list1.addAll(list2);

System.out.println(list1); // 出力: [Apple, Banana, Cherry, Date, Fig, Grape]

このコードでは、list2のすべての要素がlist1に追加され、結果として一つのリストに結合されています。

Java 8のストリームAPIを使ったリストの結合

Java 8以降、ストリームAPIを使ってリストを簡潔に結合することができます。Stream.concatメソッドを使用すると、複数のリストを一つのストリームとして結合し、それをリストに変換することができます。

List<String> list1 = Arrays.asList("Apple", "Banana", "Cherry");
List<String> list2 = Arrays.asList("Date", "Fig", "Grape");

List<String> combinedList = Stream.concat(list1.stream(), list2.stream())
    .collect(Collectors.toList());

System.out.println(combinedList); // 出力: [Apple, Banana, Cherry, Date, Fig, Grape]

この例では、Stream.concatを使用して二つのリストを結合し、それをCollectors.toList()でリストに変換しています。ストリームAPIを使用することで、コードがより直感的かつ読みやすくなります。

特定の条件でリストを結合する

ストリームAPIを使用すると、リストを結合する際に特定の条件を適用することもできます。例えば、文字列の長さに基づいてリストを結合する場合、以下のようにします。

List<String> list1 = Arrays.asList("Apple", "Banana", "Cherry");
List<String> list2 = Arrays.asList("Date", "Fig", "Grape");

List<String> filteredCombinedList = Stream.concat(list1.stream(), list2.stream())
    .filter(s -> s.length() > 4)
    .collect(Collectors.toList());

System.out.println(filteredCombinedList); // 出力: [Apple, Banana, Cherry, Grape]

このコードでは、結合されたリストから長さが4より大きい文字列のみをフィルタリングしています。ストリームAPIの強力なフィルタリング機能を使うことで、結合時に特定の条件を簡単に適用できます。

リスト結合の利点と注意点

リストの結合操作は、データの統合や処理の一貫性を保つために非常に重要です。しかし、リストの結合にはいくつかの注意点があります：

• メモリ使用量の増加: 複数のリストを結合すると、結果として得られるリストのメモリ使用量が増加します。大規模なデータを結合する場合は、メモリ効率に注意が必要です。
• スレッドセーフではない場合: リスト結合操作がスレッドセーフでない場合、マルチスレッド環境での使用は競合状態を引き起こす可能性があります。必要に応じて同期化を検討してください。

次のセクションでは、具体的なリスト結合の方法としてaddAllメソッドの使用方法について詳しく解説します。

`addAll`メソッドによるリストの結合

addAllメソッドは、Javaのコレクションフレームワークにおいて、あるリストに別のリストのすべての要素を追加するために使用される強力なメソッドです。このメソッドを使うことで、簡単に複数のリストを一つのリストに結合することができます。特に、シンプルで効率的なリスト結合が求められる場面で非常に有用です。

`addAll`メソッドの基本的な使い方

addAllメソッドは、結合先のリストに結合元のリストの全要素を順番に追加します。以下に、addAllメソッドを使った基本的なリスト結合の例を示します。

List<String> list1 = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));
List<String> list2 = new ArrayList<>(Arrays.asList("Date", "Fig", "Grape"));

// list1にlist2のすべての要素を追加
list1.addAll(list2);

System.out.println(list1); // 出力: [Apple, Banana, Cherry, Date, Fig, Grape]

このコードでは、list1にlist2の全要素が追加され、list1が結合された結果を保持しています。

特定の位置に要素を追加する

addAllメソッドには、要素を追加する位置を指定するオーバーロードされたバージョンもあります。これを使用することで、リストの特定の位置に別のリストの要素を挿入することができます。

List<String> list1 = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));
List<String> list2 = new ArrayList<>(Arrays.asList("Date", "Fig", "Grape"));

// list1のインデックス1の位置にlist2のすべての要素を追加
list1.addAll(1, list2);

System.out.println(list1); // 出力: [Apple, Date, Fig, Grape, Banana, Cherry]

この例では、list1のインデックス1の位置にlist2の要素が挿入されています。このように、リストの結合は非常に柔軟に行うことができます。

結合後のリストの重複除去

addAllメソッドを使用してリストを結合すると、重複する要素が含まれることがあります。この場合、HashSetを使用して重複を除去し、リストに戻すことができます。

List<String> list1 = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry", "Apple"));
List<String> list2 = new ArrayList<>(Arrays.asList("Date", "Fig", "Grape", "Apple"));

list1.addAll(list2);

// 重複を除去
List<String> uniqueList = new ArrayList<>(new HashSet<>(list1));

System.out.println(uniqueList); // 出力例: [Banana, Date, Cherry, Fig, Apple, Grape]

このコードでは、HashSetを使用してlist1の重複要素を除去し、uniqueListに重複のないリストを保持しています。

`addAll`メソッド使用時の注意点

addAllメソッドを使用する際には、いくつかの注意点があります：

• パフォーマンスの考慮: リストが非常に大きい場合、addAllメソッドは時間がかかることがあります。大規模なデータセットを操作する際は、パフォーマンスに注意が必要です。
• スレッドセーフでない: addAllメソッドはスレッドセーフではありません。マルチスレッド環境で使用する場合は、適切な同期化が必要です。

次のセクションでは、ストリームAPIを使用してリストを結合する方法をさらに詳しく見ていきます。これにより、コードをより簡潔にし、条件付きでリストを結合することが可能になります。

ストリームAPIを使ったリストの結合

Java 8以降では、ストリームAPIを使用してリストを結合することで、コードをより簡潔に書くことができます。Stream.concatメソッドやその他のストリーム操作を活用すると、複数のリストを効率的に結合し、条件に基づいた要素の選択や処理も容易になります。ストリームAPIは、リストの結合を行う際の柔軟性とパフォーマンスを提供します。

`Stream.concat`メソッドによるリストの結合

Stream.concatメソッドは、二つのストリームを結合して新しいストリームを作成するために使用されます。これにより、複数のリストを一つのリストに簡単に結合できます。

List<String> list1 = Arrays.asList("Apple", "Banana", "Cherry");
List<String> list2 = Arrays.asList("Date", "Fig", "Grape");

// ストリームを使用してリストを結合
List<String> combinedList = Stream.concat(list1.stream(), list2.stream())
    .collect(Collectors.toList());

System.out.println(combinedList); // 出力: [Apple, Banana, Cherry, Date, Fig, Grape]

この例では、Stream.concatメソッドを使用してlist1とlist2を結合し、最終的に新しいcombinedListとして一つのリストにまとめています。

条件に基づいたリストの結合

ストリームAPIを使用すると、リストを結合する際に特定の条件を適用することも可能です。例えば、文字列の長さに基づいてリストを結合し、その条件を満たす要素のみを選択する場合、以下のようにストリームAPIを使用します。

List<String> list1 = Arrays.asList("Apple", "Banana", "Cherry");
List<String> list2 = Arrays.asList("Date", "Fig", "Grape");

// 条件に基づいてリストを結合し、特定の条件を満たす要素のみを選択
List<String> filteredCombinedList = Stream.concat(list1.stream(), list2.stream())
    .filter(s -> s.length() > 4) // 文字列の長さが4より大きい要素のみを選択
    .collect(Collectors.toList());

System.out.println(filteredCombinedList); // 出力: [Apple, Banana, Cherry, Grape]

このコードでは、Stream.concatメソッドとfilterメソッドを組み合わせて、特定の条件（文字列の長さが4より大きい）を満たす要素のみをリストに含めています。

複数のリストを効率的に結合する

ストリームAPIを使うと、複数のリストを効率的に結合することもできます。例えば、リストのリストを一つのリストにフラット化するには、flatMapメソッドを使用します。

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("Apple", "Banana"),
    Arrays.asList("Cherry", "Date"),
    Arrays.asList("Fig", "Grape")
);

// リストのリストを一つのリストにフラット化して結合
List<String> flattenedList = listOfLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());

System.out.println(flattenedList); // 出力: [Apple, Banana, Cherry, Date, Fig, Grape]

この例では、flatMapメソッドを使って複数のリストを一つのストリームに変換し、そのストリームをリストに収集しています。

ストリームAPIを使った結合の利点と注意点

ストリームAPIを使ったリストの結合には、いくつかの利点があります：

• コードの簡潔性: ストリームAPIを使用すると、リストの結合がより簡潔で直感的になります。
• パフォーマンスの向上: 並列ストリーム（parallelStream()）を使用することで、大規模なリストをより高速に結合することが可能です。
• 柔軟なフィルタリングとマッピング: ストリームAPIを使うことで、結合する際に条件を柔軟に適用できるため、データ処理が容易になります。

しかし、ストリームAPIを使用する際には以下の点にも注意が必要です：

• メモリ使用量: 結合操作が大規模なデータセットで行われる場合、メモリ使用量が増加する可能性があります。
• スレッドセーフ: 並列ストリームを使用する場合、リスト操作がスレッドセーフであることを確認してください。

次のセクションでは、リストの分割と結合を実際のシナリオでどのように活用できるかを説明する応用例を紹介します。

応用例：リスト分割と結合の実用シナリオ

リストの分割と結合は、データの管理や処理を効率化するために多くの実用的なシナリオで使用されます。これらの操作は、特にデータの一部を並列処理したり、異なるデータソースを統合したりする際に役立ちます。ここでは、リストの分割と結合を活用する具体的なシナリオについて紹介します。

シナリオ1：大規模データの並列処理

大量のデータを扱う場合、リストを分割して複数のスレッドで並列に処理することがパフォーマンスの向上に繋がります。例えば、Webサイトのログデータを解析する際に、ログを日時で分割し、各部分を別々のスレッドで処理することで、処理時間を短縮できます。

List<String> logData = ...; // 大量のログデータ
int partitionSize = logData.size() / 4; // 4つの部分に分割

List<List<String>> partitions = new ArrayList<>();
for (int i = 0; i < logData.size(); i += partitionSize) {
    partitions.add(logData.subList(i, Math.min(i + partitionSize, logData.size())));
}

// 各部分を並列処理
partitions.parallelStream().forEach(partition -> {
    processLogs(partition); // 各部分の処理を行うメソッド
});

この例では、ログデータを4つの部分に分割し、それぞれを並列ストリームを使って同時に処理しています。これにより、大量のデータを効率よく処理することができます。

シナリオ2：異なるデータソースの統合

複数の異なるデータソースから取得した情報を一つのリストに統合することは、データ分析やレポート生成の際に必要になることがあります。例えば、複数のAPIから取得した製品情報を統合して、ユーザーに一括で表示する場合などです。

List<Product> apiData1 = fetchProductsFromApi1(); // API1からのデータ取得
List<Product> apiData2 = fetchProductsFromApi2(); // API2からのデータ取得

// 各リストを結合して一つのリストに統合
List<Product> allProducts = Stream.concat(apiData1.stream(), apiData2.stream())
    .collect(Collectors.toList());

System.out.println(allProducts); // 統合された製品情報のリストを表示

このコードでは、Stream.concatを使用して2つの異なるAPIから取得した製品データを一つのリストに結合しています。これにより、ユーザーに対して統合されたデータを提供することができます。

シナリオ3：データのバッチ処理と再結合

データをバッチごとに処理し、処理結果を一つにまとめることも一般的なシナリオです。例えば、大量の顧客データをバッチに分割して処理し、結果を最終的に一つのリストにまとめる場合などです。

List<Customer> allCustomers = getAllCustomers(); // 全顧客データを取得
int batchSize = 100;
List<List<Customer>> batches = new ArrayList<>();

for (int i = 0; i < allCustomers.size(); i += batchSize) {
    batches.add(allCustomers.subList(i, Math.min(i + batchSize, allCustomers.size())));
}

List<ProcessedCustomer> processedCustomers = batches.stream()
    .flatMap(batch -> processBatch(batch).stream()) // 各バッチを処理
    .collect(Collectors.toList());

System.out.println(processedCustomers); // 処理された全顧客データを表示

この例では、全ての顧客データをバッチに分割し、各バッチを処理した後、結果を再度結合しています。この方法により、大量データの処理を効率的に行いながら、最終的な結果を一つにまとめることができます。

まとめ

これらのシナリオは、リストの分割と結合がさまざまなデータ操作においてどれほど強力であるかを示しています。効率的なデータ処理のために、リスト操作を柔軟に使いこなすことが重要です。次のセクションでは、学習を深めるための練習問題を提供します。

練習問題：リストの分割と結合

リストの分割と結合に関する理解を深めるために、いくつかの練習問題を用意しました。これらの問題を解くことで、実際のコーディングに役立つスキルを身につけることができます。

練習問題1: リストの分割

以下の文字列のリストを、文字列の長さが偶数のものと奇数のものに分割してください。

List<String> words = Arrays.asList("Java", "Python", "C++", "JavaScript", "Ruby", "Swift");

条件:

• wordsリストを分割し、文字列の長さが偶数のものをevenLengthWordsリストに、奇数のものをoddLengthWordsリストに格納してください。

解答例:

List<String> evenLengthWords = new ArrayList<>();
List<String> oddLengthWords = new ArrayList<>();

for (String word : words) {
    if (word.length() % 2 == 0) {
        evenLengthWords.add(word);
    } else {
        oddLengthWords.add(word);
    }
}

System.out.println("偶数長の文字列: " + evenLengthWords); // 出力: [Java, C++, Ruby]
System.out.println("奇数長の文字列: " + oddLengthWords); // 出力: [Python, JavaScript, Swift]

練習問題2: 特定のサイズでリストを分割

以下の整数のリストを指定されたサイズごとに分割し、各部分をリストのリストとして返すメソッドを実装してください。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int partitionSize = 4;

条件:

• リストnumbersをpartitionSize（この場合は4）ごとに分割し、部分リストを格納したリストを返すメソッドpartitionListを実装してください。

解答例:

public static List<List<Integer>> partitionList(List<Integer> list, int size) {
    List<List<Integer>> partitions = new ArrayList<>();
    for (int i = 0; i < list.size(); i += size) {
        partitions.add(new ArrayList<>(list.subList(i, Math.min(i + size, list.size()))));
    }
    return partitions;
}

List<List<Integer>> partitionedNumbers = partitionList(numbers, partitionSize);
System.out.println(partitionedNumbers); // 出力: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]

練習問題3: リストの結合とフィルタリング

以下の2つのリストを結合し、結合したリストから重複する要素を削除した結果を返すメソッドを実装してください。

List<String> fruits1 = Arrays.asList("Apple", "Banana", "Cherry");
List<String> fruits2 = Arrays.asList("Banana", "Date", "Fig", "Apple");

条件:

• fruits1とfruits2を結合し、重複を除去した結果を返すメソッドmergeAndRemoveDuplicatesを実装してください。

解答例:

public static List<String> mergeAndRemoveDuplicates(List<String> list1, List<String> list2) {
    return Stream.concat(list1.stream(), list2.stream())
                 .distinct()
                 .collect(Collectors.toList());
}

List<String> uniqueFruits = mergeAndRemoveDuplicates(fruits1, fruits2);
System.out.println(uniqueFruits); // 出力: [Apple, Banana, Cherry, Date, Fig]

まとめ

これらの練習問題を通じて、リストの分割と結合に関する技術を実践的に学ぶことができます。問題を解きながらコードを書き、自分の理解を深めていきましょう。次のセクションでは、本記事の内容をまとめます。

まとめ

本記事では、Javaのコレクションフレームワークを使用したリストの分割と結合の方法について詳しく解説しました。リストの基本的な操作から始まり、subListメソッドやストリームAPIを活用した分割・結合の手法、さらに実際のアプリケーションにおける応用例や練習問題を通じて、リスト操作の重要性とその実践的な使用方法を学びました。適切なリストの分割と結合は、効率的なデータ管理と処理を実現するために不可欠です。これらの技術を習得することで、Javaでのデータ操作がより効果的かつ柔軟に行えるようになります。今後も実践を重ね、これらのスキルを活用していきましょう。