Il existe un moyen de composer une référence de méthode qui est l'opposé d'une référence de méthode actuelle. Voir la réponse de @ vlasec ci-dessous qui montre comment en exprimant explicitement la référence de méthode en a Predicate
puis en la convertissant à l'aide de la negate
fonction. C'est une façon parmi quelques autres façons pas trop gênantes de le faire.
Le contraire:
Stream<String> s = ...;
int emptyStrings = s.filter(String::isEmpty).count();
est-ce:
Stream<String> s = ...;
int notEmptyStrings = s.filter(((Predicate<String>) String::isEmpty).negate()).count()
ou ca:
Stream<String> s = ...;
int notEmptyStrings = s.filter( it -> !it.isEmpty() ).count();
Personnellement, je préfère la technique ultérieure parce que je trouve plus clair à lire it -> !it.isEmpty()
qu'un long casting explicite verbeux et ensuite à nier.
On pourrait aussi faire un prédicat et le réutiliser:
Predicate<String> notEmpty = (String it) -> !it.isEmpty();
Stream<String> s = ...;
int notEmptyStrings = s.filter(notEmpty).count();
Ou, si vous avez une collection ou un tableau, utilisez simplement une boucle for qui est simple, a moins de surcharge et * pourrait être ** plus rapide:
int notEmpty = 0;
for(String s : list) if(!s.isEmpty()) notEmpty++;
* Si vous voulez savoir ce qui est plus rapide, utilisez JMH http://openjdk.java.net/projects/code-tools/jmh et évitez le code de référence manuel à moins qu'il n'évite toutes les optimisations JVM - voir Java 8: performances des flux vs Collections
** Je reçois un flak pour avoir suggéré que la technique for-loop est plus rapide. Il élimine la création d'un flux, il élimine l'utilisation d'un autre appel de méthode (fonction négative pour le prédicat) et il élimine une liste / compteur d'accumulateurs temporaires. Donc, quelques choses qui sont enregistrées par la dernière construction qui pourraient le rendre plus rapide.
Je pense que c'est plus simple et plus agréable, même si ce n'est pas plus rapide. Si le travail nécessite un marteau et un clou, n'apportez pas de tronçonneuse et de colle! Je sais que certains d'entre vous s'y opposent.
wish-list: j'aimerais voir les Stream
fonctions Java évoluer un peu maintenant que les utilisateurs Java les connaissent mieux. Par exemple, la méthode 'count' dans Stream pourrait accepter un Predicate
afin que cela puisse être fait directement comme ceci:
Stream<String> s = ...;
int notEmptyStrings = s.count(it -> !it.isEmpty());
or
List<String> list = ...;
int notEmptyStrings = lists.count(it -> !it.isEmpty());
Predicate.not(Predicate)
méthode statique . Mais ce problème est toujours ouvert, nous le verrons au plus tôt dans Java 12 (si jamais).