Il y a deux interfaces fonctionnelles
if ( f.apply( value, x ) )
{
result = result + g.apply( value );
}
Et la classe suivante
public class IntData {
private int[] intValues;
public IntData(int[] p) {
intValues = p;
}
public int compute(BoolBiFunction f, IntFunction g, int x) {
int result = 0;
for (int value : intValues) {
if (f.apply(value, x)) {
result = result + g.apply(value);
}
}
return result;
}
La tâche consiste à utiliser des paramètres donc calculer indique à quelle fréquence un nombre se produit dans le champ intValues. Mais pour être honnête, je ne comprends pas vraiment ce que fait même la méthode de calcul donnée.
public interface BoolBiFunction {
boolean apply( int p1, int p2 );
}
public interface IntFunction {
int apply(int p);
}
f semble comparer les deux entiers, mais que fait même g.apply? Et comment l'expression lambda pour vérifier la fréquence d'apparition d'un nombre dans le champ intValues?
3 Réponses :
Votre méthode compute accepte une BoolBiFunction qui teste si deux valeurs int satisfont à une condition. S'ils satisfont à la condition (c'est-à-dire si f.apply (value, x) est true ), le résultat de l'application de la IntFunction sur le courant la valeur est ajoutée à un total.
Si vous voulez, par exemple, savoir combien d'éléments du tableau intValues sont égaux à 5, vous devez appeler:
public int compute(BoolBiFunction f, IntFunction g, int x) {
int result = 0;
for (int value : intValues) {
if (value == 5) { // which is equivalent to if (f.apply(value, x)) when x == 5
result = result + 1; // which is equivalent to result = result + g.apply(value);
}
}
return result;
}
Cela signifie que la BoolBiFunction renverra true si et seulement si les deux int qui lui sont passés sont égaux.
La IntFunction renverra toujours 1 , donc elle comptera le nombre de fois où le 3ème argument - 5 - est trouvé dans le tableau intValues .
Compte tenu des paramètres ci-dessus passés à compute () , si nous remplaçons les appels à f.apply et g.apply code> avec les corps réels des expressions lambda correspondantes, nous obtiendrons:
IntData someObject = ...
int numberOf5s = someObject.compute((x,y) -> x == y,
x -> 1,
5);
Puisque vous n'avez pas fourni les implémentations concrètes des deux lambdas donnés, je voudrais expliquer avec un exemple simple:
Pour appeler la méthode compute () , nous avons besoin des implémentations de BoolBiFunction et IntFunction
value x f.apply(value,x) g.apply(value) result 1 1 false - 0 3 1 true 6 0+6 = 6 5 1 true 10 6+10 = 16
Ensuite, nous initialisons x et intValues code>
16
Appelez la méthode compute ()
int result = compute(f, g, x); System.out.println(result);
Sortie: p >
x = 1;
intValues= {1, 3, 5};
Valeurs à chaque étape de la boucle for :
BoolBiFunction f = (p1, p2) -> p1>p2; IntFunction g = p -> p*2;
Dans cet exemple g .apply (valeur) renvoie valeur * 2
Parce que l'implémentation de Intfunction est p -> p * 2 code>
Le problème me semble un peu étrange. Mais voici une solution.
Regardez les commentaires du code pour comprendre ce qui se passe. J'ai inclus un exemple supplémentaire de la façon dont vous pourriez utiliser la même fonction de calcul (...) pour savoir combien de fois un nombre donné apparaît dans ce tableau.
public static void extraQuestionForYou(){
//How many times does triple of 2 occur in testData ? Answer is 2. Confirm it!
IntData intFinder = new IntData(testData);
int desiredNumber = 2;
int times = intFinder
//Find out how many times triple of desiredNumber occurs in an array.
.compute(
//A function which tells me if one number is equal to triple of another.
(number1, number2) -> number1 * 3 == number2,
//A function which says that it saw a number one more time, every time it sees that number.
someNumber -> 1,
//The number whose "triples" we want to find in an array.
desiredNumber
);
//Testing - Runs only when assertions are enabled for your JVM. Set VM args = -ea for your IDE.
assert times == 2 : "Expected " + desiredNumber + " to occur 2 times, but got " + times;
}
Que se passe-t-il dans la fonction de calcul?
f.apply (valeur, x):
g = someNumber -> 1. g.apply(value) means return 1 whenever you see value.result = result + g.apply (valeur):
f = (number1, number2) -> number1 == number2. f.apply(value, x) means number1 = value and number2 = x.
Nous pouvons réutiliser la méthode compute () pour faire d'autres choses comme trouver comment plusieurs fois, le triple d'un nombre donné se produit dans un tableau, en plus de ce que la question initiale a posée. Il y a deux façons de le faire - utilisez le code ci-dessus et recherchez 6, OU utilisez une fonction bi qui vérifie si un nombre est triple d'un autre. Nous utilisons cette dernière approche dans le code ci-dessous. Vous pouvez trouver un meilleur exemple à la place si vous le souhaitez.
public class Temp {
static int [] testData = {2, 5, 11, 2, 2, 7, 6, 3, 1, 9, 10, 6};
public static void main(String [] args){
answerToQuestion();
//extraQuestionForYou();
}
public static void answerToQuestion(){
//How many times does 2 occur in testData ? Answer is 3. Confirm it!
IntData intFinder = new IntData(testData);
int desiredNumber = 2;
int times = intFinder
//Find out how many times desiredNumber occurs in an array.
.compute(
//A function which tells me if one number is equal to another.
(number1, number2) -> number1 == number2,
//A function which says that it saw a number one more time, every time it sees that number.
someNumber -> 1,
//The number whose occurrence we want to find in an array.
desiredNumber
);
//Testing - Runs only when assertions are enabled for your JVM. Set VM args = -ea for your IDE.
assert times == 3 : "Expected " + desiredNumber + " to occur 3 times, but got " + times;
}
}
Tant que vous ne nous montrez pas les implémentations concrètes des deux lambdas données, nous ne savons pas non plus ce que font les lambdas. Montrez-nous l'appelant de compute ()
Où avez-vous vu ce code?