【Java】関数型インターフェースの基礎｜ラムダ式の活用

この記事では、Javaにおける関数型インターフェースの概念と実践的な使用方法について詳しく解説します。関数型インターフェースとラムダ式を組み合わせることで、Javaプログラミングの表現力と効率が大幅に向上します。

関数型インターフェースとは

関数型インターフェースは、単一の抽象メソッドを持つインターフェースのことです。Java 8でラムダ式が導入されて以来、関数型インターフェースはラムダ式と密接に関連し、Javaプログラミングの中で重要な役割を果たしています。関数型インターフェースは、主にメソッドの簡潔な表現やコードの可読性の向上を目的として使用され、これによりメソッドをインラインで記述できます。

特徴

• 単一の抽象メソッドを持つ
  関数型インターフェースには1つだけの抽象メソッドが定義されます。これにより、そのインターフェースはラムダ式で表現でき、コードを簡潔に記述することが可能です。
• デフォルトメソッドや静的メソッドのサポート
  デフォルトメソッドや静的メソッドは複数持つことができます。デフォルトメソッドにより、インターフェースに新しいメソッドを追加しても、実装クラスに影響を与えずに機能を拡張できます。
• ラムダ式での実装が可能
  関数型インターフェースの抽象メソッドはラムダ式で直接実装可能です。これにより、匿名クラスの記述を簡略化し、コードがさらに読みやすくなります。

使用場面

• コールバック関数やイベント処理
  GUIプログラミングなどでのイベント処理、または非同期処理でのコールバックとして使われます。
• コレクション操作
  Stream API などでのデータ操作に使われます。たとえば、map や filter メソッドの引数としてラムダ式を渡すことで、コレクション操作を直感的に行えます。
• 並列処理
  並列処理のための Runnable インターフェースのように、並列に動作するタスクを簡潔に実装できます。
• 例外処理や条件判定
  条件に基づいた操作や例外処理を実行するための関数型インターフェースとして使用されます。たとえば、Predicate インターフェースで条件判定を簡潔に記述できます。

よく使われる関数型インターフェースの例

• java.lang.Runnable
  並列処理のタスクを記述する際に使用。
• java.util.function.Predicate
  条件を判定し、true / false を返すラムダ式に使用。
• java.util.function.Function
  入力を受け取り、処理をして出力を返すラムダ式に使用。
• java.util.function.Consumer
  入力を受け取り、返り値を持たずに処理を実行するラムダ式に使用。

主要な関数型インターフェース

Java標準ライブラリには、よく使用される関数型インターフェースがいくつか用意されています。以下に主要なものを紹介します。

Runnable

java.lang.Runnable は、並列処理（スレッド）で実行するタスクを記述するための関数型インターフェースです。このインターフェースは、引数や戻り値を持たない run メソッドを定義しています。この特性により、ラムダ式で簡潔に記述することができます。

以下は Runnable を使って、別スレッドでメッセージを出力する例です。

public class RunnableExample {
    public static void main(String[] args) {
        // Runnableのラムダ式による実装
        Runnable task = () -> System.out.println("別スレッドで実行中!");

        // スレッドを作成して、taskを実行
        Thread thread = new Thread(task);
        thread.start(); // 別スレッドで「別スレッドで実行中!」が出力される

        System.out.println("メインスレッドで実行中!");
    }
}

実行結果：

メインスレッドで実行中!
別スレッドで実行中!

（出力順序は、実行のタイミングにより変わる場合があります）

1. Runnable インターフェース
   Runnable は 1つの抽象メソッド run を持つ関数型インターフェースです。このため、Runnable をラムダ式で実装できます。
2. Runnable task = () -> System.out.println("別スレッドで実行中!");
   この行で、ラムダ式を使って Runnable インターフェースを実装しています。ラムダ式 () -> System.out.println("別スレッドで実行中!"); は、run メソッドを実装したものと同じ意味です。引数も戻り値も必要ない処理を短く記述できるのが特徴です。
3. Thread thread = new Thread(task);
Thread クラスのコンストラクタに Runnable インスタンス（task）を渡して、新しいスレッドを作成しています。
4. thread.start();
start メソッドでスレッドを開始し、task 内の処理（この場合、メッセージの出力）を別スレッドで実行します。
5. メインスレッドと別スレッド
   メインスレッドでも System.out.println("メインスレッドで実行中!"); を実行しており、両方の出力が並行して実行されます。スレッドを使用することで、同時に複数の処理を進めることができます。

