Stream

Java – Streamで2つのコレクションを結合する方法

2025-04-15更新日: 2025-04-15

JavaのStreamを使用して2つのコレクションを結合するには、Stream.concat()メソッドを利用します。

このメソッドは、2つのストリームを結合し、1つの連結ストリームを生成します。

結合後のストリームは、collect(Collectors.toList())などを使ってリストや他のコレクションに変換できます。

元のコレクションは変更されません。

目次から探す

Javaを使った求人

読み込み中…

Stream.concat()を使ったコレクションの結合

JavaのStream APIを使うと、コレクションを簡単に結合することができます。

その中でも、Stream.concat()メソッドは特に便利です。

このメソッドを使うことで、2つのストリームを結合し、新しいストリームを作成することができます。

基本的な使い方

Stream.concat()の基本的な使い方はとてもシンプルです。

以下のように、2つのストリームを引数として渡すだけで結合できます。

List<String> list1 = Arrays.asList("A", "B", "C");
List<String> list2 = Arrays.asList("D", "E", "F");
Stream<String> combinedStream = Stream.concat(list1.stream(), list2.stream());
combinedStream.forEach(System.out::println);

このコードでは、list1とlist2の2つのリストをストリームに変換し、Stream.concat()で結合しています。

最終的に、結合されたストリームの要素を出力しています。

結合するコレクションの種類

Stream.concat()は、さまざまなコレクションに対して使用できます。

以下のようなコレクションが対象です。

コレクションの種類	例
List	`ArrayList`, `LinkedList`
Set	`HashSet`, `TreeSet`
配列	`String[]`, `int[]`

これらのコレクションをストリームに変換し、Stream.concat()を使って結合することができます。

結合後のストリームの特性

結合されたストリームは、元のストリームの特性を引き継ぎます。

たとえば、元のストリームが重複を許可しないSetから作成された場合、結合後のストリームも重複を許可しません。

注意点

Stream.concat()は、結合するストリームが空であっても問題なく動作します。

空のストリームが結合されると、結果は空のストリームになります。

結合後のストリームは、一度しか操作できません。

再利用したい場合は、再度ストリームを作成する必要があります。

このように、Stream.concat()を使うことで、簡単に2つのコレクションを結合することができます。

次のセクションでは、他のコレクション結合方法について見ていきましょう。

その他のコレクション結合方法

Javaでは、Stream.concat()以外にもコレクションを結合する方法がいくつかあります。

それぞれの方法には特徴があり、用途に応じて使い分けることができます。

ここでは、代表的な結合方法をいくつか紹介します。

addAll()メソッドを使った結合

Collectionインターフェースを実装しているクラスでは、addAll()メソッドを使って他のコレクションの要素を追加することができます。

以下はその例です。

List<String> list1 = new ArrayList<>(Arrays.asList("A", "B", "C"));
List<String> list2 = Arrays.asList("D", "E", "F");
list1.addAll(list2);
System.out.println(list1);

このコードでは、list1にlist2の要素を追加しています。

結果として、list1にはすべての要素が含まれます。

Stream.of()を使った結合

複数のコレクションを一度に結合したい場合、Stream.of()を使うこともできます。

以下のように、複数のコレクションを引数として渡すことができます。

List<String> list1 = Arrays.asList("A", "B", "C");
List<String> list2 = Arrays.asList("D", "E", "F");
Stream<String> combinedStream = Stream.of(list1, list2)
                                      .flatMap(Collection::stream);
combinedStream.forEach(System.out::println);

この方法では、flatMap()を使って、2つのリストを1つのストリームに変換しています。

Collectors.toList()を使った結合

ストリームを使ってコレクションを結合し、最終的にリストとして取得したい場合は、Collectors.toList()を使うことができます。

List<String> list1 = Arrays.asList("A", "B", "C");
List<String> list2 = Arrays.asList("D", "E", "F");
List<String> combinedList = Stream.concat(list1.stream(), list2.stream())
                                  .collect(Collectors.toList());
System.out.println(combinedList);

このコードでは、Stream.concat()で結合したストリームをリストに変換しています。

Setを使った結合

重複を許可しないコレクションが必要な場合、Setを使って結合することもできます。

以下のように、HashSetを使って結合する例です。

Set<String> set1 = new HashSet<>(Arrays.asList("A", "B", "C"));
Set<String> set2 = new HashSet<>(Arrays.asList("B", "C", "D"));
Set<String> combinedSet = new HashSet<>(set1);
combinedSet.addAll(set2);
System.out.println(combinedSet);

この場合、combinedSetには重複がない状態で要素が追加されます。

これらの方法を使うことで、Javaでのコレクションの結合がより柔軟に行えます。

