Apa yang anda perlu tahu tentang antara muka berfungsi dalam Java 8?

Prakata

Java 8 menyediakan banyak antara muka berfungsi, termasuk Fungsi, Pengguna, Pembekal, Predikat dan sebagainya. Kesemuanya terletak di bawah pakej java.util.function.

Mengapa anda perlu mengetahui antara muka berfungsi ini

Oleh kerana 4 antara muka berfungsi ini ialah antara muka penting baharu dalam Java 8, Pada masa yang sama , ciri Strim baharu Java 8 juga menggunakan antara muka ini , jadi mempelajarinya boleh membantu kami memahami aliran Strim dengan lebih baik.

Oleh kerana ini ialah antara muka berfungsi, anda boleh menggunakan ungkapan Lambda untuk menulis logik pelaksanaan antara muka. Dan dalam proses pembelajaran, anda boleh lebih memahami idea pengaturcaraan berfungsi.

Antara muka fungsi

Penjelasan

Perkataan Fungsi bermaksud "fungsi", sama seperti y = f(x) dalam matematik, ia menerima parameter x, Selepas beroperasi melalui fungsi f, hasil y dikembalikan. Antara muka

Function mengandungi empat kaedah:

• apply(T t): Ini ialah kaedah utama antara muka Function, yang menerima parameter dan mengembalikan a hasil. Pada masa yang sama, ia juga merupakan satu-satunya kaedah abstrak, dan selebihnya mempunyai pelaksanaan lalai (kaedah abstrak antara muka dalam Java 8 menyokong pelaksanaan lalai).

• andThen(Function after): Fungsinya adalah untuk menggabungkan dua Function. Mula-mula laksanakan fungsi semasa, kemudian laksanakan fungsi andThen, dan hantar hasil fungsi semasa sebagai parameter kepada fungsi andThen.

• compose(Function before): Dengan cara yang sama, menggabungkan dua Function akan melaksanakan fungsi compose dahulu, kemudian melaksanakan fungsi semasa dan menggunakan hasil daripada compose fungsi sebagai parameter yang dihantar ke fungsi semasa.

• identity(): Mengembalikan fungsi yang melakukan penukaran identiti, iaitu mengembalikan parameter input itu sendiri.

Antara muka fungsi biasanya digunakan untuk menukar nilai satu jenis kepada nilai jenis lain.

gunakan kaedah

// Function 接口的泛型，第一个参数是入参类型，第二个参数是出参类型
// Function 接口只有一个抽象方法，就是 apply()，下面利用 Lambda 表达式实现这个抽象方法并创建 Function 对象
Function<Integer, String> function = num -> "GTA" + num;
// 将5这个参数传递给function，得到返回结果
String result = function.apply(5);
System.out.println(result); // 打印：GTA5

danKemudian dan karang kaedah

// 定义两个 Function 对象进行相关转换操作
Function<String, String> upperCase = s -> s.toUpperCase();
Function<String, String> addPostfix = s -> s + "5";
// 链式调用，将 gta 这个字符串参数先传递 upperCase 这个函数进行操作，然后将得到的结果传递给 addPostfix 函数进行操作，得到返回结果
String str = upperCase.andThen(addPostfix).apply("gta");
System.out.println(str); // 打印：GTA5

mengenal pasti kaedah

identity kaedah mengembalikan fungsi yang melakukan penukaran identiti, yang akan Memasukkan parameter dikembalikan tidak berubah. Contohnya:

Function<String, String> identity = Function.identity();
String result = identity.apply("hello"); // result is "hello"

Antara muka pengguna

Penjelasan

Pengguna bermaksud "pengguna" menggunakan parameter input dan tidak mengembalikan hasilnya untuk anda.

Antara muka pengguna mengandungi dua kaedah:

• accept(T t): Kaedah ini menerima parameter dan melaksanakan beberapa operasi.

• andThen(Consumer after): Dengan cara yang sama, gabungkan dua Pengguna dan gunakan mereka satu demi satu.

kaedah terima

Antara muka pengguna biasanya digunakan untuk menggunakan parameter dan kemudian melakukan beberapa operasi. Contohnya:

// Consumer 接口，泛型参数是入参类型，接受一个参数，并不返回结果，相当于消费了这个参数
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("我输入什么就打印什么"); // 打印：我输入什么就打印什么

andThen kaedah

menggabungkan dua Pengguna:

Consumer<String> first = s -> System.out.println(s + 5);
Consumer<String> second = s -> System.out.println(s + 6);
// 先执行 first 这个 Consumer，接着执行 second 这个 Consumer
Consumer<String> combination = first.andThen(second);
combination.accept("GTA"); // 打印：GTA5 GTA6