Predicate

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        Predicate<Integer> isPositive = n -> n > 0;

        System.out.println(isPositive.test(5));  // true
        System.out.println(isPositive.test(-3)); // false
    }
}

実行結果：

true
false

このコードは、Predicateインターフェースを利用して、数値が正であるかどうかを判定する例です。Predicateは条件をテストし、結果をtrueまたはfalseで返す関数型インターフェースです。

1. Predicate<Integer> isPositive = n -> n > 0;
   この行でPredicateのインスタンスisPositiveをラムダ式で定義しています。n -> n > 0の部分は、ラムダ式です。これは「入力された数nが0より大きい場合にtrueを返し、それ以外の場合はfalseを返す」という条件を定義しています。
   • ラムダ式 (n -> n > 0)は、Predicateの唯一の抽象メソッドであるtestメソッドの実装です。
2. System.out.println(isPositive.test(5));
   この行で、isPositive.test(5)を呼び出しています。testメソッドは、5が正であるかどうかを判定し、結果としてtrueを返します。この結果がSystem.out.printlnで出力されるため、画面にはtrueと表示されます。
3. System.out.println(isPositive.test(-3));
   この行では、testメソッドに-3を渡し、数が正でない（つまり負の数）ため、falseを返します。この結果が出力され、画面にはfalseと表示されます。

Consumer

import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        Consumer<String> printUpperCase = s -> System.out.println(s.toUpperCase());

        printUpperCase.accept("hello"); // HELLO
        printUpperCase.accept("world"); // WORLD
    }
}

実行結果：

HELLO
WORLD

このコードは、Consumerインターフェースを使用して、文字列を大文字に変換し、画面に出力する例です。Consumerは引数を受け取って処理を行うが、結果を返さない関数型インターフェースです。

1. Consumer<String> printUpperCase = s -> System.out.println(s.toUpperCase());
   この行で、Consumerインターフェースのインスタンス printUpperCase をラムダ式で定義しています。
   s -> System.out.println(s.toUpperCase()) の部分がラムダ式で、「入力された文字列sを大文字に変換して出力する」という処理を記述しています。
   • ラムダ式 (s -> System.out.println(s.toUpperCase())) は、Consumerインターフェースの唯一の抽象メソッドである acceptメソッド の実装として機能します。
2. printUpperCase.accept("hello");
   この行では、acceptメソッドに"hello"を渡しています。ラムダ式の内容に従い、文字列"hello"を大文字の"HELLO"に変換して出力します。この結果、画面にはHELLOと表示されます。
3. printUpperCase.accept("world");
   同様に、"world"もacceptメソッドによって大文字の"WORLD"に変換され、出力されます。この結果、画面にはWORLDと表示されます。

Function

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        Function<String, Integer> stringLength = s -> s.length();

        System.out.println(stringLength.apply("Java")); // 4
        System.out.println(stringLength.apply("Programming")); // 11
    }
}

実行結果：

4
11

このコードは、Functionインターフェースを使用して、文字列の長さを取得する例です。Functionインターフェースは、入力を受け取り、処理を行った結果を返す関数型インターフェースです。

1. Function<String, Integer> stringLength = s -> s.length();
   この行で、FunctionインターフェースのインスタンスstringLengthをラムダ式で定義しています。s -> s.length()の部分はラムダ式で、「入力された文字列sの長さを返す」という処理を記述しています。
   • ラムダ式 (s -> s.length()) は、Functionインターフェースの唯一の抽象メソッドである applyメソッド の実装として機能します。
2. System.out.println(stringLength.apply("Java"));
   この行では、applyメソッドに"Java"を渡し、文字列の長さを取得しています。“Java”は4文字のため、この呼び出しの結果として4が返り、System.out.printlnで出力されます。
3. System.out.println(stringLength.apply("Programming"));
   同様に、"Programming"の長さもapplyメソッドによって取得されます。“Programming”は11文字のため、この呼び出しの結果として11が返り、出力されます。

Supplier

import java.util.function.Supplier;
import java.util.Random;

public class SupplierExample {
    public static void main(String[] args) {
        Supplier<Integer> randomInt = () -> new Random().nextInt(100);

        System.out.println(randomInt.get()); // ランダムな整数（0-99）
        System.out.println(randomInt.get()); // 別のランダムな整数
    }
}

実行結果：

42
85

実行結果は毎回異なります。get()メソッドが呼ばれるたびに、0から99までのランダムな整数が生成されます。

このコードは、Supplierインターフェースを使用して、ランダムな整数を生成する例です。Supplierインターフェースは、引数を取らずに結果を返す関数型インターフェースです。