用途に応じて適切な方法を選ぶことで、効率的にコレクションを扱うことができるでしょう。

次のセクションでは、結合後のコレクションの操作について見ていきます。

結合後のコレクションの操作

コレクションを結合した後は、その結果を使ってさまざまな操作を行うことができます。

ここでは、結合後のコレクションに対してよく行われる操作をいくつか紹介します。

フィルタリング

結合したコレクションから特定の条件に合う要素だけを抽出するには、filter()メソッドを使います。

以下の例では、結合したリストから特定の文字で始まる要素をフィルタリングしています。

List<String> list1 = Arrays.asList("Apple", "Banana", "Cherry");
List<String> list2 = Arrays.asList("Avocado", "Blueberry", "Coconut");
List<String> combinedList = Stream.concat(list1.stream(), list2.stream())
                                  .filter(s -> s.startsWith("A"))
                                  .collect(Collectors.toList());
System.out.println(combinedList); // [Apple, Avocado]

このコードでは、”A”で始まる要素だけが抽出されています。

マッピング

結合後のコレクションの要素を別の形式に変換するには、map()メソッドを使用します。

以下の例では、結合したリストの要素を大文字に変換しています。

List<String> combinedList = Stream.concat(list1.stream(), list2.stream())
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());
System.out.println(combinedList); // [APPLE, BANANA, CHERRY, AVOCADO, BLUEBERRY, COCONUT]

このように、map()を使うことで要素の変換が簡単に行えます。

ソート

結合したコレクションをソートするには、sorted()メソッドを使います。

以下の例では、結合したリストをアルファベット順にソートしています。

List<String> sortedList = Stream.concat(list1.stream(), list2.stream())
                                 .sorted()
                                 .collect(Collectors.toList());
System.out.println(sortedList); // [Apple, Avocado, Banana, Blueberry, Cherry, Coconut]

このコードでは、結合したリストがアルファベット順に並べ替えられています。

集計

結合したコレクションの要素数を数えたり、合計を計算したりすることもできます。

以下の例では、結合したリストの要素数をカウントしています。

long count = Stream.concat(list1.stream(), list2.stream())
                   .count();
System.out.println(count); // 6

このように、count()メソッドを使うことで、簡単に要素数を取得できます。

重複の削除

結合したコレクションから重複を取り除くには、distinct()メソッドを使います。

以下の例では、重複を排除したリストを作成しています。

List<String> listWithDuplicates = Arrays.asList("A", "B", "C", "A", "B");
List<String> distinctList = listWithDuplicates.stream()
                                              .distinct()
                                              .collect(Collectors.toList());
System.out.println(distinctList); // [A, B, C]

このように、distinct()を使うことで、重複を簡単に取り除くことができます。

結合後のコレクションに対しては、フィルタリング、マッピング、ソート、集計、重複の削除など、さまざまな操作が可能です。

これらの操作を組み合わせることで、より複雑なデータ処理が行えるようになります。

次のセクションでは、注意点とベストプラクティスについて見ていきましょう。

注意点とベストプラクティス

Javaでコレクションを結合する際には、いくつかの注意点やベストプラクティスがあります。

これらを理解しておくことで、より効率的でエラーの少ないコードを書くことができます。

ストリームの再利用に注意

ストリームは一度しか操作できないため、結合したストリームを再利用することはできません。

再度使用したい場合は、新たにストリームを作成する必要があります。

以下のように、ストリームを再利用しようとするとエラーが発生します。

Stream<String> stream = Stream.of("A", "B", "C");
stream.forEach(System.out::println); // 初回の操作は成功
// stream.forEach(System.out::println); // ここでエラーが発生

このようなエラーを避けるために、ストリームを必要な操作ごとに新たに作成することを心がけましょう。

大きなコレクションの結合に注意

大きなコレクションを結合する場合、メモリ使用量やパフォーマンスに影響を与えることがあります。

特に、Stream.concat()を使うと、結合されたストリームが一時的にメモリに保持されるため、注意が必要です。

必要に応じて、ストリームを分割して処理することを検討しましょう。

並列処理の活用

大きなデータセットを扱う場合、ストリームの並列処理を活用することができます。

parallelStream()を使うことで、複数のスレッドで処理を行い、パフォーマンスを向上させることができます。

List<String> list1 = Arrays.asList("A", "B", "C");
List<String> list2 = Arrays.asList("D", "E", "F");
List<String> combinedList = Stream.concat(list1.parallelStream(), list2.parallelStream())
                                  .collect(Collectors.toList());

ただし、並列処理はスレッドの管理が複雑になるため、適切な状況でのみ使用するようにしましょう。

コレクションの特性を理解する

結合するコレクションの特性を理解しておくことが重要です。

