Java Academy · Lektion

Metodreferenser till godtyckliga instanser

Referera till en instansmetod utan att ange mottagaren – detta används ofta med Stream-operationer.

Lektion 3 av 413 steg

Metodreferenser till godtyckliga instanser är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad är referenser till godtyckliga instanser?

En metodreferens till en godtycklig instans använder ClassName::instanceMethod. Här fungerar det första argumentet i det funktionella gränssnittet som mottagare – varje element blir objektet som metoden anropas 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]

Så löses mottagaren

För en referens till en godtycklig instans, Type::method, blir det funktionella gränssnittets första parameter this (mottagaren):

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

Används flitigt med strömoperationer

Referenser till godtyckliga instanser är den vanligaste typen i strömpipelines:

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 två argument

En metod med två argument på en typ motsvarar BiFunction<T, U, R>, där T är mottagaren och U är 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 godtycklig instans

String::compareTo motsvarar Comparator<String> – jämförelseoperatorns två argument blir mottagare och 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]

Godtycklig instans för en egen klass

Det fungerar med instansmetoder i alla klasser, inte bara 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)

Skillnaden mot en specifik instans

Den viktiga skillnaden:

Specifik: obj::method – obj är alltid mottagaren
Godtycklig: Type::method – varje element ÄR mottagaren

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

Metodreferenser i collectors

Referenser till godtyckliga instanser kombineras naturligt med collectors:

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]

Kedja metodreferenser

Metodreferenser kan kedjas 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

Fallgrop: Överlagrade metoder

När en metod är överlagrad måste kompilatorn avgöra vilken överlagring som motsvarar det funktionella gränssnittet. Om det inte går att avgöra blir det ett kompileringsfel – använd en lambda för att undanröja 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

Prestanda

Metodreferenser och lambdauttryck kompileras till samma bytekod (via invokedynamic). Det finns ingen prestandaskillnad – välj det som är mest lättläst. De flesta stilguider föredrar metodreferenser när de uttrycker avsikten tydligt.

Snabb kontroll

Vad representerar String::toUpperCase när den används med .map()?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Metodreferenser till godtyckliga instanser

Viktiga punkter:

Syntax: ClassName::instanceMethod – varje element är mottagaren
Motsvarar funktionella gränssnitt där mottagaren är den första parametern
Vanligast i .map(), .filter(), .sorted() och .forEach()
Metoder med två argument → BiFunction/BiPredicate med elementet som mottagare
Ingen prestandaskillnad jämfört med lambda – välj det som är mest lättläst

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Metodreferenser till godtyckliga instanser” gratis?

Ja – hela texten till ”Metodreferenser till godtyckliga instanser” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Metodreferenser till godtyckliga instanser”?

Referera till en instansmetod utan att ange mottagaren – detta används ofta med Stream-operationer. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Metodreferenser till godtyckliga instanser”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Referenser till statiska metoder
Metodreferenser till en specifik instans
Metodreferenser till godtyckliga instanser
Konstruktorreferenser

← Tillbaka till Java Academy