1. Supplier<Integer> randomInt = () -> new Random().nextInt(100);
   この行で、SupplierインターフェースのインスタンスrandomIntをラムダ式で定義しています。() -> new Random().nextInt(100)の部分はラムダ式で、「0から99までのランダムな整数を生成して返す」という処理を記述しています。
   • ラムダ式 () -> new Random().nextInt(100)は、Supplierの唯一の抽象メソッドであるgetメソッドの実装として機能します。
2. System.out.println(randomInt.get());
   この行では、getメソッドを呼び出し、ランダムな整数を生成して出力しています。new Random().nextInt(100)は、0から99までの範囲のランダムな整数を生成します。
3. System.out.println(randomInt.get());
   もう一度getメソッドを呼び出して、別のランダムな整数を生成し、出力します。get()メソッドを呼び出すたびに、新しいランダムな整数が生成されるため、毎回異なる結果が得られます。

BiFunction

import java.util.function.BiFunction;

public class BiFunctionExample {
    public static void main(String[] args) {
        BiFunction<String, String, String> concat = (s1, s2) -> s1 + s2;

        System.out.println(concat.apply("Hello, ", "World!")); // Hello, World!
    }
}

実行結果：

Hello, World!

このコードは、BiFunctionインターフェースを使用して、2つの文字列を連結する例です。BiFunctionインターフェースは、2つの引数を受け取り、結果を返す関数型インターフェースです。

1. BiFunction<String, String, String> concat = (s1, s2) -> s1 + s2;
   この行で、BiFunctionインターフェースのインスタンスconcatをラムダ式で定義しています。(s1, s2) -> s1 + s2の部分がラムダ式で、「2つの文字列s1とs2を連結して結果を返す」という処理を記述しています。
   • ラムダ式 (s1, s2) -> s1 + s2は、BiFunctionの唯一の抽象メソッドであるapplyメソッドの実装として機能します。
2. System.out.println(concat.apply("Hello, ", "World!"));
   この行では、applyメソッドに2つの文字列"Hello, "と"World!"を渡し、それらを連結した結果を返しています。この結果として"Hello, World!"が返され、System.out.printlnで出力されます。

UnaryOperator

import java.util.function.UnaryOperator;

public class UnaryOperatorExample {
    public static void main(String[] args) {
        UnaryOperator<Integer> square = n -> n * n;

        System.out.println(square.apply(5)); // 25
        System.out.println(square.apply(3)); // 9
    }
}

実行結果：

25
9

このコードは、UnaryOperatorインターフェースを使用して、整数の二乗を計算する例です。UnaryOperatorは1つの引数を受け取り、それと同じ型の結果を返す関数型インターフェースです。

1. UnaryOperator<Integer> square = n -> n * n;
   この行で、UnaryOperatorインターフェースのインスタンスsquareをラムダ式で定義しています。n -> n * nの部分がラムダ式で、「入力された整数nを二乗して返す」という処理を記述しています。
   • ラムダ式 (n -> n * n) は、UnaryOperatorの唯一の抽象メソッドである applyメソッド の実装として機能します。
2. System.out.println(square.apply(5));
   この行では、applyメソッドに5を渡し、その二乗である25を計算しています。この結果がSystem.out.printlnで出力され、画面には25と表示されます。
3. System.out.println(square.apply(3));
   同様に、applyメソッドに3を渡し、その二乗である9を計算しています。この結果が出力され、画面には9と表示されます。

BinaryOperator

import java.util.function.BinaryOperator;

public class BinaryOperatorExample {
    public static void main(String[] args) {
        BinaryOperator<Integer> max = (a, b) -> a > b ? a : b;

        System.out.println(max.apply(10, 5)); // 10
        System.out.println(max.apply(3, 8));  // 8
    }
}

実行結果：

10
8

このコードは、BinaryOperatorインターフェースを使用して、2つの整数のうち大きい方を返す例です。BinaryOperatorは、2つの引数を受け取り、それと同じ型の結果を返す関数型インターフェースです。

1. BinaryOperator<Integer> max = (a, b) -> a > b ? a : b;
   この行で、BinaryOperatorインターフェースのインスタンスmaxをラムダ式で定義しています。(a, b) -> a > b ? a : bの部分がラムダ式で、「2つの整数aとbを比較し、大きい方を返す」という処理を記述しています。
   • ラムダ式 (a, b) -> a > b ? a : bは、BinaryOperatorの唯一の抽象メソッドであるapplyメソッドの実装として機能します。
