web-dev-qa-db-fra.com

interfaces fonctionnelles de Java 8 en Java 7

les interfaces fonctionnelles de Java 8 sont-elles disponibles quelque part (c'est-à-dire un fichier jar) pour que je puisse les utiliser dans un projet Java 7? de cette façon, je pourrais plus tard transférer plus facilement le code dans Java 8. idiomatic. Sinon, est-ce techniquement possible ou utilise-t-il de nouvelles fonctionnalités telles que les méthodes par défaut?

oui, je voulais dire les interfaces dans Java.util.function. puisque l'ajout de paquets avec le préfixe Java semble être interdit, leur importation ailleurs n'est pas une option.

javacompatibilityjava-7java-8
16
msung

Une interface fonctionnelle est simplement une interface avec une seule méthode, non statique ni par défaut. Toutes les interfaces répondant à cette définition peuvent être implémentées via un lambda dans Java 8.

Par exemple, Runnable est une interface fonctionnelle et dans Java 8, vous pouvez écrire: Runnable r = () -> doSomething();.

La plupart des interfaces fonctionnelles apportées par Java 8 se trouvent dans le paquetage Java.util.function . Les plus courants sont:

  • Consumer<T> qui a un void accept(T t)
  • Supplier<T> qui a un T get()
  • Function<T, R> qui a un R apply(T t)
  • Predicate<T> qui en tant que boolean test(T t)

À ce stade, vous pouvez utiliser des interfaces à méthode unique chaque fois que cela s'avère utile, si possible avec des signatures similaires. Lorsque vous migrez vers Java 8, vous pourrez facilement restructurer votre IDE à partir de:

someMethod(new MyConsumer<T>() { public void accept(T t) { use(t); } });

dans

someMethod(t -> use(t));

Puis changez la signature de someMethod(MyConsumer<T> mc) en someMethod(Consumer<T> c), supprimez votre interface MyConsumer et vous avez terminé.

16
assylias

Voici les signatures des principales interfaces fonctionnelles de Java 8, qui complètent la réponse d’assylias.

public interface Consumer<T> {
    void accept(T t);
}

public interface Supplier<T> {
    T get();
}

public interface Function<T, R> {
    R apply(T t);
}

public interface Predicate<T> {
    boolean test(T t);
}
6
mkdev

Les interfaces fonctionnelles de Java 8 sont limitées. Utilisez les types FunctionalJava P1, F, F2, F3, ..., F8, TryCatch0, TryCatch1, ..., TryCatch8 pour faire la même chose maintenant avec davantage de fonctionnalités.

https://functionaljava.ci.cloudbees.com/job/master/javadoc/

Vous pouvez utiliser le projet Retro Lambda pour compiler avec Java 8 et lambdas, mais pour cibler la machine virtuelle Java 7. Cela évite tout le non-sens anonyme de classe interne. Voir le projet FunctionalJava pour un exemple ( http://www.functionaljava.org/ ).

1
Mark Perry

Outre la réponse de @assylias qui, à mon avis, résout le problème dans la plupart des cas, il existe une option supplémentaire: créer votre propre @FunctionalInterface et le conserver ainsi.

Cela dépend de l'endroit où vous utilisez les fonctions. Toutes les interfaces susmentionnées peuvent être utilisées par les classes d’utilitaires JDK. Predicate permet le filtrage, Supplier permet la création d'objets, Function permet le mappage ... En fait, Predicate et Supplier sont plutôt simples, mais Function et Consumer peuvent être souvent mal définis, en particulier BiFunction. Ils peuvent également vous lier les mains dans certains cas d'utilisation.

Vous pouvez écrire votre propre interface comportant un certain nombre d'entrées, émettant des exceptions vérifiées, contenant des génériques uniquement là où vous en avez besoin et dont le nom indique l'utilisation qui en est faite.

//@FunctionalInterface
public interface MyCustomInterface {
    <T> MyCustomOutput myCustomAction(MyCustomInput<T> str) throws MyCustomException;
}

Ainsi, bien que les interfaces fournies avec JDK soient utiles, vous préférerez peut-être parfois conserver votre propre solution, même avec Java 8, avec uniquement les annotations et lambdas au lieu des classes anonymes.

0
Vlasec