Javaのラムダ式で配列を扱う！Arrays.streamの基本と注意点を初心者向けに解説

1. Arrays.streamとは？

1. Arrays.streamとは？

Arrays.streamは、Javaのjava.util.Arraysクラスに含まれる静的メソッドで、配列に格納されたデータをStream APIで処理できるように変換する役割を持っています。Java 8から導入されたこの機能により、従来のようなfor文やif文を多用する複雑なループ処理を、より直感的で簡潔なコードに書き換えることができます。

大きな特徴は、Listなどのコレクションと異なり、配列には自身をStream化するstream()メソッドが存在しない点です。そのため、配列を扱う際には必ずこのArrays.streamが窓口となります。

例えば、数値の配列から偶数だけを抜き出して合計を計算する処理を見てみましょう。従来の書き方よりも、やりたいこと（意図）が明確に伝わるコードになります。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 数値が入った配列を用意します
        int[] numbers = {1, 2, 3, 4, 5, 6};

        // Arrays.streamを使って、偶数だけを抽出して合計を求める
        int sum = Arrays.stream(numbers)      // 配列をStreamに変換
                        .filter(n -> n % 2 == 0) // 2で割り切れる数（偶数）だけに絞り込む
                        .sum();                  // すべてを足し合わせる

        System.out.println("偶数の合計は: " + sum);
    }
}

このサンプルでは、filterというメソッドの中でラムダ式n -> n % 2 == 0を使用しています。たったこれだけの記述で、複雑な条件分岐を伴うループ処理が完了します。非常にシンプルでスマートな書き方だと思いませんか？

2. 配列とラムダ式の基本的な使い方

2. 配列とラムダ式の基本的な使い方

ラムダ式と配列を組み合わせる最大のメリットは、「各要素に対して何をしたいか」を直感的に記述できる点にあります。プログラミング未経験の方にとって、従来のfor文を使った繰り返し処理は、変数の初期化やカウントアップの記述など、本質的ではない部分でつまずきやすいポイントでした。

しかし、Arrays.streamとラムダ式を使えば、まるで日本語で指示を出すように「配列のデータを流して、加工して、集める」というステップを1行で表現できます。まずは、複数の果物名が入った配列の要素を、すべて大文字に変換するシンプルな例を見てみましょう。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 1. 元となる配列を用意する
        String[] words = {"apple", "banana", "cherry"};

        // 2. 配列をStreamに変換し、ラムダ式で一括処理する
        List<String> upperList = Arrays.stream(words)
                                     .map(s -> s.toUpperCase()) // 各要素(s)を大文字に変換
                                     .collect(Collectors.toList()); // 結果をリストにまとめる

        // 結果を表示
        System.out.println(upperList); // [APPLE, BANANA, CHERRY]
    }
}

このようにmapメソッドを活用することで、配列内の文字列を加工したり、数値に変換したりといった「データの変換処理」が驚くほど簡単に実装できるようになります。コードの行数が減るだけでなく、後から見返したときに何をしているかが一目で分かるのが、モダンなJavaの書き方の特徴です。

3. Arrays.streamとStream.ofの違い

3. Arrays.streamとStream.ofの違い

Javaで配列をStreamに変換しようとすると、Arrays.streamのほかにStream.ofというメソッドも見つかります。どちらを使えばいいか迷うかもしれませんが、初心者が特に注意すべきなのが「int型などのプリミティブ型の配列」を扱うときの違いです。

この違いを具体的なコードで比較してみましょう。例えば、数字の配列を処理しようとした場合、結果が大きく異なります。

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30};

        // Arrays.streamの場合：中身の「10, 20, 30」を1つずつ処理できる
        IntStream correctStream = Arrays.stream(numbers);
        System.out.println("Arrays.streamの要素数: " + correctStream.count()); // 結果は 3

        // Stream.ofの場合：配列という「1つの箱」として処理される
        Stream<int[]> wrongStream = Stream.of(numbers);
        System.out.println("Stream.ofの要素数: " + wrongStream.count()); // 結果は 1
    }
}

プログラミング初心者の方が「配列の要素を1つずつ加工したい、合計を出したい」という目的でコードを書くなら、迷わずArrays.streamを選んでください。Stream.ofを使うと、配列全体が1つの要素として扱われるため、filterやmapといった便利な機能が意図通りに動かなくなってしまいます。

