JavaのストリームAPIは、データの集合に対する操作を簡潔かつ効率的に行うための強力なツールです。従来のループや条件分岐を用いたデータ処理に比べて、ストリームAPIはコードの可読性を大幅に向上させ、複雑なデータ操作を一行で実行することを可能にします。本記事では、JavaストリームAPIを使って、条件に基づくデータ抽出をどのように効率的に行うかを学びます。これにより、データセットから特定の条件を満たす項目を素早く取り出し、必要に応じて加工や分析を行うための方法を理解できるでしょう。さらに、ストリームAPIを活用することで、Javaプログラムのパフォーマンスを最大限に引き出す方法についても詳しく解説します。
ストリームAPIとは何か
JavaのストリームAPIは、Java 8で導入された機能で、コレクションや配列などのデータソースに対する操作を連鎖的に行うことができるAPIです。ストリームは、データの要素を一つずつ処理するための抽象的な視点を提供し、データの操作を宣言的に記述できるため、コードがより直感的で読みやすくなります。
ストリームAPIの利点
ストリームAPIの利点は、以下の通りです。
1. 宣言的プログラミング
ストリームAPIを使用することで、「何をするか」に焦点を当てた宣言的なプログラミングが可能になります。これにより、コードが簡潔で理解しやすくなり、保守性が向上します。
2. 簡潔さと可読性
従来の命令的なアプローチに比べて、ストリームAPIはデータのフィルタリング、マッピング、集約などの操作をチェーンでつなげて記述できるため、コードの行数が減り、可読性が向上します。
3. 並列処理の容易さ
ストリームAPIは並列処理を容易にするための機能を備えており、parallelStream()メソッドを使うことで、データ処理をマルチスレッドで実行し、パフォーマンスを向上させることができます。
ストリームの種類
ストリームにはいくつかの種類があり、データの処理方法に応じて選択することができます。例えば、無限にデータを供給する無限ストリームや、データの順序を保持する順序ストリームなどがあります。それぞれの用途に応じて最適なストリームを使用することが、効率的なデータ処理には重要です。
ストリームAPIの基本的な操作
ストリームAPIを利用すると、データの集合に対してさまざまな操作を簡潔に行うことができます。ここでは、ストリームAPIの基本的な操作であるフィルタリング、マッピング、集約について紹介します。
フィルタリング (Filtering)
フィルタリングとは、特定の条件を満たす要素のみを抽出する操作です。filter()メソッドを使用することで、ストリーム内の要素を条件に基づいて選別できます。例えば、整数のリストから偶数のみを抽出する場合は、以下のように記述します。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());マッピング (Mapping)
マッピングは、ストリーム内の各要素に対して何らかの関数を適用し、新しいストリームを生成する操作です。map()メソッドを使用して、要素を変換できます。例えば、文字列のリストをその長さのリストに変換する場合は以下のようになります。
List<String> words = Arrays.asList("apple", "banana", "cherry");
List<Integer> lengths = words.stream()
.map(String::length)
.collect(Collectors.toList());集約 (Reduction)
集約操作は、ストリーム内の要素をまとめて単一の結果を得るために使用します。reduce()メソッドを使うと、例えば数値の合計や文字列の連結を行うことができます。以下は、整数のリストの合計を計算する例です。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, Integer::sum);結論
ストリームAPIの基本操作をマスターすることで、データ処理のコードがより直感的でシンプルになります。これらの操作を組み合わせることで、複雑なデータ操作も簡単に行えるようになり、コードの可読性と保守性が向上します。
フィルターと条件によるデータ抽出
ストリームAPIの強力な機能の一つに、条件に基づいてデータを選別するフィルタリング操作があります。filter()メソッドを使用することで、特定の条件を満たす要素だけを抽出することが可能です。これにより、データセットから必要な情報だけを効率よく取り出すことができます。
filterメソッドの基本
filter()メソッドは、ストリーム内の要素に対して述語（Booleanを返す関数）を適用し、その条件を満たす要素のみを含む新しいストリームを返します。たとえば、整数のリストから偶数のみを抽出するコードは以下の通りです。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());このコードでは、n % 2 == 0という条件で偶数のみを選別し、結果を新しいリストevenNumbersに収集しています。
複数条件でのフィルタリング
filter()メソッドは複数回連鎖することができるため、複数の条件に基づいたフィルタリングも容易に実行できます。例えば、1から100までの整数のリストから、偶数であり5で割り切れる数を抽出する場合、以下のように記述できます。
List<Integer> numbers = IntStream.rangeClosed(1, 100)
.boxed()
.filter(n -> n % 2 == 0)
.filter(n -> n % 5 == 0)
.collect(Collectors.toList());このように複数のfilter()を連鎖させることで、条件を細かく指定することが可能です。
実用例：名前のフィルタリング
実用的な例として、名前のリストから特定の文字で始まる名前だけを抽出する方法を見てみましょう。以下のコードは、リストから「A」で始まる名前だけを取り出します。
List<String> names = Arrays.asList("Alice", "Bob", "Andrew", "Michael", "Anna");
List<String> filteredNames = names.stream()
.filter(name -> name.startsWith("A"))
.collect(Collectors.toList());結果として、filteredNamesには「Alice」、「Andrew」、「Anna」が含まれることになります。
まとめ
filter()メソッドを使うことで、ストリームAPIは非常に柔軟なデータ抽出手法を提供します。これにより、特定の条件に基づくデータの選別が簡単になり、効率的なデータ処理が可能となります。複数の条件を組み合わせたり、異なるデータ型で操作を行うことで、さらに複雑なデータ処理も容易に行うことができるのがストリームAPIの大きな特徴です。
マップ操作でデータを変換する
ストリームAPIのもう一つの強力な機能として、map()メソッドを使ったデータの変換があります。map()メソッドを使用することで、ストリーム内の各要素に対して特定の操作を適用し、要素を変換した新しいストリームを生成することができます。このメソッドは、データの形式を変更したり、特定のフィールドを抽出する際に非常に便利です。
mapメソッドの基本
map()メソッドは、ストリームの各要素に対して関数を適用し、その結果を含む新しいストリームを返します。たとえば、整数のリストから各要素を2倍にする例を以下に示します。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> doubledNumbers = numbers.stream()
.map(n -> n * 2)
.collect(Collectors.toList());このコードでは、n -> n * 2というラムダ式で各要素を2倍にし、結果を新しいリストdoubledNumbersに収集しています。
オブジェクトのフィールド抽出
map()メソッドは、オブジェクトのリストから特定のフィールドを抽出する際にも使用できます。例えば、ユーザーオブジェクトのリストからすべてのユーザー名を抽出する場合、以下のように記述します。
class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
}
List<User> users = Arrays.asList(
new User("Alice", 30),
new User("Bob", 25),
new User("Charlie", 35)
);
List<String> names = users.stream()
.map(User::getName)
.collect(Collectors.toList());このコードでは、UserオブジェクトのリストからgetName()メソッドを使って各ユーザーの名前を抽出し、新しいリストnamesに収集しています。
データの型変換
map()メソッドを使うことで、データの型を変換することも可能です。例えば、数値のリストを文字列に変換する例を以下に示します。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> stringNumbers = numbers.stream()
.map(String::valueOf)
.collect(Collectors.toList());この例では、String::valueOfメソッドを使って整数を文字列に変換し、stringNumbersという新しいリストに収集しています。
まとめ
map()メソッドを使用することで、ストリームAPIはデータの変換や形式変更を簡単に行う手段を提供します。このメソッドは、リストやセットのようなコレクションから特定のフィールドを抽出したり、データの型を変換する際に非常に有用です。これにより、複雑なデータ操作をシンプルで直感的に行うことが可能になり、開発効率の向上に貢献します。
コレクターによるデータの集約
ストリームAPIのもう一つの重要な機能として、Collectorsクラスを用いたデータの集約があります。Collectorsクラスは、ストリームの結果をリスト、セット、マップなどのコレクションに収集する方法を提供し、データを集約する際に非常に便利です。これにより、データの処理結果を柔軟に操作することが可能になります。
Collectors.toList()によるリストへの集約
Collectors.toList()は、ストリームの要素をリストに収集するために使用されます。例えば、フィルタリング後の整数のストリームをリストに収集するコードは以下のようになります。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());このコードでは、偶数のみを含む新しいリストevenNumbersが生成されます。
Collectors.toSet()によるセットへの集約
Collectors.toSet()を使用すると、ストリームの結果をセットに収集することができます。セットは重複を許さないコレクションであり、一意の要素を保持する場合に役立ちます。
List<String> words = Arrays.asList("apple", "banana", "apple", "cherry");
Set<String> uniqueWords = words.stream()
.collect(Collectors.toSet());この例では、uniqueWordsには"apple", "banana", "cherry"のみが含まれ、重複する"apple"は1つにまとめられます。
Collectors.toMap()によるマップへの集約
Collectors.toMap()は、ストリームの要素をキーと値のペアでマップに収集するために使用します。例えば、ユーザーオブジェクトのリストを名前をキー、年齢を値とするマップに変換する場合、以下のように記述します。
class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
List<User> users = Arrays.asList(
new User("Alice", 30),
new User("Bob", 25),
new User("Charlie", 35)
);
Map<String, Integer> userMap = users.stream()
.collect(Collectors.toMap(User::getName, User::getAge));このコードでは、userMapはユーザーの名前をキーとして、年齢を値とするマップになります。
Collectors.joining()による文字列の連結
文字列を連結して一つの文字列にまとめる場合には、Collectors.joining()が使用できます。このメソッドは、ストリームの要素を一つの文字列として結合します。
List<String> words = Arrays.asList("apple", "banana", "cherry");
String result = words.stream()
.collect(Collectors.joining(", "));このコードは、resultに"apple, banana, cherry"という文字列を生成します。
まとめ
Collectorsクラスを使用することで、ストリームの結果をさまざまな形式に集約することが可能になります。リスト、セット、マップ、さらにはカスタマイズされたデータ形式への集約まで、柔軟な操作が可能です。これにより、データ処理の結果を容易に操作できるため、Javaプログラムの設計と実装がよりシンプルで強力になります。
並列ストリームを使った高速データ処理
ストリームAPIには、データ処理のパフォーマンスを向上させるための機能として並列ストリームが用意されています。並列ストリームを使用することで、データの処理を複数のスレッドで同時に実行し、大量のデータに対する操作を効率的に行うことができます。
並列ストリームの基本
通常のストリーム操作は順次実行されますが、並列ストリームを使用すると、ストリーム内の要素が複数のスレッドで同時に処理されます。並列ストリームを作成するには、parallelStream()メソッドまたは既存のストリームに対してparallel()メソッドを使用します。以下の例は、並列ストリームを使用して数値のリストの合計を計算する方法を示しています。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.parallelStream()
.reduce(0, Integer::sum);このコードでは、parallelStream()メソッドを使用して、数値のリストを並列に処理し、その結果として合計を計算しています。
並列ストリームの利点
並列ストリームの主な利点は、マルチコアプロセッサのパフォーマンスを最大限に活用できる点です。これにより、大量のデータを扱う場合や計算が複雑な処理において、処理速度を大幅に向上させることができます。
1. 自動的な並列処理の最適化
並列ストリームを使用すると、Javaランタイムが自動的にスレッドプールを管理し、最適なスレッド数を決定して並列処理を行います。これにより、開発者は複雑なスレッド管理を行う必要がなくなります。
2. 大規模データセットの処理
並列ストリームは、大規模なデータセットを効率的に処理するために最適化されています。例えば、リスト内の要素をフィルタリングし、特定の条件に基づいてデータを集約するような操作は、並列ストリームを使用することで高速化されます。
並列ストリームの注意点
並列ストリームには利点が多いものの、使用にはいくつかの注意点もあります。
1. 順序が保証されない場合がある
並列処理では、データの順序が保証されないことがあります。順序を重要視する操作（例：ファイルの行の順序を保つなど）には不向きです。順序が必要な場合は、forEachOrdered()などのメソッドを使用することが推奨されます。
2. スレッドセーフでない操作のリスク
並列ストリームでは複数のスレッドが同時にデータにアクセスするため、スレッドセーフでない操作を行うと競合状態が発生する可能性があります。ストリーム内の操作は副作用がないように設計することが重要です。
3. 小規模データには適さない
並列処理にはスレッドの管理やコンテキストスイッチにオーバーヘッドが伴うため、小規模なデータセットの場合は逆に処理が遅くなることがあります。並列ストリームは、大規模データの処理に特化して使用するのが望ましいです。
まとめ
並列ストリームを使用することで、JavaストリームAPIは大規模なデータ処理を効率的に行うための強力な手段となります。並列処理によるパフォーマンス向上の利点を享受しながら、正しい状況で使用し、適切な注意を払うことで、Javaプログラムの効率を最大限に引き出すことができます。
実用例：顧客データの抽出と分析
ストリームAPIは、現実世界の様々なデータ操作にも非常に有効です。ここでは、顧客データのリストから条件に基づいてデータを抽出し、分析する方法を実例を用いて解説します。この実用例を通して、ストリームAPIの強力な機能とその応用可能性を具体的に理解しましょう。
顧客データのセットアップ
まず、顧客データのセットアップを行います。この例では、Customerというクラスを定義し、顧客情報を持つリストを作成します。
class Customer {
private String name;
private int age;
private String city;
private double purchaseAmount;
public Customer(String name, int age, String city, double purchaseAmount) {
this.name = name;
this.age = age;
this.city = city;
this.purchaseAmount = purchaseAmount;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getCity() {
return city;
}
public double getPurchaseAmount() {
return purchaseAmount;
}
}
List<Customer> customers = Arrays.asList(
new Customer("Alice", 28, "New York", 120.5),
new Customer("Bob", 35, "Los Angeles", 75.2),
new Customer("Charlie", 22, "New York", 60.0),
new Customer("David", 30, "San Francisco", 200.0),
new Customer("Eva", 40, "Los Angeles", 300.5)
);このリストには5人の顧客の情報が含まれており、それぞれの顧客は名前、年齢、都市、購入金額を持っています。
条件に基づくデータ抽出
次に、ストリームAPIを使用して特定の条件に基づいてデータを抽出します。ここでは、年齢が30歳以上の顧客を抽出し、その結果を名前のリストとして収集します。
List<String> olderCustomers = customers.stream()
.filter(c -> c.getAge() >= 30)
.map(Customer::getName)
.collect(Collectors.toList());このコードでは、filter()メソッドを使用して年齢が30歳以上の顧客をフィルタリングし、map()メソッドで顧客の名前を抽出して、最終的にcollect(Collectors.toList())で名前のリストを作成しています。
購入金額に基づくデータ分析
さらに、購入金額に基づいてデータを分析することも可能です。例えば、購入金額が100ドル以上の顧客の平均購入金額を計算する場合、次のように行います。
double averagePurchase = customers.stream()
.filter(c -> c.getPurchaseAmount() >= 100)
.mapToDouble(Customer::getPurchaseAmount)
.average()
.orElse(0.0);ここでは、filter()メソッドで購入金額が100ドル以上の顧客を選び、mapToDouble()メソッドを使って購入金額を抽出し、average()メソッドでその平均を計算しています。orElse(0.0)は、平均が計算できない場合のデフォルト値として0.0を返します。
都市ごとの顧客数の集計
さらに、都市ごとの顧客数を集計することもできます。以下のコードは、各都市に何人の顧客がいるかをカウントします。
Map<String, Long> cityCount = customers.stream()
.collect(Collectors.groupingBy(Customer::getCity, Collectors.counting()));groupingBy()メソッドは、都市をキーとして顧客をグループ化し、counting()で各グループの顧客数をカウントします。結果は、都市名をキー、顧客数を値とするマップcityCountになります。
まとめ
この実用例では、顧客データのリストに対してストリームAPIを使用して条件に基づくデータ抽出と分析を行いました。ストリームAPIを用いることで、複雑なデータ操作もシンプルで効率的に行うことが可能になります。これにより、データの可視化や洞察を得るための強力なツールとなり、実際のアプリケーション開発においても非常に有用です。
条件付きデータ抽出の応用
ストリームAPIの魅力の一つは、複雑な条件を組み合わせてデータを抽出することが容易である点です。複数の条件を同時に満たすデータを抽出したり、異なる条件セットを組み合わせてフィルタリングを行うことで、データの操作をより柔軟に行うことができます。ここでは、ストリームAPIを使った複雑な条件でのデータ抽出方法を紹介します。
複数条件の組み合わせ
複数の条件を組み合わせてデータを抽出するには、filter()メソッドを連続して使用するか、条件を組み合わせた述語を作成します。以下は、顧客の年齢が30歳以上で、かつ購入金額が100ドル以上の顧客を抽出する例です。
List<Customer> filteredCustomers = customers.stream()
.filter(c -> c.getAge() >= 30 && c.getPurchaseAmount() >= 100)
.collect(Collectors.toList());このコードでは、filter()メソッド内で&&演算子を使用して、二つの条件（年齢が30歳以上、購入金額が100ドル以上）を組み合わせています。
条件を変数として定義
複数の条件をわかりやすくするために、条件を変数として定義することができます。これにより、条件を再利用したり、動的に条件を変更することが容易になります。
Predicate<Customer> isOlderThan30 = c -> c.getAge() >= 30;
Predicate<Customer> hasHighPurchase = c -> c.getPurchaseAmount() >= 100;
List<Customer> filteredCustomers = customers.stream()
.filter(isOlderThan30.and(hasHighPurchase))
.collect(Collectors.toList());ここでは、Predicateインターフェースを使って条件を定義し、それらをand()メソッドで組み合わせています。この方法により、コードがより読みやすくなり、条件の変更や再利用が簡単になります。
条件によるグルーピングと集計
条件を組み合わせてデータをグループ化し、各グループごとの集計を行うことも可能です。例えば、顧客を年齢ごとのグループに分け、それぞれのグループの平均購入金額を計算する場合、以下のように行います。
Map<String, Double> averagePurchaseByAgeGroup = customers.stream()
.collect(Collectors.groupingBy(
c -> c.getAge() >= 30 ? "30歳以上" : "30歳未満",
Collectors.averagingDouble(Customer::getPurchaseAmount)
));このコードは、顧客の年齢に基づいて二つのグループ（30歳以上、30歳未満）に分け、それぞれのグループの平均購入金額を計算しています。
動的な条件によるフィルタリング
動的に条件を組み立ててデータを抽出することもできます。例えば、ユーザーが指定した条件に基づいてデータをフィルタリングする場合、以下のように条件を動的に設定することができます。
boolean filterByAge = true; // ユーザーの選択に基づいて設定
boolean filterByPurchaseAmount = false; // ユーザーの選択に基づいて設定
Stream<Customer> customerStream = customers.stream();
if (filterByAge) {
customerStream = customerStream.filter(c -> c.getAge() >= 30);
}
if (filterByPurchaseAmount) {
customerStream = customerStream.filter(c -> c.getPurchaseAmount() >= 100);
}
List<Customer> filteredCustomers = customerStream.collect(Collectors.toList());ここでは、filterByAgeやfilterByPurchaseAmountといったフラグを使って、ユーザーの入力に応じた条件でデータをフィルタリングしています。
まとめ
ストリームAPIを使用することで、複雑な条件を組み合わせたデータ抽出が簡単に行えます。条件を組み合わせたり、動的に変更することで、必要に応じた柔軟なデータ操作が可能になります。これにより、データの分析や処理がより効率的で効果的になります。
ストリームAPIのベストプラクティス
JavaのストリームAPIは、データ操作を簡潔に記述できる強力なツールですが、適切に使用しないとパフォーマンス低下やバグの原因になることがあります。ここでは、ストリームAPIを効果的に使用するためのベストプラクティスと、避けるべきアンチパターンについて解説します。
ベストプラクティス
1. 明確で単純なストリーム操作を心がける
ストリーム操作を複雑にしすぎると、コードの可読性が低下し、保守が難しくなります。なるべくシンプルで明確な操作を行うようにしましょう。複雑な操作が必要な場合は、メソッド参照やラムダ式を適切に使用して、コードを分かりやすくすることが重要です。
List<String> names = customers.stream()
.filter(c -> c.getAge() > 30)
.map(Customer::getName)
.collect(Collectors.toList());このように、filter()とmap()を使って簡潔にデータを操作することで、コードの意図が明確になります。
2. 終端操作を必要に応じて使用する
ストリームは基本的に遅延評価されるため、中間操作（filter()やmap()など）は、終端操作（collect()やforEach()など）が呼ばれるまで実行されません。必要なデータ操作がすべて終わった後に終端操作を呼び出すことで、効率的にデータ処理を行うことができます。
3. 並列ストリームの使用に注意する
並列ストリームは大規模データの処理に効果的ですが、すべての場合に最適ではありません。データの順序が重要な場合や、データサイズが小さい場合には、並列ストリームを避けるべきです。また、スレッドセーフでないオペレーションや状態を持つオブジェクトを扱う場合も、並列ストリームの使用は控えるべきです。
4. ストリーム操作を連鎖させて使う
ストリームAPIの利点は、操作を連鎖的に行えることにあります。これにより、コードを簡潔にし、効率的なデータ処理が可能となります。必要に応じて、複数のフィルターやマップ操作を連続で使用することで、データを段階的に変換していきます。
List<String> results = customers.stream()
.filter(c -> c.getAge() > 25)
.filter(c -> c.getPurchaseAmount() > 50)
.map(Customer::getName)
.collect(Collectors.toList());アンチパターン
1. 無駄なストリーム生成を避ける
ストリームは一度限りの操作で使い捨てるのが基本です。同じストリームを複数回使うために再生成するのは効率が悪く、無駄なメモリ使用を引き起こします。必要な操作は一度のストリームで完結させましょう。
2. 中間操作で副作用を持たせない
中間操作（filter(), map()など）で副作用を持つ操作を行うと、バグの原因になります。ストリームAPIは本質的に不変であるべきです。副作用が必要な場合は、終端操作（forEach()など）で行うようにします。
// NG: 中間操作で副作用を持たせる
customers.stream()
.filter(c -> {
System.out.println("Filtering customer: " + c.getName());
return c.getAge() > 30;
})
.collect(Collectors.toList());副作用のある操作は、意図せず多くの要素に適用される可能性があり、予期しない挙動を引き起こします。
3. 過剰な並列処理の使用
並列処理は強力ですが、使い方を誤るとパフォーマンスが低下します。小さなデータセットやI/Oバウンドな操作には不向きです。また、スレッド競合が発生しやすい状況での並列ストリームの使用も避けるべきです。
まとめ
ストリームAPIは強力で便利なツールですが、適切な使用法を守らないと逆効果となることがあります。ベストプラクティスを守りつつ、アンチパターンを避けることで、ストリームAPIを効果的に活用し、コードの品質と効率を高めることができます。正しい使用法を学び、実践することで、より強力で保守しやすいJavaプログラムを作成することが可能になります。
演習問題：ストリームAPIを使ったデータ操作
これまでに学んだストリームAPIの使い方を実践するために、いくつかの演習問題を解いてみましょう。これらの問題を通して、ストリームAPIの基本操作や応用方法を復習し、理解を深めてください。
演習問題1: フィルタリングとマッピング
以下のリストから、価格が100ドル以上の商品名を抽出し、アルファベット順に並べたリストを作成してください。
class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
}
List<Product> products = Arrays.asList(
new Product("Laptop", 999.99),
new Product("Smartphone", 499.99),
new Product("Tablet", 299.99),
new Product("Headphones", 89.99),
new Product("Monitor", 149.99)
);
// 解答例
List<String> productNames = products.stream()
.filter(p -> p.getPrice() >= 100)
.map(Product::getName)
.sorted()
.collect(Collectors.toList());
System.out.println(productNames); // 出力: [Laptop, Monitor, Smartphone, Tablet]演習問題2: 集約と統計
次に、以下の従業員リストから、各部署の平均給与を計算し、部署ごとに表示してください。
class Employee {
private String department;
private double salary;
public Employee(String department, double salary) {
this.department = department;
this.salary = salary;
}
public String getDepartment() {
return department;
}
public double getSalary() {
return salary;
}
}
List<Employee> employees = Arrays.asList(
new Employee("HR", 50000),
new Employee("IT", 75000),
new Employee("HR", 55000),
new Employee("IT", 80000),
new Employee("Sales", 60000)
);
// 解答例
Map<String, Double> averageSalaries = employees.stream()
.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getSalary)));
averageSalaries.forEach((department, avgSalary) -> System.out.println(department + ": " + avgSalary));演習問題3: 並列ストリームの活用
大量の数値データを扱う際に、並列ストリームを使って効率よく合計を計算してください。以下のコードを参考に、並列処理を使用して1から100万までの整数の合計を計算します。
// 解答例
long sum = LongStream.rangeClosed(1, 1_000_000)
.parallel()
.reduce(0, Long::sum);
System.out.println("Sum: " + sum); // 出力: Sum: 500000500000演習問題4: 複数条件でのフィルタリング
以下の顧客リストから、年齢が30歳以上であり、かつ購入金額が50ドル以上の顧客の名前をリストとして取得してください。
class Customer {
private String name;
private int age;
private double purchaseAmount;
public Customer(String name, int age, double purchaseAmount) {
this.name = name;
this.age = age;
this.purchaseAmount = purchaseAmount;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public double getPurchaseAmount() {
return purchaseAmount;
}
}
List<Customer> customers = Arrays.asList(
new Customer("Alice", 28, 150.0),
new Customer("Bob", 35, 40.0),
new Customer("Charlie", 32, 60.0),
new Customer("David", 24, 70.0),
new Customer("Eva", 42, 120.0)
);
// 解答例
List<String> selectedCustomers = customers.stream()
.filter(c -> c.getAge() >= 30 && c.getPurchaseAmount() >= 50)
.map(Customer::getName)
.collect(Collectors.toList());
System.out.println(selectedCustomers); // 出力: [Charlie, Eva]まとめ
これらの演習問題を通じて、ストリームAPIの基本的な使用方法から高度なデータ操作まで、さまざまな機能を実践的に学ぶことができます。実際に手を動かしてコードを書き、ストリームAPIの力を体感してみてください。これにより、Javaプログラミングにおけるデータ処理の効率と効果を最大限に引き出すスキルが身につくでしょう。
まとめ
本記事では、JavaのストリームAPIを使った条件に基づくデータ抽出の方法について解説しました。ストリームAPIの基本的な操作であるフィルタリングやマッピング、集約から始まり、並列ストリームを使った高速データ処理、複数条件によるデータ抽出の応用、さらには実用例を通じて、その実際の使用方法を詳しく学びました。これにより、ストリームAPIを用いたデータ処理の効率化とコードの可読性向上が期待できます。演習問題を通して、習得した知識を実際に試し、理解を深めることができました。ストリームAPIを活用することで、より強力で効率的なJavaプログラムを作成できるようになります。今後の開発において、ぜひこの知識を活用してください。
コメント