2. System.out.println(max.apply(10, 5));
   この行では、applyメソッドに10と5を渡しています。ラムダ式の内容に従い、10と5を比較した結果、10が大きいため10が返され、System.out.printlnで出力されます。
3. System.out.println(max.apply(3, 8));
   同様に、applyメソッドに3と8を渡しています。3と8を比較した結果、8が大きいため8が返され、出力されます。

カスタム関数型インターフェースの作成

独自の関数型インターフェースを作成することもできます。以下は、2つの引数を受け取り、boolean値を返すカスタム関数型インターフェースの例です。

@FunctionalInterface
public interface CustomPredicate<T> {
    boolean test(T t1, T t2);
}

public class CustomPredicateExample {
    public static void main(String[] args) {
        CustomPredicate<String> startsWith = (s, prefix) -> s.startsWith(prefix);

        System.out.println(startsWith.test("Hello", "He")); // true
        System.out.println(startsWith.test("World", "wo")); // false
    }
}

実行結果：

true
false

このコードは、カスタム関数型インターフェース CustomPredicate を定義し、そのインターフェースを使用して文字列が指定された接頭辞で始まるかどうかを判断する例です。

1. @FunctionalInterface アノテーション
   @FunctionalInterfaceは、インターフェースが関数型インターフェースであることを示すためのアノテーションです。このインターフェースは、単一の抽象メソッド test を持っています。
2. public interface CustomPredicate<T>
CustomPredicateインターフェースは、型パラメーターTを持ち、testメソッドを通じて2つの引数（同じ型のT）を受け取り、boolean値を返します。このメソッドは、特定の条件をテストするために使用されます。
3. CustomPredicate<String> startsWith = (s, prefix) -> s.startsWith(prefix);
   この行で、CustomPredicateインターフェースのインスタンスstartsWithをラムダ式で定義しています。ラムダ式は、s（チェックする文字列）とprefix（接頭辞）を受け取り、s.startsWith(prefix)を使用してtrueまたはfalseを返します。
4. System.out.println(startsWith.test("Hello", "He"));
   この行では、testメソッドに"Hello"と"He"を渡しています。"Hello"は"He"で始まるため、trueが返され、出力されます。
5. System.out.println(startsWith.test("World", "wo"));
   同様に、testメソッドに"World"と"wo"を渡しています。"World"は"wo"で始まらないため、falseが返され、出力されます。

まとめ

この記事では、関数型インターフェースの概念から実践的な使用方法まで、段階的に学習することができます。特に、Java 8以降で導入された関数型プログラミングの機能を効果的に活用する方法を理解することで、より簡潔で表現力豊かなコードを書くスキルを身につけることができます。

関数型インターフェースの適切な使用は、コードの可読性向上、再利用性の促進、そしてラムダ式やメソッド参照との組み合わせによる効率的なプログラミングを可能にします。

• 【Java】ラムダ式とは何か？基本構文や使用例を解説
• 【Java】Stream APIとラムダ式｜コレクション操作

【Java】ラムダ式とは何か？基本構文や使用例を解説

この記事では、Javaのラムダ式について、基本的な概念から実践的な使用方法までを学ぶことができます。リストのソートを例にとり、具体的なコード比較を行うことで、ラムダ式の実用的な利点を把握することができます。

www.programming-make-and-learn.tech

2024.10.29

【Java】Stream APIとラムダ式｜コレクション操作

この記事では、Java 8で導入されたStream APIの基本的な特徴、適切な使用場面、ラムダ式を活用した様々なStream操作方法、そして並列処理の方法まで、幅広くカバーしています。特に、filter()、map()、reduce()、collect()などの主要なStream操作について解説しています。

www.programming-make-and-learn.tech

2024.10.29

未経験でもWEBスキルを取得したい方

• Javaコース
  ※Javaプログラミングを基礎から応用まで、体系的に学べる実践的なカリキュラムが特徴です。「マインクラフト」を通じてJavaの基本文法とフレームワークの概念を学びます。また、実際のプロジェクト開発を通じて、データベース連携やWebアプリケーション開発のスキルを身につけることができます。

【デイトラ】未経験でWebスキル習得！SNS発オンラインスクール

今すぐデイトラで学習を始めることで、急速に変化するIT業界での競争力を獲得し、在宅ワーク時代に適したスキルを身につけることができます。さらに、政府支援プログラムとの連携や多様な学習形態の選択肢により、あなたの状況に最適な学習方法を見つけることができます。

www.programming-make-and-learn.tech

2024.09.23