このように、JavaのStream操作では「データの型」と「どのメソッドを使うか」の組み合わせが非常に重要です。まずは「配列ならArrays.stream」という基本をセットで覚えておきましょう。

4. 配列をソートする処理

4. 配列をソートする処理

配列の中身を特定の順番に並び替えたいとき、Arrays.streamとsortedメソッドを組み合わせると、非常にスッキリとした記述が可能になります。従来のJavaでは、配列そのものを直接書き換える方法が一般的でしたが、Streamを使うことで「元の配列はそのままに、新しく並び替えたリストを作る」という、安全で再利用しやすいプログラムが書けます。

例えば、バラバラの順番で並んでいるお名前（文字列）を、五十音順やアルファベット順（昇順）に並び替える方法を見てみましょう。プログラミングの経験がなくても、コードの流れを追うだけで直感的に理解できるはずです。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SortExample {
    public static void main(String[] args) {
        // 1. 並び替え前の配列を用意
        String[] names = {"Yamada", "Suzuki", "Tanaka"};

        // 2. Arrays.streamでデータを流し、sortedで並び替える
        List<String> sortedNames = Arrays.stream(names)
                                         .sorted() // ここで昇順にソート
                                         .collect(Collectors.toList()); // リストにまとめる

        // 結果を表示：[Suzuki, Tanaka, Yamada] の順になります
        System.out.println("並び替え後のリスト: " + sortedNames);
    }
}

このように、複雑なソートのアルゴリズムを自分で一から書く必要はありません。Arrays.streamからsortedへつなぐだけで、誰でも読みやすくメンテナンスしやすいコードを実現できます。実務においても、データの表示順を整える処理は頻繁に登場するため、この書き方を覚えておくと非常に重宝します。

5. 配列のフィルタ処理と集計

5. 配列のフィルタ処理と集計

「大量のデータから特定の条件に合うものだけを選び出したい」という場面は、プログラミングにおいて非常に多く登場します。Arrays.streamとfilter（フィルタ）メソッドを組み合わせれば、複雑なif文を使わずに、まるでフィルターで水を濾すようにデータを抽出できます。

例えば、テストの点数が入った配列から「60点以上の合格者だけ」を取り出す処理を考えてみましょう。未経験の方でも、以下のコードを見れば「どこで条件を指定しているか」がすぐに分かるはずです。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterExample {
    public static void main(String[] args) {
        // 1. テストの点数（数値の配列）を用意
        int[] scores = {45, 72, 88, 53, 67};

        // 2. 60点以上のデータだけを抽出してリストに保存
        List<Integer> passed = Arrays.stream(scores)
                                      .filter(score -> score >= 60) // 60点以上という条件で絞り込む
                                      .boxed()                     // 数値をオブジェクトに変換（箱詰め）
                                      .collect(Collectors.toList()); // リスト形式にまとめる

        // 結果を表示：[72, 88, 67]
        System.out.println("合格者の点数一覧: " + passed);
        
        // おまけ：合格者の人数を数えるのも簡単です
        long count = Arrays.stream(scores).filter(s -> s >= 60).count();
        System.out.println("合格者数: " + count + "人");
    }
}

このように、フィルタ処理と集計（人数を数える、合計を出すなど）をセットで行えるのがStream APIの魅力です。従来の「for文の中でif文を書いて、新しい変数に1つずつ追加する」という手間のかかる作業が、流れるような1つの処理として完結します。

6. nullに注意！Arrays.streamの落とし穴

6. nullに注意！Arrays.streamの落とし穴

Arrays.streamを使いこなせるようになると非常に便利ですが、実務で絶対に気をつけなければならない「落とし穴」があります。それが、処理しようとする配列そのものがnull（空っぽの状態）である可能性です。

もし配列がnullの状態でArrays.stream()を実行してしまうと、JavaではNullPointerExceptionというエラーが発生し、プログラムがその場で止まってしまいます。これを防ぐためには、処理を行う前に「中身がちゃんと存在するか？」を確認するステップが必要です。

import java.util.Arrays;

