utiliser des if-else dans java 8 expression lambda

J'ai une déclaration à java-7 et c'est un travail de l'amende:

Character cha = new Character(',');
String ncourseIds = null;
String pastCourseIds = null;
for (EquivalentCourse equivalentCourse : equivalentCourses) {
  if(equivalentCourse.getNcourse() != null){
    ncourseIds += equivalentCourse.getNcourse().getId()+ ",";   
  } else if(equivalentCourse.getPastCourse() != null) {
    pastCourseIds +=equivalentCourse.getPastCourse().getId()+","; 
  }
}
if(!ncourseIds.isEmpty() &&cha.equals(ncourseIds.charAt(ncourseIds.length()-1))) {
  ncourseIds = ncourseIds.substring(0, ncourseIds.length()-1);
}
if(!pastCourseIds.isEmpty()&& cha.equals(pastCourseIds.charAt(pastCourseIds.length()-1))) {
  pastCourseIds = pastCourseIds.substring(0,pastCourseIds.length()-1);
}

Maintenant je veux convertir mon code pour Stream & collect dans java 8, je mets en œuvre la moitié de mes affaires sur filtre pas null Ncourse:

equivalentCourses.stream().filter(obj -> obj.getNcourse() != null )
                 .map(obj -> obj.getNcourse().getId()).collect(Collectors.joining(","));

mais je ne sais pas à mettre en œuvre, c'est else-statement. toute aide?

Pourquoi utilisez-vous Character au lieu de char? Cela rend votre code plus difficile à lire et le gaspillage de ressources. Cependant, vous n'avez pas besoin, si vous remplacez !ncourseIds.isEmpty() && ha.equals(ncourseIds.charAt(ncourseIds.length()-1)) avec un simple ncourseIds.endsWith(",") et de la même manière, !pastCourseIds.isEmpty() && cha.equals(pastCourseIds.charAt(pastCourseIds.length()-1)) avec pastCourseIds.endsWith(","). Pour recueillir des deux chaînes avec des cours d'eau, vous pouvez simplement effectuer deux flux d'opérations.
déjà dit: l'utilisation de deux flux d'opérations (un pour getNcourse() != null et un pour getNcourse() == null && getPastCourse() != null).

InformationsquelleAutor Shayan Mirzaee | 2017-02-15

Comme un flux d'appel chaîne complexe des deux ruisseaux - en évitant les branches conditionnelles.

String ncourseIds = equivalentCourses.stream()
   .filter(equivalentCourse -> equivalentCourse.getNcourse() != null)
   .map(EquivalentCourse::getNcourse)
   .map(x -> String.valueOf(x.getId()))
   .collect(Collectors.joining(", "));

String pastCourseIds = equivalentCourses.stream()
   .filter(equivalentCourse -> equivalentCourse.getNcourse() == null
          && equivalentCourse.getPastCourse() != null)
   .map(EquivalentCourse::getPastCourse)
   .map(x -> String.valueOf(x.getId()))
   .collect(Collectors.joining(", "));

C'est aussi un code en se concentrant sur les deux chaînes, avec une efficacité de rejoindre.

Par ailleurs, si c'est pour une chaîne SQL, vous pouvez utiliser un PreparedStatement avec un Tableau.

Embellissement comme indiqué par @Holger:

String ncourseIds = equivalentCourses.stream()
   .map(EquivalentCourse::getNcourse)
   .filter(Objects::nonNull)
   .map(NCourse::getId)
   .map(String::valueOf)
   .collect(Collectors.joining(", "));

String pastCourseIds = equivalentCourses.stream()
   .filter(equivalentCourse -> equivalentCourse.getNcourse() == null)
   .map(EquivalentCourse::getPastCourse)
   .filter(Objects::nonNull)
   .map(EquivalentCourse::getPastCourse)
   .map(PastCourse::getId)
   .map(String::valueOf)
   .collect(Collectors.joining(", "));

Belle utilisation de la double deux-points!
Vous pouvez simplifier par une modification de l'ordre. Premier volet de l'op: .map(EquivalentCourse::getNcourse) .filter(Objects::nonNull), deuxième volet de l'op: .filter(equivalentCourse -> equivalentCourse.getNcourse() == null) .map(EquivalentCourse::getPastCourse) .filter(Objects::nonNull).
vous avez raison, et aussi le getId pourrait être amélioré avec quelques connaissances de classe

InformationsquelleAutor Joop Eggen

Vous pourriez groupe en condition puis reconfigurer:

public void booleanGrouping() throws Exception {
    List<String> strings = new ArrayList<>();
    strings.add("ala");
    strings.add("ela");
    strings.add("jan");

    strings.stream()
            .collect(
                    Collectors.groupingBy(s -> s.endsWith("a")) //using function Obj -> Bool not predicate
            ).entrySet()
            .stream()
            .collect(
                    Collectors.toMap(
                            e -> e.getKey() ? "Present" : "Past",
                            e -> e.getValue().stream().collect(Collectors.joining(""))
                    )
            );
}