Antara muka pembekal

Antara muka pembekal hanya mentakrifkan satu get() kaedah, kaedah mana yang Menerima tiada parameter dan mengembalikan hasil.

Perkataan Pembekal bermaksud "pembekal". Ia memberi saya perasaan bahawa ia adalah pengeluar, tanpa parameter, ia secara langsung menghasilkan sesuatu untuk anda.

Antara muka pembekal biasanya digunakan untuk menjana nilai. Contohnya:

// Supplier 接口，泛型参数是出参类型，不接受参数，但是会提供结果，相当于生产了某个东西
Supplier<String> supplier = () -> "提供一个我随便打的字符串给调用方";
String text = supplier.get();
System.out.println(text); // 打印：提供一个我随便打的字符串给调用方

Antara muka predikat

Penerangan

Predikat Perkataan bermaksud "nubuatan, ramalan, predikat, predikat", yang digunakan untuk ramalan dan pertimbangan. Antara muka

Predicate mengandungi empat kaedah:

• test(T t): Kaedah ini menerima satu parameter dan mengembalikan Nilai Boolean.

• and(Predicate other): Digabungkan dengan Predikat lain untuk melaksanakan operasi logik dan .

• negate(): Digabungkan dengan Predikat lain untuk melaksanakan operasi logik BUKAN .

• or(Predicate other): Digabungkan dengan Predikat lain untuk melaksanakan operasi logik atau .

kaedah ujian

Antara muka Predikat biasanya digunakan untuk menguji sama ada keadaan adalah benar. Contohnya:

// Predicate 接口，泛型参数是入参类型，返回布尔值
Predicate<String> predicate = s -> s.contains("god23bin");
boolean flag = predicate.test("god23bin能给你带来收获吗？");
System.out.println("god23bin能给你带来收获吗？" + flag); // 打印：god23bin能给你带来收获吗？true

dan kaedah

Untuk kemudahan demonstrasi, dua Predikat disediakan di sini:

Predicate<String> startsWithA = (str) -> str.startsWith("A"); // 如果传入的字符串是A开头，则返回 true
Predicate<String> endsWithZ = (str) -> str.endsWith("Z"); // 如果传入的字符串是Z结尾，则返回 true

digabungkan menggunakan dan, dan operasi dan ialah:

Predicate<String> startsWithAAndEndsWithZ = startsWithA.and(endsWithZ);
System.out.println(startsWithAAndEndsWithZ.test("ABCDEFZ")); // true
System.out.println(startsWithAAndEndsWithZ.test("BCDEFGH")); // false

negate method

Guna negate untuk menggabungkan, Bukan operasi:

Predicate<String> notStartsWithA = startsWithA.negate();
System.out.println(notStartsWithA.test("ABCDEF")); // false
System.out.println(notStartsWithA.test("BCDEFGH")); // true

atau kaedah

Gunakan atau untuk menggabungkan, Atau Operasi:

Predicate<String> startsWithAOrEndsWithZ = startsWithA.or(endsWithZ);
System.out.println(startsWithAOrEndsWithZ.test("ABCDEF")); // true
System.out.println(startsWithAOrEndsWithZ.test("BCDEFGH")); // false

Apakah aplikasi antara muka ini

Antara muka berfungsi ini digunakan dalam strim Strim. Sudah tentu, apabila anda mempunyai keperluan yang sama, anda juga boleh menggunakan antara muka ini sendiri. Mari kita bincangkan tentang aplikasi dalam aliran Strim.

Function 接口：例如 map 方法，map 方法就是将一个类型的值转换为另一个类型的值。

// map 方法，将 T 类型的值转换成 R 类型的值
// R 是返回的 Stream 流的元素类型，T 是原先 Stream 流的元素类型
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

Consumer 接口：例如 forEach 方法

// forEach 方法，遍历 Stream 流中的元素，T 类型是 Stream 流的元素类型
void forEach(Consumer<? super T> action);

Supplier 接口：例如 generate 方法

// 生成一个无限长度的 Stream 流
public static<T> Stream<T> generate(Supplier<T> s) {
    Objects.requireNonNull(s);
    return StreamSupport.stream(
        new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
}

Predicate 接口：例如 filter 方法，使用 Predicate 进行过滤操作。

// 过滤出 Stream 流中，判断结果为 true 的元素
Stream<T> filter(Predicate<? super T> predicate);

Atas ialah kandungan terperinci Apa yang anda perlu tahu tentang antara muka berfungsi dalam Java 8?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!