Java: est-il d'une carte de fonction?

J'ai besoin d'un carte fonction. Est là quelque chose comme cela en Java déjà?

(Pour ceux qui se demandent: bien sûr, je sais comment mettre en place cette triviale fonction de moi-même...)

  • Si non, il est trivial de définir vous-même. Mais je suppose que google connaît une douzaine d'implémentations?
  • Double (plutôt plus) dans le stackoverflow.com/questions/3907412/...
  • Comment est-elle la même question?
  • Ce n'est pas la même question. Il est étroitement lié, par contre...
  • Si la réponse à cette question est oui, il répond également à l'autre lié à la question. Si la réponse est non (et il me semble), ils sont totalement indépendants.
  • ah juste assez, vous avez raison. Excuses
  • Groovy a construit dans cette si vous pouvez l'utiliser.
  • Comme de Java8, c'est Ce que @delnan peut-être allusion à leveluplunch.com/java/examples/...

InformationsquelleAutor Albert | 2010-10-11
  1. 85

    Il n'y a pas de notion de fonction dans le JDK de java 6.

    Goyave a un La fonction interface, bien que l'

    Collections2.transformer(Collection<E>, la Fonction<E,E2>)

    la méthode fournit les fonctionnalités dont vous avez besoin.

    Exemple:

    //example, converts a collection of integers to their
//hexadecimal string representations
final Collection<Integer> input = Arrays.asList(10, 20, 30, 40, 50);
final Collection<String> output =
    Collections2.transform(input, new Function<Integer, String>(){

        @Override
        public String apply(final Integer input){
            return Integer.toHexString(input.intValue());
        }
    });