public class NullCheckExample {
    public static void main(String[] args) {
        // ケース1：配列がnull（データが定義されていない）場合
        String[] data = null;

        // nullのままArrays.stream(data)を使うとエラーになるため、if文でチェックします
        if (data != null) {
            Arrays.stream(data).forEach(System.out::println);
        } else {
            System.out.println("配列がnullなので、処理をスキップしました。");
        }

        // ケース2：配列は存在するが、中身が「空」の場合
        String[] emptyData = {};
        
        // 空配列の場合はArrays.streamを使ってもエラーにはならず、単に何も実行されません
        System.out.println("空配列の処理を開始します（エラーにはなりません）");
        Arrays.stream(emptyData).forEach(System.out::println);
    }
}

最近のJavaでは、Optionalという機能を使ってよりスマートに回避する方法もありますが、まずは基本として「配列を扱うときは、その配列が本当に存在するかを確認する」という意識を持つことが、プログラミング脱初心者の第一歩となります。

7. 配列からの重複排除

7. 配列からの重複排除

配列内の重複を取り除きたい場合も、distinct()を使えばラムダ式で簡単に書けます。

String[] items = {"apple", "banana", "apple", "cherry"};
List<String> unique = Arrays.stream(items)
                            .distinct()
                            .collect(Collectors.toList());

配列からユニークな要素だけを取り出す処理は、データ処理や帳票出力などの実務でもよく使われます。

まとめ

まとめ

Arrays.streamとラムダ式で配列操作を理解する

ここまで、Javaのラムダ式とArrays.streamを使った配列の扱い方について、基礎から注意点まで順を追って確認してきました。従来のfor文を使った配列処理と比べると、Arrays.streamとStream APIを組み合わせることで、配列の操作をとても簡潔かつ直感的に記述できることが分かります。配列をStreamに変換するという考え方は、Javaのモダンな書き方を理解するうえで欠かせない重要なポイントです。

特にArrays.streamは、配列をそのままStreamとして扱えるため、filterやmap、sorted、distinctなどの中間操作を自然に組み合わせることができます。数値配列の集計処理や、文字列配列の変換、条件による抽出など、よくある処理を短いコードで表現できる点は、可読性と保守性の両面で大きなメリットといえるでしょう。Javaで配列処理を行う場面では、Arrays.streamを使う選択肢を常に意識しておくことが大切です。

Stream.ofとの違いとプリミティブ型の注意点

記事の中でも触れたように、Arrays.streamとStream.ofは似ているようで挙動が異なります。特にint配列やdouble配列といったプリミティブ型の配列では、この違いを理解していないと、意図しない処理結果になってしまいます。Stream.ofを使うと配列全体が一つの要素として扱われてしまい、要素ごとの処理ができません。そのため、配列を分解して要素単位で処理したい場合は、Arrays.streamを使う必要があります。

また、プリミティブ型のStreamでは、collectを使ってListに変換する際にboxedが必要になる点も重要です。この仕様を知らないと、なぜListに変換できないのか分からず戸惑ってしまうことがあります。こうした細かな違いを理解することで、Arrays.streamをより安全かつ正確に使いこなせるようになります。

nullチェックと実務での使いどころ

Arrays.streamを使う際に見落としがちなのが、配列がnullの場合の挙動です。空配列であれば問題なくStreamは生成されますが、nullの場合はNullPointerExceptionが発生します。そのため、実務で外部データやユーザー入力を扱う場合には、事前にnullチェックを行う習慣が欠かせません。これはラムダ式やStream APIに限らず、Java全体に共通する基本的な考え方でもあります。

配列のソート、重複排除、条件抽出といった処理は、業務アプリケーションやデータ処理の場面で頻繁に登場します。Arrays.streamを使った書き方に慣れておくことで、コード量を減らしつつ、処理内容が伝わりやすいプログラムを書くことができます。結果として、チーム開発でも理解しやすいコードにつながります。

振り返り用サンプルプログラム

ここで、Arrays.streamとラムダ式のポイントを意識した簡単なサンプルプログラムを見てみましょう。条件抽出と並び替えを組み合わせた例です。

String[] fruits = {"orange", "apple", "banana", "apple"};

if (fruits != null) {
    List<String> result = Arrays.stream(fruits)
                                .distinct()
                                .sorted()
                                .collect(Collectors.toList());
    System.out.println(result);
}

このように、Arrays.streamを使えば、配列に対する一連の処理を流れとして自然に記述できます。どのような順序でデータが加工されているのかも読み取りやすく、Javaの配列操作に対する理解がより深まります。