小编Ale*_*nko的帖子

我有一个Set<Person>，我需要过滤内容，然后填充给定集中的另一组。

我对流还很陌生。

我能想到的第一个解决方案是链接stream().filter().foreach()

解决方案一：

private Set<Person> mapPerson(final Set<Student> student) {
        final Set<Person> person = new HashSet<>();
        student.stream()
            .filter(student1 -> Objects.nonNull(student.getAge()))
            .forEach(student1 -> person.add(Person.builder()
                .id(student1.getId())
                .status(student1.getStatus()))
                .build()));

        return person;
    }

但我不确定这是否可以通过链接来完成stream().filter().map()？

将不胜感激任何帮助，如果可以两种方式进行，哪种方式是首选方式？

我正在尝试为我的班级编写一个 30 行或更少的程序（自我强加的挑战）。

该程序会询问用户一个简单的加法、除法、乘法或减法问题，然后玩家回答、冲洗并重复 10 次，然后询问玩家是否要继续或结束程序。应随机选择问题类型（add、mult等）。

这样我就不需要使用巨大的 switch case 或 if-else 树，我想知道是否有任何方法可以在变量中包含运算符，然后稍后使用它。

例子：

var operator = +;
int[] n = {1, 2};
System.out.println(n[0] operator n[1]);

输出将是“3”

这就是我想做的事情的一个例子。这可能吗？

我想创建一个嵌套HashMap：

var myHashMap = new HashMap<String, HashMap<String, int>>();

我想将记录插入到 inside 中，如果键不存在，HashMap我发现自己需要实例化内部：HashMap

var myHashMap = new HashMap<String, HashMap<String, int>>();
var outerStringValue = "ABC";
var innerStringValue = "XYZ";
var innerInt = 45;

if (!myHashMap.containsKey(outerStringValue) {
    var innerHashMap = new HashMap<String, int>();
    innerHashMap.put(innerStringValue, innerInt);
    myHashMap.put(outerStringValue, innerHashMap);
} else {
    myHashMap.get(outerStringValue).put(innerStringValue, innerInt);
}

有没有更好的方法来做到这一点，而不需要innerHashMap为每个唯一myHashMap（外部HashMap）键实例化一个新的？

我有一个Map如下所示：

Map<Character, Integer> map = new LinkedHashMap<Character, Integer>();
    map.put('c', 5);
    map.put('f', 2);
    map.put('r', 1);
    map.put('D', 3);

我需要获得输出：

cccccffrDDD

我可以在正常过程中做到这一点，但我想在 Java 8 中做到这一点。你能分享一些如何实现这一点的提示吗？

下面的第一个作业无法编译，但我不确定为什么，静态方法的方法签名与函数方法签名匹配，尽管它不使用类型参数。尽管第二行除了类型参数化之外具有相同的签名，但编译良好。

这背后的原因是什么？

public class GenericSample<T> {
    public static void staticLambdaMtd(Integer a) {
            
    }   

    public static<X> void staticLambdaMtd2(X a) {
            
    }  

    // Funca<T> fa1 = GenericSample::staticLambdaMtd;//does not compile !

    Funca<T> fa = GenericSample::staticLambdaMtd2;//does compile !      
}
    
interface Funca<A> {
    public void funct(A a);
}

谁能解释一下下面代码的输出，以及这里涉及的Java原理是什么？

class Mammal {
    void eat(Mammal m) {
        System.out.println("Mammal eats food");
    }
}

class Cattle extends Mammal{
    void eat(Cattle c){
        System.out.println("Cattle eats hay");
    }
}

class Horse extends Cattle {
    void eat(Horse h) {
        System.out.println("Horse eats hay");
    }
}

public class Test {
    public static void main(String[] args) {
        Mammal h = new Horse();
        Cattle c = new Horse();
        c.eat(h);
    }
}

它产生以下输出：

Mammal eats food

我想知道我们是如何得到上述结果的。

我需要从 an 中的每个元素获取一个对象Iterable并将其添加到List.

我可以使用下面的代码来做到这一点。ImmutableList但是，有没有什么方法可以在不显式实例化的情况下创建 Guava List？

List<Data> myList = new ArrayList<>();
myIterable.forEach(val ->
  myList.add(val.getMetaData())
);

我想让我的代码更通用。为了实现这一点，我证明了列表和供应商都是方法参数。

事实证明，reduce()在有多个可供选择的情况下，无法推断具体方法（见下面的屏幕截图）。

如何声明我想要使用的方法版本？

public BigDecimal methodCalculate(List<MyObject> list, Supplier<? extends BigDecimal> getValue) {
    BigDecimal sum = list.stream()
            .filter(item -> item.getPremium())
            .map(item -> getValue)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    return sum;
}

假设我有一个Optional包含Stream：

Optional<Stream<Integer>> optionalStream = Optional.of(Stream.of(1, 2, 3));

现在我需要提取它Stream本身。如果Optional为空，您想要获得一个空的 Stream。

我正在寻找类似的东西，flatStream()可以一步执行转换。我怎样才能做到这一点？

我目前的尝试：

Stream<Integer> stream = optionalStream.stream().flatMap(Function.identity());

问题的背景

在我的真实场景中，我有这样的东西，它给了我一个Stream<Optional<Foo>>：

stream.findFirst().map(e -> e.getChildren())

我希望避免多种if-else情况。下面的代码有更简洁的写法吗？

private Set<String> getValues(Optional<String> one, Optional<String> two) {
    if (one.isPresent() && two.isPresent()) {
        return ImmutableSet.of(one.get(), two.get());
    } else if (one.isPresent()) {
        return ImmutableSet.of(one.get());
    } else {
        return two.isPresent() ? ImmutableSet.of(two.get()) : ImmutableSet.of();
    }
}