Java Academy · leksjon

Metodereferanser til vilkårlige instanser

Referer til en instansmetode uten å angi mottakeren – dette brukes ofte med Stream-operasjoner.

Leksjon 3 av 413 trinn

Metodereferanser til vilkårlige instanser er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva er metodereferanser til vilkårlige instanser?

En metodereferanse til en vilkårlig instans bruker ClassName::instanceMethod. Her fungerer det første argumentet til det funksjonelle grensesnittet som mottaker – hvert element blir objektet metoden kalles på.

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]

Slik bestemmes mottakeren

For en metodereferanse til en vilkårlig instans, Type::method, blir det første parameteret i det funksjonelle grensesnittet til this (mottakeren):

// 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

Brukes mye med strømoperasjoner

Metodereferanser til vilkårlige instanser er den vanligste typen i strømforløp:

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);

BiFunction-stil med metoder med to argumenter

En metode med to argumenter på en type samsvarer med BiFunction<T, U, R>, der T er mottakeren og U er argumentet:

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

Comparator med vilkårlig instans

String::compareTo samsvarer med Comparator<String> – komparatorens to argumenter blir henholdsvis mottaker og 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]

Vilkårlig instans for egendefinert klasse

Dette fungerer med instansmetoder i alle klasser, ikke bare JDK-typer:

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)

Forskjellen fra spesifikk instans

Den viktigste forskjellen:

Spesifikk: obj::method – obj er alltid mottakeren
Vilkårlig: Type::method – hvert element ER mottakeren

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()

Metodereferanser i samlere

Metodereferanser til vilkårlige instanser kombineres naturlig med samlere:

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]

Kjeding av metodereferanser

Metodereferanser kan kjedes med andThen/compose på Function:

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

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

Fallgruve: Overbelastede metoder

Når en metode er overbelastet, må kompilatoren utlede hvilken overbelastning som samsvarer med det funksjonelle grensesnittet. Hvis valget er tvetydig, oppstår en kompileringsfeil – bruk en lambda for å fjerne tvetydigheten:

// 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

Ytelse

Metodereferanser og lambdaer kompileres til samme bytekode (via invokedynamic). Det er ingen ytelsesforskjell – velg det som er mest lesbart. De fleste stilguider foretrekker metodereferanser når de uttrykker hensikten tydelig.

Hurtigsjekk

Hva representerer String::toUpperCase når det brukes med .map()?

Besvar den i den interaktive leksjonen

Oppsummering: Metodereferanser til vilkårlige instanser

Viktigste punkter:

Syntaks: ClassName::instanceMethod – hvert element er mottakeren
Samsvarer med funksjonelle grensesnitt der mottakeren er det første parameteret
Vanligst i .map(), .filter(), .sorted() og .forEach()
Metoder med to argumenter → BiFunction/BiPredicate med elementet som mottaker
Ingen ytelsesforskjell sammenlignet med lambda – velg ut fra lesbarhet

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Metodereferanser til vilkårlige instanser» gratis?

Ja – hele teksten i «Metodereferanser til vilkårlige instanser» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Metodereferanser til vilkårlige instanser»?

Referer til en instansmetode uten å angi mottakeren – dette brukes ofte med Stream-operasjoner. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Metodereferanser til vilkårlige instanser»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Referanser til statiske metoder
Metodereferanser til instansmetoder på en bestemt instans
Metodereferanser til vilkårlige instanser
Konstruktørreferanser

← Tilbake til Java Academy