L'équivalent de la Scala, à la foldLeft dans Java 8

Ce qui est l'équivalent de la Scala, à la grande foldLeft dans Java 8?

J'ai été tenté de penser que c'était reduce, mais de réduire doit retourner quelque chose de type identique à ce qu'il réduit sur.

Exemple:

import java.util.List;

public class Foo {

    //this method works pretty well
    public int sum(List<Integer> numbers) {
        return numbers.stream()
                      .reduce(0, (acc, n) -> (acc + n));
    }

    //this method makes the file not compile
    public String concatenate(List<Character> chars) {
        return chars.stream()
                    .reduce(new StringBuilder(""), (acc, c) -> acc.append(c)).toString();
    }
}

Le problème dans le code ci-dessus est le accumulator: new StringBuilder("")

Ainsi, quelqu'un pourrait-il m'indiquer le bon équivalent de la foldLeft/correction de mon code?

Pour info: le nom de La langue est "la Scala", pas "la SCALA". (Je crois qu'il est dans une langue différente, appelée "la SCALA", qui n'est probablement pas celui que tu veux dire.)
Connexes stackoverflow.com/questions/30736587/...
sauf si vous avez une source pour qu'il soit une langue différente avec le même nom mais avec une majuscule, je serais très surpris. Je pense que le capitalisés orthographe vient du vieux gestionnaires qui sont utilisés pour les langues étant capitalisés, à l'instar de BASE et FORTRAN 😀
J'ai essayé de googler pour elle, mais c'est un peu dur, car googler "SCALA" renvoie également les résultats pour "Scala". Je crois, je l'ai vu dans le contexte de ce que nous aurions appelé aujourd'hui le "big data analyse" sur IBM de milieu de gamme systèmes, mais avant le "big data" (ou Scala) étaient une chose. Cependant, j'ai personnellement jamais travaillé sur IBM de milieu de gamme systèmes, de sorte que je ne me souviens pas les noms des outils associés, des cadres, des bibliothèques ou des langues, afin d'effectuer une meilleure google requête. Le fait que la Scala est utilisé dans le big data, et IBM est lourdement en poussant Scala n'est pas exactement de l'aide, soit.

InformationsquelleAutor GA1 | 2016-12-20

12

Mise à jour:

Ici est la première tentative pour obtenir votre code fixe:
```
public static String concatenate(List<Character> chars) {
        return chars
                .stream()
                .reduce(new StringBuilder(),
                                StringBuilder::append,
                                StringBuilder::append).toString();
    }
```
Il utilise le suivant réduire la méthode:
```
<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);
```
Il peut sembler déroutant, mais si vous regardez la documentation javadoc il y a une belle explication qui peut vous aider à comprendre rapidement les détails. La réduction est équivalent au code suivant:
```
U result = identity;
for (T element : this stream)
     result = accumulator.apply(result, element)
return result;
```
Pour une explication plus approfondie, veuillez vérifier cette source.

Cette utilisation n'est pas correcte car elle viole le contrat de réduire les qui indique que l'accumulateur doit être associatif, à la non-ingérence, d'apatride, de la fonction pour l'intégration d'un élément supplémentaire en raison. En d'autres termes, puisque l'identité est mutable, le résultat sera brisée en cas d'exécution parallèle.

Comme indiqué dans les commentaires ci-dessous une bonne option est d'utiliser la réduction comme suit:
```
return chars.stream().collect(
     StringBuilder::new, 
     StringBuilder::append, 
     StringBuilder::append).toString();
```
Le fournisseur StringBuilder::new sera utilisé pour créer des contenants réutilisables qui seront ensuite combinés.
- Même comme avec les autres de répondre: Ne pas utiliser reduce de cette façon. Les fonctions sont pas autorisé à modifier leurs paramètres. L'utilisation correcte est .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append). Voir Mutable réduction.
- merci, c'est vrai. La réponse est mis à jour.
- Ce n'est pas une question d'efficacité, c'est à propos de l'exactitude. À l'aide de reduce de cette façon constitue une violation du contrat et doit être considéré comme cassé, même si elle peut faire de la destinée chose dans certaines circonstances. Plus particulièrement, il va se casser à coup sûr lors de l'utilisation d'un courant parallèle.
- Avez-vous l'adresse de l'ordre de la concaténation de caractères ou de l'statefulness du constructeur?
- C'est à propos de la modification de la StringBuilder. Il n'y a pas de problème avec la commande.
InformationsquelleAutor Lachezar Balev
16

