0Pricing
Java Academy · Pelajaran

Referensi Metode Instans Arbitrer

Referensikan metode instans tanpa menentukan penerimanya—teknik ini banyak digunakan dalam operasi Stream.

Referensi Metode Instans Arbitrer adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Apa Itu Referensi Instans Sembarang

Referensi metode instans sembarang menggunakan ClassName::instanceMethod. Di sini, argumen pertama antarmuka fungsional berperan sebagai penerima — setiap elemen menjadi objek yang metodenya dipanggil.

import java.util.*;
import java.util.stream.*;

List<String> names = List.of("alice","bob","carol");

// String::toUpperCase — receiver is each list element
List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(upper); // [ALICE, BOB, CAROL]

Bagaimana Penerima Ditentukan

Untuk referensi instans sembarang Type::method, parameter pertama antarmuka fungsional menjadi this (penerima):

// String::length matches Function<String, Integer>
// Equivalent to: s -> s.length()
Function<String, Integer> len = String::length;
System.out.println(len.apply("Java")); // 4

// String::isEmpty matches Predicate<String>
// Equivalent to: s -> s.isEmpty()
Predicate<String> isEmpty = String::isEmpty;
System.out.println(isEmpty.test(""));   // true

Sering Digunakan dalam Operasi Aliran

Referensi instans sembarang adalah jenis yang paling umum dalam alur pemrosesan aliran:

List<String> words = List.of("Hello","","World","","Java");

// filter with String::isEmpty
long empty = words.stream().filter(String::isEmpty).count();
System.out.println(empty); // 2

// map with String::toLowerCase
words.stream()
     .filter(s -> !s.isEmpty())
     .map(String::toLowerCase)
     .forEach(System.out::println);

Gaya BiFunction dengan Metode Dua Argumen

Metode dengan dua argumen pada suatu tipe cocok dengan BiFunction<T, U, R>, dengan T sebagai penerima dan U sebagai argumen:

import java.util.function.*;

// String::startsWith → BiPredicate<String, String>
// receiver=first arg, argument=second arg
BiPredicate<String, String> starts = String::startsWith;
System.out.println(starts.test("JavaStream", "Java")); // true
System.out.println(starts.test("Python", "Java"));      // false

Pembanding dengan Instans Sembarang

String::compareTo cocok dengan Comparator<String> — dua argumen pembanding menjadi penerima dan parameter:

List<String> words = List.of("banana","apple","cherry");

List<String> sorted = words.stream()
    .sorted(String::compareTo)
    .collect(Collectors.toList());
System.out.println(sorted); // [apple, banana, cherry]

Kelas Kustom dengan Instans Sembarang

Ini berfungsi pada metode instans kelas apa pun, bukan hanya tipe JDK:

record Product(String name, double price) {
    boolean isExpensive() { return price > 50; }
    String label() { return name + " ($" + price + ")"; }
}

List<Product> products = List.of(
    new Product("Widget", 9.99),
    new Product("Gadget", 99.99),
    new Product("Donut", 1.50)
);

products.stream()
    .filter(Product::isExpensive)
    .map(Product::label)
    .forEach(System.out::println); // Gadget ($99.99)

Perbedaan dari Instans Tertentu

Perbedaan utamanya:

  • Tertentu: obj::method — obj selalu menjadi penerima
  • Sembarang: Type::method — setiap elemen IS penerima
String fixed = "prefix";
// Specific instance: fixed is always the receiver
Predicate<String> startsFixed = fixed::startsWith; // always checks 'prefix'.startsWith(arg)

// Arbitrary instance: each element is the receiver
Predicate<String> isEmpty = String::isEmpty; // each element.isEmpty()

Referensi Metode dalam Pengumpul

Referensi instans sembarang berpadu secara alami dengan pengumpul:

List<String> items = List.of("  hello "," world ","  java  ");
List<String> trimmed = items.stream()
    .map(String::trim)
    .collect(Collectors.toList());
System.out.println(trimmed); // [hello, world, java]

Merangkai Referensi Metode

Referensi metode dapat dirangkai dengan andThen/compose pada fungsi:

Function<String, String> pipeline =
    ((Function<String, String>) String::trim)
        .andThen(String::toUpperCase);

System.out.println(pipeline.apply("  hello world  "));
// HELLO WORLD

Kendala: Metode dengan Nama Sama

Saat suatu metode memiliki beberapa versi, kompilator harus menentukan versi mana yang cocok dengan antarmuka fungsional. Jika ambigu, terjadi kesalahan kompilasi — gunakan lambda untuk menghilangkan ambiguitas:

// println is overloaded — which one?
// Consumer<String> c = System.out::println; // OK — infers println(String)
// Consumer<Object> c2 = System.out::println; // OK

// But if ambiguous:
// Function<Object,?> fn = System.out::println; // Error — println doesn't return a value

Kinerja

Referensi metode dan lambda dikompilasi menjadi kode byte yang sama (melalui pemanggilan dinamis). Tidak ada perbedaan kinerja — pilih yang lebih mudah dibaca. Sebagian besar panduan gaya merekomendasikan referensi metode jika referensi tersebut menyatakan maksud dengan jelas.

Pemeriksaan Singkat

Apa yang direpresentasikan oleh String::toUpperCase saat digunakan dengan .map()?

Ringkasan: Referensi Metode Instans Sembarang

Pokok-pokok penting:

  • Sintaks: ClassName::instanceMethod — setiap elemen menjadi penerima
  • Cocok dengan antarmuka fungsional yang penerimanya merupakan parameter pertama
  • Paling umum digunakan dalam .map(), .filter(), .sorted(), .forEach()
  • Metode dengan dua argumen → BiFunction/BiPredicate dengan elemen sebagai penerima
  • Tidak ada perbedaan kinerja dibandingkan lambda — pilih berdasarkan keterbacaan

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Referensi Metode Instans Arbitrer” gratis?

Ya — teks lengkap “Referensi Metode Instans Arbitrer” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Referensi Metode Instans Arbitrer”?

Referensikan metode instans tanpa menentukan penerimanya—teknik ini banyak digunakan dalam operasi Stream. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Referensi Metode Instans Arbitrer” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Referensi Metode Statis
  2. Referensi Metode Instans pada Instans Tertentu
  3. Referensi Metode Instans Arbitrer
  4. Referensi Konstruktor
← Kembali ke Java Academy