Tutorial Base Java

Controllo di流程 Java

Array Java

Java orientato agli oggetti (I)

Java orientato agli oggetti (II)

Java orientato agli oggetti (III)

Gestione eccezioni Java

Lista Java

Queue (coda) Java

Map di Java

Set di Java

Input/Output (I/O) Java

Reader/Writer Java

Altri argomenti Java

Connessione MySQL Java Nuove caratteristiche Java 8

Interfaccia funzionale Java 8

Nuove caratteristiche Java 8

Un'interfaccia funzionale (Functional Interface) è un'interfaccia che ha un solo metodo astratto ma può avere molti metodi non astratti.

Le interfacce funzionali possono essere convertite implicitamente in espressioni lambda.

Espressioni lambda e riferimenti a metodi (che possono anche essere considerati espressioni lambda).

Come definire un'interfaccia funzionale come segue:

@FunctionalInterface
interface GreetingService　
{
　　　　void sayMessage(String message);
}

Allora si può utilizzare l'espressione lambda per rappresentare un'implementazione dell'interfaccia (Nota: prima di JAVA 8 generalmente si usavano classi anonime):

GreetingService greetService1 = message -> System.out.println("Hello " + message);

Le interfacce funzionali supportano in modo amichevole le funzioni esistenti.

Interfaccia funzionale esistente prima di JDK 1.8:

java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

Nuove interfacce funzionali aggiunte in JDK 1.8:

java.util.function

java.util.function Contiene molte classi, utilizzate per supportare la programmazione funzionale in Java, le interfacce funzionali in questo pacchetto includono:

Numero di sequenza	Interfaccia & Descrizione
1	BiConsumer<T,U> Rappresenta un'operazione che accetta due parametri di input e non restituisce alcun risultato.
2	BiFunction<T,U,R> Rappresenta un metodo che accetta due parametri di input e restituisce un risultato.
3	BinaryOperator<T> Rappresenta un'operazione su due operatori dello stesso tipo e restituisce un risultato dello stesso tipo.
4	BiPredicate<T,U> Rappresenta un metodo booleano con due parametri.
5	BooleanSupplier Rappresenta il fornitore di un risultato booleano.
6	Consumer<T> Rappresenta un'operazione che accetta un parametro di input e non restituisce alcun risultato.
7	DoubleBinaryOperator Rappresenta un'operazione su due valori double e restituisce un risultato di tipo double.
8	DoubleConsumer Rappresenta un'operazione che accetta un parametro di valore double e non restituisce alcun risultato.
9	DoubleFunction<R> Rappresenta un metodo che accetta un parametro di valore double e restituisce un risultato.
10	DoublePredicate Rappresenta un metodo booleano con un parametro di valore double.
11	DoubleSupplier Rappresenta il fornitore di una struttura di valore double.
12	DoubleToIntFunction Accetta un input di tipo double, restituisce un risultato di tipo int.
13	DoubleToLongFunction Accetta un input di tipo double, restituisce un risultato di tipo long.
14	DoubleUnaryOperator Accetta un parametro dello stesso tipo double, il tipo di ritorno anche è double.
15	Function<T,R> Accetta un parametro di input, restituisce un risultato.
16	IntBinaryOperator Accetta due parametri dello stesso tipo int, il tipo di ritorno anche è int.
17	IntConsumer Accetta un parametro di tipo int, senza restituire alcun valore.
18	IntFunction<R> Accetta un input di tipo int e restituisce un risultato .
19	IntPredicate Accetta un input di tipo int e restituisce un risultato booleano.
20	IntSupplier Senza parametri, restituisce un risultato di tipo int.
21	IntToDoubleFunction Accetta un input di tipo int e restituisce un risultato di tipo double .
22	IntToLongFunction Accetta un input di tipo int e restituisce un risultato di tipo long.
23	IntUnaryOperator Accetta un parametro di tipo int e il tipo di valore di ritorno anche int .
24	LongBinaryOperator Accetta due parametri di tipo long e il tipo di valore di ritorno anche long.
25	LongConsumer Accetta un input di tipo long e senza valore di ritorno.
26	LongFunction<R> Accetta un input di tipo long e restituisce un risultato.
27	LongPredicate R accetta un input di tipo long e restituisce un risultato di tipo booleano.
28	LongSupplier Senza parametri, restituisce un valore di tipo long.
29	LongToDoubleFunction Accetta un input di tipo long e restituisce un risultato di tipo double.
30	LongToIntFunction Accetta un input di tipo long e restituisce un risultato di tipo int.
31	LongUnaryOperator Accetta un parametro di tipo long e il tipo di valore di ritorno anche long.
32	ObjDoubleConsumer<T> Accetta un tipo di input object e un tipo di input double, senza valore di ritorno.
33	ObjIntConsumer<T> Accetta un tipo di input object e un tipo di input int, senza valore di ritorno.
34	ObjLongConsumer<T> Accetta un tipo di input object e un tipo di input long, senza valore di ritorno.
35	Predicate<T> Accetta un parametro di input e restituisce un risultato booleano.
36	Supplier<T> Senza parametri, restituisce un risultato.
37	ToDoubleBiFunction<T,U> Accetta due parametri di input e restituisce un risultato di tipo double
38	ToDoubleFunction<T> Accetta un parametro di input e restituisce un risultato di tipo double
39	ToIntBiFunction<T,U> 接受两个输入参数，返回一个int类型结果。
40	ToIntFunction<T> 接受一个输入参数，返回一个int类型结果。
41	ToLongBiFunction<T,U> 接受两个输入参数，返回一个long类型结果。
42	ToLongFunction<T> 接受一个输入参数，返回一个long类型结果。
43	UnaryOperator<T> 接受一个参数为类型T,返回值类型也为T。