System.out.println(output);

    De sortie:

    [a, 14, 1e, 28, 32]

    Ces jours-ci, avec Java 8, il est en fait une fonction map, alors je serais probablement écrire le code d'une manière plus concise:

    Collection<String> hex = input.stream()
                              .map(Integer::toHexString)
                              .collect(Collectors::toList);
    • Il est intéressant de noter que tandis qu'avec la Goyave vous peut ce faire, vous pourriez ne pas vouloir: code.google.com/p/guava-libraries/wiki/FunctionalExplained (lire la section "Avertissements").
    • vrai, mais je suis assez sûr que désigne plus avancé concepts fonctionnels que cela, sinon ils n'auraient pas développé le transformation() méthodes en premier lieu
    • En fait, non, il y a souvent un réel gain de performance avec les idiomes, qui est pourquoi ils insistent vous devez utiliser uniquement si vous êtes certain qu'il répond aux deux critères énoncés: l'épargne nette de la LDC pour la base de code dans son ensemble, et éprouvée gains de performance en raison de l'évaluation différée (ou au moins pas les performances). Ne plaide pas contre l'utilisation d'entre eux, indiquant juste que, si vous allez, vous devriez tenir compte des avertissements de la mise en œuvre.
    • maintenant que Java 8 est sorti, souhaitez mettre à jour avec un exemple impliquant des lambdas? Comme Collections2.transform(input -> Integer.toHexString(intput.intValue())
    • Dans Java 8, je ne vois pas de raison de faire ça avec la Goyave. À la place, j'irais pour leventov réponse
    • c'est la bonne réponse mais l'écriture d'une boucle beaucoup plus simple et plus petit
    • vrai. Code impératif est généralement plus efficace, mais le code fonctionnel est moins sujette aux erreurs et plus maintenable
    • Je suis d'accord, mais dans ce sujet spécifique impératif code est plus facile à maintenir et sujettes à erreur de trop (je veux dire, comment pouvez-cette boucle de cause aucune erreur?)
    • tout d'abord, ce n'est plus la réponse que je vous suggère, au bout de 6 ans. Mais l'OP est de poser des questions au sujet d'une carte de fonction, pas de code impératif.. j'ai mis à jour ma réponse à montrer comment allais-je écrire le code de ces jours
    • Mais une différence importante: l'ancien code était paresseux, ce code est impatient. En fonction de vos commentaires et de votre cas d'utilisation, cela peut être une énorme différence
    • .recueillir des(Collectionneurs.toList()); a fonctionné pour moi

    InformationsquelleAutor Sean Patrick Floyd
  2. 88

    Depuis Java 8, il y a quelques options standard pour ce faire, dans le JDK:

    Collection<E> in = ...
Object[] mapped = in.stream().map(e -> doMap(e)).toArray();
//or
List<E> mapped = in.stream().map(e -> doMap(e)).collect(Collectors.toList());

    Voir java.util.Collection.stream() et java.util.flux de données.Des collectionneurs.toList().

    • C'est tellement détaillé qui me fait mal à l'intérieur.
    • si la collection est ArrayList et vous n'en avez pas besoin, après la cartographie, il est plus simple et plus efficace ArrayList.replaceAll.
    • verbeux, mais agile. stream() ou parallelStream(), la collecte de Liste ou d'un Ensemble, etc. Mais je suis d'accord, il devrait y avoir des raccourcis pour la plupart des cas d'utilisation courants.
    • leventov: replaceAll() ne peut pas la carte d'un type différent, n'est utilisable que pour les listes, et modifie la liste d'origine. Ce n'est pas bon. Je peux accepter que vous avez besoin pour créer un Stream de chaque collection, avant de vous pouvez effectuer certaines opérations fonctionnelles, mais pourquoi, OH POURQUOI ne sont-ils pas toList(), toSet() etc. des méthodes directement sur elle? L'enfer qui se soucie de certains collectionneurs? Je veux juste map/filter une collection.
    • d'accord à propos de toList(). Remplacement de type différent: (List<R>)((List) list).replaceAll(o -> doMap((E) o));
    • leventov: Merci de ne pas faire ce genre de hacks. Jamais. 🙂
    • Si vous ne voulez pas vous embêter à le convertir à un flux et à l'arrière, vous pouvez utiliser la Goyave est Collections2.transform avec un lambda. Qui est assez laconique, mais il est décevant de constater qu'il n'y a pas de façon laconique à la carte d'une collection dans la JRE. OMI Collection doit avoir été donné map et filter avec des implémentations par défaut.
    • Peut e -> doMap(e) être remplacé par seulement doMap?
    • oui, quelque chose comme foo::doMap ou Foo::doMap.
    • Je suppose que c'est pourquoi Scala existe. Attendre pour Java 12 pour avoir quelque chose de lisible.
    • En Java 12: [1, 2, 3].collect { it * 2 } //result: [2, 4, 6] Ça va être un super moment!
    • Comment créer une Collection à partir d'un simple tableau []?
    • Les tableaux de.asList()

    InformationsquelleAutor leventov
  3. 26

    Il y a une magnifique bibliothèque appelée Fonctionnel Java qui s'occupe de beaucoup de choses que vous voulez Java, mais il ne le fait pas. Puis de nouveau, il y a aussi ce merveilleux langage Scala qui fait tout Java doit avoir fait, mais n'a pas, tout en restant compatible avec ce qui est écrit pour la JVM.

    • Je suis intéressé par comment ont-ils permettre la syntaxe suivante: a.map({int i => i + 42}); ont-ils étendre compilateur? ou ajouté de préprocesseur?
    • Vous pouvez leur demander ce que vous-même ou consulter le code source pour voir comment c'est fait. Voici un lien vers la source: functionaljava.org/source
    • exemples d'utilisation de la syntaxe de BGGA fermetures de proposition. Alors qu'il est en cours d'exécution du prototype, il n'est pas "officielle" de Java encore.
    • cette syntaxe est partie d'un projet de spécification pour les fermetures en Java (voir l'avant-dernier paragraphe de la page d'accueil). Il n'y a qu'un prototype de la mise en œuvre.
    • pour être juste: scala n'est pas le seul choix. Groovy, Clojure, JRuby, et probablement beaucoup d'autres, toutes offrent cette fonctionnalité.
    • mais qui compile ce code? javac? ou de leur première utilisation de leurs préprocesseur?
    • Scala fil détourner 🙁 j'espère ne pas devenir comme le JavaPosse liste de diffusion 😉
    • C# 😛
    • sur la machine virtuelle Java? Je ne le pense pas... 🙂
    • Il y a de plus fonctionnel bibliothèques Java, Fonctionnel Java niso d'entre eux. Voir stackoverflow.com/questions/1267297/...
    • vrai, mais je voudrais tout de même dire que FunctionalJava et Goyave sont les deux plus prometteurs options
    • modifié Javac pouvez compiler le code. Il est disponible à l'adresse javac.info (cherchez "prototype"). Mais je pense que Fonctionnel Java page de l'utiliser seulement comme un uncompilable exemple.
    • Ayant récemment utilisé FunctionalJava, je dois dire que je suis maintenant inquiet qu'il ne semble plus être activement soutenu ...
    • ... et aussi lisible que perl ...

    InformationsquelleAutor wheaties
  4. 9

    Être très prudent avec Collections2.transform() de goyave.
    Cette méthode est plus grand avantage est aussi son plus grand danger: sa paresse.

    Regardez la documentation de Lists.transform(), qui, je crois, s'applique également à Collections2.transform():

    La fonction est appliquée paresseusement, invoquée en cas de besoin. Cela est nécessaire
    pour la liste retournée à être vue, mais cela signifie que la fonction
    sera appliqué à plusieurs reprises pour des opérations en bloc comme
    Liste.contient(java.lang.De l'objet) et de la Liste.hashCode(). Pour cela
    bien, la fonction devrait être rapide. Pour éviter d'évaluation différée lorsque
    la liste retournée n'a pas besoin d'être vue, copie de la liste retournée
    dans une nouvelle liste de votre choix.

    Également dans la documentation de Collections2.transform() ils mentionnent vous obtenez une vue en direct, que le changement dans la liste source d'affecter la transformée de liste. Ce genre de comportement peut entraîner difficiles à repérer des problèmes si le développeur ne se rend pas compte de la façon dont il fonctionne.

    Si vous voulez un style plus classique, "carte", ce qui sera une fois et une fois seulement, alors vous êtes mieux avec FluentIterable, également à partir de Goyave, qui a un fonctionnement qui est beaucoup plus simple. Voici le google exemple:

    FluentIterable
       .from(database.getClientList())
       .filter(activeInLastMonth())
       .transform(Functions.toStringFunction())
       .limit(10)
       .toList();

    transform() ici est la méthode la carte. Il utilise la même Fonction<> "rappels" comme Collections.transform(). La liste que vous obtenez en retour est en lecture seule, utilisez alors copyInto() pour obtenir une lecture-écriture de la liste.

    Sinon bien sûr, quand java8 sort avec des lambdas, ce sera obsolète.

    InformationsquelleAutor Emmanuel Touzery
  5. 2

    C'est une autre fonctionnelle lib avec qui vous pouvez utiliser la carte: http://code.google.com/p/totallylazy/

    sequence(1, 2).map(toString); //lazily returns "1", "2"
    InformationsquelleAutor Pedro Morte Rolo
  6. 1

    Même si c'est une vieille question que j'aimerais vous montrer une autre solution:

    Il suffit de définir votre propre exploitation à l'aide de java génériques et de java 8 flux:

    public static <S, T> List<T> mapAll(Collection<S> collection, Function<S, T> mapper) {
   return collection.stream().map(mapper).collect(Collectors.toList());
}

    Que vous pouvez écrire du code comme ceci:

    List<String> hex = mapAll(Arrays.asList(10, 20, 30, 40, 50), Integer::toHexString);
    InformationsquelleAutor IPP Geek