Java Academy · Lezione

Riferimenti a metodi di istanza arbitraria

Faccia riferimento a un metodo di istanza senza specificare il ricevitore, una tecnica ampiamente utilizzata nelle operazioni sugli Stream.

Lezione 3 di 413 passaggi

Riferimenti a metodi di istanza arbitraria è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Che cosa sono i riferimenti a un'istanza arbitraria?

Un riferimento a un metodo di un'istanza arbitraria utilizza ClassName::instanceMethod. In questo caso, il primo argomento dell'interfaccia funzionale funge da ricevitore: ogni elemento diventa l'oggetto sul quale viene chiamato il metodo.

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]

Come viene risolto il ricevitore

Per un riferimento a un'istanza arbitraria Type::method, il primo parametro dell'interfaccia funzionale diventa this (il ricevitore):

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

Utilizzati soprattutto con le operazioni sugli stream

I riferimenti a un'istanza arbitraria sono il tipo più comune nelle pipeline di stream:

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

Stile BiFunction con metodi a due argomenti

Un metodo a due argomenti di un tipo corrisponde a BiFunction<T, U, R>, dove T è il ricevitore e U è l'argomento:

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 con istanza arbitraria

String::compareTo corrisponde a Comparator<String>: i due argomenti del comparatore diventano il ricevitore e il parametro:

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]

Istanza arbitraria con una classe personalizzata

Funziona con i metodi di istanza di qualsiasi classe, non solo con i tipi del 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)

Differenza rispetto all'istanza specifica

La differenza fondamentale è la seguente:

Specifico: obj::method — obj è sempre il ricevitore
Arbitrario: Type::method — ogni elemento È il ricevitore

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

Riferimenti a metodi nei collector

I riferimenti a un'istanza arbitraria si combinano naturalmente con i collector:

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]

Concatenazione di riferimenti a metodi

I riferimenti a metodi possono essere concatenati con andThen/compose su Function:

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

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

Problema: metodi sovraccaricati

Quando un metodo è sovraccaricato, il compilatore deve determinare quale versione corrisponde all'interfaccia funzionale. Se la scelta è ambigua, si verifica un errore di compilazione: utilizzi una lambda per risolvere l'ambiguità:

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

Prestazioni

I riferimenti a metodi e le lambda vengono compilati nello stesso bytecode (tramite invokedynamic). Non vi è alcuna differenza in termini di prestazioni: scelga la forma più leggibile. La maggior parte delle guide di stile preferisce i riferimenti a metodi quando esprimono chiaramente l'intento.

Verifica rapida

Che cosa rappresenta String::toUpperCase quando viene utilizzato con .map()?

Rispondi nella lezione interattiva

Riepilogo: riferimenti a metodi di un'istanza arbitraria

Punti chiave:

Sintassi: ClassName::instanceMethod — ogni elemento è il ricevitore
Corrisponde alle interfacce funzionali in cui il ricevitore è il primo parametro
È utilizzato soprattutto in .map(), .filter(), .sorted(), .forEach()
Metodi a due argomenti → BiFunction/BiPredicate con l'elemento come ricevitore
Nessuna differenza di prestazioni rispetto a una lambda: scelga in base alla leggibilità

Gratis per iniziare

Impara Java con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 104
Lezioni: 374

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Riferimenti a metodi di istanza arbitraria» è gratuita?

Sì — il testo completo di «Riferimenti a metodi di istanza arbitraria» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Riferimenti a metodi di istanza arbitraria»?

Faccia riferimento a un metodo di istanza senza specificare il ricevitore, una tecnica ampiamente utilizzata nelle operazioni sugli Stream. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Riferimenti a metodi di istanza arbitraria»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Riferimenti a metodi statici
Riferimenti a metodi di istanza su un'istanza specifica
Riferimenti a metodi di istanza arbitraria
Riferimenti a costruttori

← Torna a Java Academy