たとえば、Setを使うと重複が自動的に排除されますが、Listを使うと重複が許可されます。

結合後のコレクションの特性を考慮して、適切なコレクションを選択しましょう。

エラーハンドリング

コレクションの結合や操作中にエラーが発生する可能性があります。

特に、外部データソースからのデータを扱う場合は、エラーハンドリングを適切に行うことが重要です。

例外処理を用いて、エラーが発生した際の挙動を明確にしておきましょう。

コードの可読性を保つ

複雑なストリーム操作を行う場合、コードの可読性が低下することがあります。

適切な変数名を使用し、必要に応じてメソッドを分割することで、コードを読みやすく保つことが大切です。

また、コメントを追加することで、他の開発者が理解しやすくなります。

これらの注意点とベストプラクティスを意識することで、Javaでのコレクションの結合や操作がよりスムーズに行えるようになります。

次のセクションでは、実践的な応用例について見ていきましょう。

実践的な応用例

Javaのコレクション結合機能は、さまざまな実践的なシナリオで活用できます。

ここでは、具体的な応用例をいくつか紹介します。

ユーザー情報の統合

異なるデータソースから取得したユーザー情報を統合する場合、コレクションの結合が役立ちます。

たとえば、2つの異なるリストからユーザー名を結合し、重複を排除して一意のユーザー名リストを作成することができます。

List<String> usersFromSource1 = Arrays.asList("Alice", "Bob", "Charlie");
List<String> usersFromSource2 = Arrays.asList("Bob", "David", "Eve");
List<String> uniqueUsers = Stream.concat(usersFromSource1.stream(), usersFromSource2.stream())
                                 .distinct()
                                 .collect(Collectors.toList());
System.out.println(uniqueUsers); // [Alice, Bob, Charlie, David, Eve]

この例では、distinct()メソッドを使って重複を排除しています。

商品リストの統合

異なる店舗からの商品リストを統合する場合も、コレクションの結合が便利です。

以下の例では、2つの店舗からの商品のリストを結合し、価格を比較することができます。

class Product {
    String name;
    double price;
    Product(String name, double price) {
        this.name = name;
        this.price = price;
    }
    @Override
    public String toString() {
        return name + ": $" + price;
    }
}
List<Product> store1Products = Arrays.asList(new Product("Apple", 1.0), new Product("Banana", 0.5));
List<Product> store2Products = Arrays.asList(new Product("Banana", 0.4), new Product("Cherry", 1.5));
List<Product> allProducts = Stream.concat(store1Products.stream(), store2Products.stream())
                                  .collect(Collectors.toList());
allProducts.forEach(System.out::println);

このコードでは、2つの店舗からの商品リストを結合し、すべての商品を出力しています。

データ分析

データ分析のシナリオでは、異なるデータセットを結合して分析を行うことがよくあります。

たとえば、売上データと顧客データを結合して、特定の顧客の売上を分析することができます。

class Sale {
    String customerName;
    double amount;
    Sale(String customerName, double amount) {
        this.customerName = customerName;
        this.amount = amount;
    }
}
List<Sale> salesData = Arrays.asList(new Sale("Alice", 100.0), new Sale("Bob", 150.0));
List<Sale> additionalSalesData = Arrays.asList(new Sale("Alice", 200.0), new Sale("Charlie", 300.0));
List<Sale> allSales = Stream.concat(salesData.stream(), additionalSalesData.stream())
                            .collect(Collectors.toList());
Map<String, Double> totalSalesByCustomer = allSales.stream()
    .collect(Collectors.groupingBy(sale -> sale.customerName, 
                                   Collectors.summingDouble(sale -> sale.amount)));
totalSalesByCustomer.forEach((customer, total) -> 
    System.out.println(customer + ": $" + total));

この例では、顧客ごとの売上を集計し、結果を出力しています。

フィルタリングと集計の組み合わせ

結合したコレクションに対してフィルタリングと集計を組み合わせることで、特定の条件に合うデータを効率的に分析できます。

以下の例では、特定の価格以上の商品をフィルタリングし、その合計を計算しています。

double thresholdPrice = 1.0;
double totalAboveThreshold = allProducts.stream()
    .filter(product -> product.price > thresholdPrice)
    .mapToDouble(product -> product.price)
    .sum();
System.out.println("Total price of products above $" + thresholdPrice + ": $" + totalAboveThreshold);

このコードでは、指定した価格以上の商品をフィルタリングし、その合計金額を計算しています。

これらの実践的な応用例を通じて、Javaのコレクション結合機能がどのように役立つかを理解できたかと思います。

さまざまなシナリオで活用することで、データ処理や分析がより効率的に行えるようになります。

コレクションの結合を活用して、あなたのプロジェクトに役立ててみてください。