函数式接口示例

Predicate <T> 接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。

该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。

该接口用于测试对象是 true 或 false。

我们可以通过以下示例(Java8Tester.java)来了解函数式接口 Predicate <T> 的使用：

Java8Tester.java file

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
　
public class Java8Tester {
　　　public static void main(String args[]){
　　　　　　List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
　　　　　　　　
　　　　　　// Predicate<Integer> predicate = n -> true
　　　　　　// n è un parametro passato al metodo test dell'interfaccia Predicate
　　　　　　// n 如果存在则 test 方法返回 true
　　　　　　　　
　　　　　　System.out.println("输出所有数据:");
　　　　　　　　
　　　　　　// 传递参数 n
　　　　　　eval(list, n -> true);
　　　　　　　　
　　　　　　// Predicate<Integer> predicate1 = n -> n % 2 == 0
　　　　　　// n è un parametro passato al metodo test dell'interfaccia Predicate
　　　　　　// 如果 n % 2 为 0 test 方法返回 true
　　　　　　　　
　　　　　　System.out.println("输出所有偶数:");
　　　　　　eval(list, n -> n % 2 == 0);
　　　　　　　　
　　　　　　// Predicate<Integer> predicate2 = n -> n > 3
　　　　　　// n è un parametro passato al metodo test dell'interfaccia Predicate
　　　　　　// Se n è maggiore di 3, il metodo test restituisce true
　　　　　　　　
　　　　　　System.out.println("Output di tutti i numeri maggiori di 3:");
　　　　　　eval(list, n-> n > 3);
　　　}
　　　　
　　　public static void eval(List<Integer> list, Predicate<Integer> predicate) {
　　　　　　for(Integer n: list) {
　　　　　　　　
　　　　　　　　　if(predicate.test(n)) {
　　　　　　　　　　　　System.out.println(n + " ");
　　　　　　　　　}
　　　　　　}
　　　}
}

Esegui lo script sopra riportato, il risultato sarà:

$ javac Java8Tester.java　
$ java Java8Tester
Output di tutti i dati:
1　
2　
3　
4　
5　
6　
7　
8　
9　
Output di tutti i numeri pari:
2　
4　
6　
8　
Output di tutti i numeri maggiori di 3:
4　
5　
6　
7　
8　
9

Nuove caratteristiche Java 8

Connessione MySQL Java Nuove caratteristiche Java 8