需要一些输入才能更好地使用Java-8编写代码

Question

我有一小部分代码(POJO)与java-8。我的问题是，我是否可以更好地使用java-8？我在课堂上提到了一些评论。

假设我有Person、Standard和Subject pojos，并且也不担心equals和hashCode方法，我只想要关于Java-8的输入。

package com.java8.learn.domain;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author Vishal.Zanzrukia
 *
 */
public class Teacher extends Person {

    private Map<Standard, Set<Subject>> standardWiseSubjects;

    public Map<Standard, Set<Subject>> getStandardWiseSubjects() {
        return standardWiseSubjects;
    }

    public void addStandardWiseSubject(Subject subject, Standard standard) {
        if (this.standardWiseSubjects == null) {
            this.standardWiseSubjects = new HashMap<>();
        }
        if (this.standardWiseSubjects.containsKey(standard)) {
            this.standardWiseSubjects.get(standard).add(subject);
        } else {
            Set<Subject> subjects = new HashSet<>();
            subjects.add(subject);
            this.standardWiseSubjects.put(standard, subjects);
        }
    }

    // I need some inputs over here.
    public Map<Subject, Set<Standard>> getSubjectWiseStandards() {

        if (this.standardWiseSubjects == null) {
            return null;
        }

        Map<Subject, Set<Standard>> output = new HashMap<>();

        this.standardWiseSubjects.values().parallelStream().flatMap(set -> set.stream()).forEach(subject -> {
            Set<Standard> standards = new HashSet<>();
            this.standardWiseSubjects.forEach((standard, subjects) -> {
                // TODO can I convert this if condition into predicate?
                if (subjects.contains(subject)) {
                    standards.add(standard);
                }
            });
            output.put(subject, standards);
        });

        return output;
    }
}

Answer 1

可以使用addStandardWiseSubject方法简化computeIfAbsent方法：

public void addStandardWiseSubject(Subject subject, Standard standard) {
    if (this.standardWiseSubjects == null) {
        this.standardWiseSubjects = new HashMap<>();
    }
    this.standardWiseSubjects.computeIfAbsent(standard,
            s -> new HashSet<>()).add(subject);
}

getSubjectWiseStandards()要复杂得多:你需要倒转地图。可以生成所有主题的中间对和相应的标准(我使用AbstractMap.SimpleEntry类来表示这种对)：

public Map<Subject, Set<Standard>> getSubjectWiseStandards() {
    if (this.standardWiseSubjects == null) {
        return null;
    }

    return this.standardWiseSubjects.entrySet().parallelStream()
        .<Map.Entry<Subject, Standard>> flatMap(
                e -> e.getValue().stream()
                    .map(st -> new AbstractMap.SimpleEntry<>(st, e.getKey())))
        .collect(Collectors.groupingBy(e -> e.getKey(), 
                 Collectors.mapping(e -> e.getValue(), 
                 Collectors.toSet())));
}

使用我的EntryStream库的StreamEx类，这看起来可能更简单：

public Map<Subject, Set<Standard>> getSubjectWiseStandards() {
    if (this.standardWiseSubjects == null) {
        return null;
    }

    return EntryStream.of(this.standardWiseSubjects).parallel()
            .invert().flatMapKeys(Set::stream).groupingTo(HashSet::new);
}

请注意，具有并行流的forEach应该非常小心地使用，因为它可以并行地执行不同的元素。您的解决方案在修改来自此HashMap操作的forEach (这不是线程安全的)时可能不正确。

Answer 2

应该是可能的，如下所示

Map<Standard, Set<Subject>> map = new HashMap<Standard, Set<Subject>>();
Map<Subject, Set<Standard>> reverseMap = new HashMap<Subject, Set<Standard>>();
HashSet<Subject> std1Subjects = new HashSet<Subject>();
std1Subjects.add(new Subject("English"));
std1Subjects.add(new Subject("Maths"));
std1Subjects.add(new Subject("Science"));

HashSet<Subject> std2Subjects = new HashSet<Subject>();
std2Subjects.add(new Subject("Hindi"));
std2Subjects.add(new Subject("Gujarati"));
std2Subjects.add(new Subject("Maths"));

HashSet<Subject> std3Subjects = new HashSet<Subject>();
std3Subjects.add(new Subject("Sanskrit"));
std3Subjects.add(new Subject("Science"));
std3Subjects.add(new Subject("Maths"));

map.put(new Standard("1"), std1Subjects);
map.put(new Standard("2"), std2Subjects);
map.put(new Standard("3"), std3Subjects);

//1.
map.keySet().forEach((std) -> map.get(std).forEach((sub)->{
    if(reverseMap.containsKey(sub)){
        reverseMap.get(sub).add(std);
    }else{
        HashSet<Standard> standardSet = new HashSet<Standard>();
        standardSet.add(std);
        reverseMap.put(sub, standardSet);
    }
}));

reverseMap
        .forEach((k, v) -> System.out.println("k-" + k + " , v-" + v));

也像下面这样

map.keySet().forEach((std) -> map.get(std).forEach((sub)->{
            reverseMap.computeIfAbsent(sub,standard-> new HashSet<>()).add(std);
            reverseMap.computeIfPresent(sub, (subject,stdSet) -> reverseMap.get(subject)).add(std);
        }));