Il n'y a pas d'équivalent de foldLeft dans Java 8 du Flux de l'API. Comme d'autres l'ont noté, reduce(identity, accumulator, combiner) est proche, mais il n'est pas équivalent avec foldLeft, car il nécessite le type résultant B à combiner avec lui-même et associatif (en d'autres termes, être monoïde-like), une propriété que chaque type a.

Il y a aussi une demande d'amélioration pour cette: ajouter des Flux.foldLeft() d'exploitation du terminal

De voir pourquoi les réduire ne fonctionne pas, considérez le code suivant, où vous avez l'intention d'exécuter une série d'opérations arithmétiques en commençant par nombre:
```
val arithOps = List(('+', 1), ('*', 4), ('-', 2), ('/', 5))
val fun: (Int, (Char, Int)) => Int = {
  case (x, ('+', y)) => x + y
  case (x, ('-', y)) => x - y
  case (x, ('*', y)) => x * y
  case (x, ('/', y)) => x / y
}
val number = 2
arithOps.foldLeft(number)(fun) //((2 + 1) * 4 - 2) /5
```
Si vous avez essayé d'écrire reduce(2, fun, combine), ce combiner la fonction pourriez-vous passer qui combine deux nombres? L'ajout de ces deux nombres ensemble n'a clairement pas le résoudre. Aussi, la valeur 2 n'est clairement pas un identité élément.

Noter qu'aucune opération qui nécessite une exécution séquentielle peut être exprimée en termes de reduce. foldLeft est en fait plus générique que reduce: vous pouvez mettre en œuvre reduce avec foldLeft mais vous ne pouvez pas mettre en œuvre foldLeft avec reduce.

InformationsquelleAutor dzs
6

La méthode que vous cherchez est java.util.Flux de données.réduire, notamment la surcharge de trois paramètres, de l'identité, de l'accumulateur, et la fonction binaire. C'est le bon équivalent à la Scala de foldLeft.

Cependant, vous êtes pas autorisés à utiliser Java reduce de cette façon, et non de la Scala, à la foldLeft pour cette question. Utilisation collecter à la place.
- Alors que j'aime votre réponse, "vous n'êtes pas autorisé" semble un peu mal. Pouvez-vous reformuler?
- Il serait une erreur de type Java du type de système ont été assez expressif pour exprimer cette contrainte. Mais il n'est pas et ainsi, la contrainte n'est mentionné que dans la Javadoc. La Javadoc de dire quels types d'objets sont autorisés à passer, et les objets de l'OP passe ne satisfont pas à ces contraintes, ergo, elle n'est pas permis d'appeler reduce. Sinon, comment auriez-vous la phrase que?
- Eh bien, il n'y a pas de restriction sur le type, seulement sur la façon dont vous utilisez les objets. Si vous utilisez l'accumulateur et de combiner des fonctions comme (a,b) -> new StringBuilder().append(a).append(b), ce serait une utilisation légale, mais pas très efficace, par rapport à la collect solution.
- Je dirais qu'une "restriction sur la façon dont vous utilisez les objets" est "une restriction sur le type". Ou plutôt doit être, c'est le point de l'ensemble d'un système de type. C'est juste que Java du type de système est assez faible et donc ces contraintes ne peuvent pas être exprimées comme un type. (Contrairement, disons, Agda, Guru, Isabelle, Épigramme, l'Idris, le Coq, où il serait assez facile de coder cette restriction dans le système de type et donc le faire au moment de la compilation type d'erreur.)
- Je suis d'accord, ce serait bien si Java du type de système était assez expressif pour cela. Hélas, il ne l'est pas. Et il n'y a aucun point en prétendant que c'est. Comme je l'ai écrit, je suis avec vous, mais il ne sert à rien de faire semblant, vous pouvez interdire quelque chose si vous avez réellement ne peux pas. Toute la structure du code qui compile et ne viole pas les droits d'auteur ou de restriction de licence est, par définition, permis, qu'on le veuille ou non. C'est pourquoi j'aimerais reformuler "vous n'êtes pas autorisé" à "il est considéré comme un antipattern" ou "c'est une violation de la méthode de contrat".
- sauf que c'est pas juste un antipattern. Il n'est tout simplement pas autorisé par la documentation de la méthode. Antipatterns peut ou peut ne pas entraîner dur pour maintenir le code. L'OP du code est tout simplement cassé. Kaput. Ne fonctionne pas.
- Cette réponse est simplement faux. Stream reduce(identity, accumulator, combiner) implique un associatif combiner la fonction, qui n'est pas une exigence de foldLeft, par conséquent, tous les foldLeft construire peut être réécrit pour reduce. Prenez l'exemple suivant, où la soustraction et la division ne sont pas associative: val ops = List(('+', 1), ('*', 4), ('-', 2), ('/', 5)) val fun: (Int, (Char, Int)) => Int = { case (x, ('+', y)) => x + y case (x, ('-', y)) => x - y case (x, ('*', y)) => x * y case (x, ('/', y)) => x / y } ops.foldLeft(2)(fun) // ((2 + 1) * 4 - 2) / 5
InformationsquelleAutor Jörg W Mittag

Les autres sont corrects, il n'y a pas d'équivalent si. Voici une util proche-

<U, T> U foldLeft(Collection<T> sequence, U identity, BiFunction<U, ? super T, U> accumulator) {
    U result = identity;
    for (T element : sequence)
        result = accumulator.apply(result, element);
    return result;
}

votre cas à l'aide de la méthode ci-dessus pourrait ressembler-

public String concatenate(List<Character> chars) {
    return foldLeft(chars, new StringBuilder(""), StringBuilder::append).toString();
}

Ou sans le lambda méthode ref sucre,

public String concatenate(List<Character> chars) {
    return foldLeft(chars, new StringBuilder(""), (stringBuilder, character) -> stringBuilder.append(character)).toString();
}

InformationsquelleAutor Gagandeep Kalra

Vous devez vous connecter pour publier un commentaire.