Ruisseau premier groupe par condition, vous devez utiliser equivalentCourse.getNcourse() != null deuxième remapper les collections de la valeur à la chaîne. Vous pouvez introduire:

enum PresentPast{
    Present, Past
    PresentPast is(boolean v){
         return v ? Present : Past
    }
}

et changement e -> e.getKey() ? "Present" : "Past" enum en fonction de la solution.

Edit:

Solution pour else if:

public Map<Classifier, String> booleanGrouping() throws Exception {
    List<String> strings = new ArrayList<>();
    strings.add("ala");
    strings.add("ela");
    strings.add("jan");
    //our ifs:
    /*
        if(!string.endsWith("n")){
        }else if(string.startsWith("e")){}

        final map should contains two elements
        endsWithN -> ["jan"]
        startsWithE -> ["ela"]
        NOT_MATCH -> ["ala"]

     */
    return strings.stream()
            .collect(
                    Collectors.groupingBy(Classifier::apply) //using function Obj -> Bool not predicate
            ).entrySet()
            .stream()
            .collect(
                    Collectors.toMap(
                            e -> e.getKey(),
                            e -> e.getValue().stream().collect(Collectors.joining(""))
                    )
            );
}

enum Classifier implements Predicate<String> {
    ENDS_WITH_N {
        @Override
        public boolean test(String s) {
            return s.endsWith("n");
        }
    },
    STARTS_WITH_E {
        @Override
        public boolean test(String s) {
            return s.startsWith("e");
        }
    }, NOT_MATCH {
        @Override
        public boolean test(String s) {
            return false;
        }
    };

    public static Classifier apply(String s) {
        return Arrays.stream(Classifier.values())
                .filter(c -> c.test(s))
                .findFirst().orElse(NOT_MATCH);
    }
}

C'est une bonne solution pour if-else déclaration, mais la question est à propos de else-if déclaration. Dans ce cas, vous devez effectuer deux flux de l'opération.
Je vois 🙂 je vais corriger ça (vous avez besoin d'introduire un peu différent condition) alors que je suis de retour à mon PC principal 😀

InformationsquelleAutor Koziołek

Mise à jour

Pour ajouter une alternative, voici ce à quoi ressemblera le code pour faire le travail avec deux filter() opérations. Remarque, cela a de l'impact d'une itération sur l'ensemble de la collection un deuxième temps, ce qui peut avoir un impact sur les performances, si cela est une grande collection.

Je suis aussi allé de l'avant et simplifiée de la logique en ce qui concerne la chaîne de rejoindre. Corrigez-moi si j'ai raté quelque chose là-bas.

final List<String> courseIdList = new ArrayList<>();
final List<String> pastCourseIdList = new ArrayList<>();

equivalentCourses.stream().filter((current) -> current.getNcourse() != null)
                .forEach((current) -> courseIdList.add(current.getNcourse().getId()));

equivalentCourses.stream().filter((current) -> current.getNcourse() != null && current.getPastCourse() != null)
                .forEach((current) -> pastCourseIdList.add(current.getPastCourse().getId()));

String ncourseIds = String.join(",", courseIdList);
String pastCourseIds = String.join(",", pastCourseIdList);

Réponse originale à cette question

Pour votre cas d'utilisation, il peut faire le plus de sens pour utiliser le forEach() lambda. Ce sera le moyen le plus facile pour faire la traduction.

java.lang.Character cha = new java.lang.Character(',');

final StringBuilder ncourseIdBuilder = new StringBuilder();
final StringBuilder pastCourseIdBuilder = new StringBuilder();
equivalentCourses.stream().forEach((equivalentCourse) -> {
    if (equivalentCourse.getNcourse() != null) {
        ncourseIdBuilder.append(equivalentCourse.getNcourse().getId()).append(",");
    } else if (equivalentCourse.getPastCourse() != null) {
        pastCourseIdBuilder.append(equivalentCourse.getPastCourse().getId()).append(",");
    }
});

String ncourseIds = ncourseIdBuilder.toString();
String pastCourseIds = pastCourseIdBuilder.toString();

if (!ncourseIds.isEmpty() && cha.equals(ncourseIds.charAt(ncourseIds.length() - 1))) {
    ncourseIds = ncourseIds.substring(0, ncourseIds.length() - 1);
}
if (!pastCourseIds.isEmpty() && cha.equals(pastCourseIds.charAt(pastCourseIds.length() - 1))) {
    pastCourseIds = pastCourseIds.substring(0, pastCourseIds.length() - 1);
}

Vous pouvez réécrire le code à l'aide de filter() expressions, mais il va me falloir un plus gros re-travail de la logique dans les instructions conditionnelles, qui présente le risque que vous pourriez casser quelque chose si ce n'est pas bien testé. La logique des changements sont exactement ce que @Holger et @Ole V. V. de référence dans leurs observations sur la question d'origine.

Si vous utilisez forEach() ou les filtres, les lambdas ne peut pas accéder non-final variables dans l'expression, c'est pourquoi j'ai ajouté le final StringBuilder variable en dehors de la portée de la boucle.

InformationsquelleAutor Cuga

Vous devez vous connecter pour publier un commentaire.