Java Academy · Pelajaran

Function dan BiFunction

Ubah nilai secara fungsian

Pelajaran 1 daripada 413 langkah

Function dan BiFunction ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Perkara yang Diwakili oleh Function

Function<T, R> ialah antara muka teras untuk transformasi dalam java.util.function. Ia menerima satu argumen jenis T dan mengembalikan hasil jenis R.

Kaedah abstrak tunggalnya ialah R apply(T t).
Ia memodelkan pemetaan tulen daripada masukan kepada keluaran.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        System.out.println(length.apply("hello"));
    }
}

Memanggil apply

Anda memanggil Function dengan memanggil apply. Badan lambda mengandungi logik transformasi.

Jenis masukan dan keluaran boleh berbeza.
Rujukan kaedah seperti String::toUpperCase boleh menggantikan lambda.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> upper = String::toUpperCase;
        System.out.println(upper.apply("java"));
    }
}

Komposisi andThen

andThen merantai fungsi: hasil fungsi pertama menjadi masukan kepada fungsi kedua.

f.andThen(g) bermaksud g(f(x)).
Ia dibaca dari kiri ke kanan.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.andThen(plus3).apply(5));
    }
}

Komposisi compose

compose menjalankan fungsi argumen terlebih dahulu.

f.compose(g) bermaksud f(g(x)).
Ia ialah imej cermin bagi andThen.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.compose(plus3).apply(5));
    }
}

Function.identity

Function.identity() mengembalikan fungsi yang memberikan semula masukannya tanpa perubahan.

Berguna dalam pengumpul strim dan pemetaan lalai.
Setara dengan x -> x.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> id = Function.identity();
        System.out.println(id.apply("unchanged"));
    }
}

Kenali BiFunction

BiFunction<T, U, R> menerima dua argumen dan mengembalikan satu hasil.

Kaedahnya ialah R apply(T t, U u).
Sesuai untuk menggabungkan dua nilai, seperti mencantumkan peta.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(4, 6));
    }
}

BiFunction dengan Jenis Berbeza

Ketiga-tiga parameter jenis BiFunction boleh berbeza.

Di sini, kami menggabungkan satu String dan satu int menjadi satu String.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
        System.out.println(repeat.apply("ab", 3));
    }
}

BiFunction danThen

BiFunction juga menyokong andThen, yang menerima Function satu argumen untuk memproses hasil selepas itu.

BiFunction tidak mempunyai compose kerana operasi itu memerlukan dua masukan.

import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        Function<Integer, String> label = n -> "sum=" + n;
        System.out.println(add.andThen(label).apply(7, 8));
    }
}

Fungsi dalam Koleksi

Banyak antara muka pengaturcaraan menerima Function. Contohnya, Map.computeIfAbsent menerima fungsi pemetaan untuk kunci yang tiada.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> lengths = new HashMap<>();
        lengths.computeIfAbsent("hello", String::length);
        System.out.println(lengths);
    }
}

Menyimpan Fungsi dalam Pemboleh Ubah

Oleh sebab fungsi ialah objek, anda boleh menyimpan, menghantar dan mengembalikannya. Inilah asas Java berasaskan gaya fungsi.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> square = n -> n * n;
        Function<Integer, Integer> cube = n -> n * n * n;
        Function<Integer, Integer> chosen = square;
        System.out.println(chosen.apply(5));
    }
}

Membina Saluran Transformasi

Merantai andThen berulang kali membina saluran transformasi yang mudah dibaca dan boleh digunakan semula.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> trim = String::trim;
        Function<String, String> upper = String::toUpperCase;
        Function<String, Integer> len = String::length;
        System.out.println(trim.andThen(upper).andThen(len).apply("  abc "));
    }
}

Semakan Pantas

Apakah hasil pengiraan f.andThen(g).apply(x)?

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah mempelajari antara muka teras untuk transformasi:

Function<T,R> memetakan satu nilai dengan apply.
andThen merantai ke hadapan (g(f(x))); compose merantai ke belakang (f(g(x))).
Function.identity() mengembalikan masukannya.
BiFunction<T,U,R> mengendalikan dua masukan dan menyokong andThen tetapi bukan compose.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Function dan BiFunction” percuma?

Ya — teks penuh “Function dan BiFunction” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Function dan BiFunction”?

Ubah nilai secara fungsian Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Function dan BiFunction” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy