Java Academy · Oppitunti

Mielivaltaisen instanssin metodiviittaukset

Viittaa instanssimetodiin määrittämättä vastaanottajaa – tätä käytetään paljon Stream-operaatioissa.

Oppitunti 3/413 vaihetta

Mielivaltaisen instanssin metodiviittaukset on ilmainen Java Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Java Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Java Academy-kurssilla on yhteensä 4 oppituntia.

Mitä ovat mielivaltaisen instanssin viitteet?

Mielivaltaisen instanssin metodiviite käyttää muotoa ClassName::instanceMethod. Tässä funktionaalisen rajapinnan ensimmäinen argumentti toimii vastaanottajana — kustakin alkiosta tulee olio, jonka päällä metodi kutsutaan.

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]

Miten vastaanottaja määritetään

Mielivaltaisen instanssin viitteessä Type::method funktionaalisen rajapinnan ensimmäisestä parametrista tulee this (vastaanottaja):

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

Käytetään paljon Stream-operaatioissa

Mielivaltaisen instanssin viitteet ovat yleisin viitetyyppi stream-putkissa:

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-tyyli kaksiparametrisilla metodeilla

Tyypin kaksiparametrinen metodi vastaa muotoa BiFunction<T, U, R>, jossa T on vastaanottaja ja U argumentti:

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 ja mielivaltainen instanssi

String::compareTo vastaa muotoa Comparator<String> — vertailijan kaksi argumenttia ovat vastaanottaja ja parametri:

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]

Mielivaltainen instanssi omassa luokassa

Toimii minkä tahansa luokan instanssimetodeilla, ei ainoastaan JDK-tyypeillä:

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)

Ero tietyn instanssin viitteeseen

Keskeinen ero:

Tietty: obj::method — obj on aina vastaanottaja
Mielivaltainen: Type::method — kukin alkio ON vastaanottaja

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

Metodiviitteet kerääjissä

Mielivaltaisen instanssin viitteet sopivat luontevasti yhteen kerääjien kanssa:

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]

Metodiviitteiden ketjuttaminen

Metodiviitteitä voi ketjuttaa Function-rajapinnan andThen- ja compose-metodeilla:

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

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

Kompastuskivi: ylikuormitetut metodit

Kun metodi on ylikuormitettu, kääntäjän on pääteltävä, mikä ylikuormitettu versio vastaa funktionaalista rajapintaa. Jos valinta on epäselvä, kyseessä on käännösvirhe — käytä lambdaa epäselvyyden poistamiseen:

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

Suorituskyky

Metodiviitteet ja lambdat käännetään samaksi tavukoodiksi (invokedynamic-mekanismin kautta). Suorituskyvyssä ei ole eroa — valitse se, joka on luettavampi. Useimmat tyyliohjeet suosittelevat metodiviitteitä, kun ne ilmaisevat tarkoituksen selkeästi.

Pikatarkistus

Mitä String::toUpperCase edustaa, kun sitä käytetään .map()-metodin kanssa?

Vastaa interaktiivisessa oppitunnissa

Kertaus: mielivaltaisen instanssin metodiviitteet

Tärkeimmät asiat:

Syntaksi: ClassName::instanceMethod — kukin alkio on vastaanottaja
Vastaa funktionaalisia rajapintoja, joissa vastaanottaja on ensimmäinen parametri
Yleisimmät käyttökohteet ovat .map(), .filter(), .sorted() ja .forEach()
Kaksiparametriset metodit → BiFunction/BiPredicate, jossa alkio toimii vastaanottajana
Suorituskyvyssä ei ole eroa lambdaan verrattuna — valitse luettavuuden perusteella

Aloita maksutta

Opi Java tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 104
Oppitunnit: 374

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Mielivaltaisen instanssin metodiviittaukset” ilmainen?

Kyllä – oppitunnin ”Mielivaltaisen instanssin metodiviittaukset” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Java Academy-kurssin, päivitä CoddyKit PROhon. Java Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Mielivaltaisen instanssin metodiviittaukset”?

Viittaa instanssimetodiin määrittämättä vastaanottajaa – tätä käytetään paljon Stream-operaatioissa. Harjoittelet Java Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Java Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Java Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Mielivaltaisen instanssin metodiviittaukset”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Java Academy-oppitunnilla?

Kyllä. Jokainen Java Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Staattiset metodiviittaukset
Metodiviittaukset tietyn instanssin metodeihin
Mielivaltaisen instanssin metodiviittaukset
Konstruktoriviittaukset

← Takaisin: Java Academy