我想在一个带有Optional的前缀中添加一个流.既然Stream.concat只能连接Streams我有这个问题:
如何将Optional <T>转换为Stream <T>？
例:
Optional<String> optional = Optional.of("Hello");
Stream<String> texts = optional.stream(); // not working
使用Java 8流,当输入Integer没有输出时,映射a 的最佳方法是什么List<Integer>？
只需返回null？但现在我的输出列表大小将小于我的输入大小...
List<Integer> input = Arrays.asList(0,1,2,3);
List<Integer> output = input.stream()
.map(i -> {
Integer out = crazyFunction(i);
if(out == null || out.equals(0))
return null;
return Optional.of(out);
})
.collect(Collectors.toList());
我喜欢自选是在Java标准库现在.但是我仍然遇到一个基本问题,我还没有弄清楚如何以最好的方式解决(最容易阅读和理解,最漂亮,最短)的方式:
当可选项为空时如何从方法返回？
我正在寻找一个通用的解决方案,适用于选项数和代码块大小的不同组合.
在下面的例子中,我将尝试展示我的意思:
void m1() {
// When I get an optional:
Optional<String> o = getOptional();
// And want to return if it's empty
if (!o.isPresent()) return;
// In the whole rest of the method I have to call Optional.get
// every time I want the value:
System.out.println(o.get());
// Which is pretty ugly and verbose!
}
void m2() {
// If I instead return null if a value is absent:
String s = getNullabe();
if (s == …使用Java 8 lambdas,有效创建新的List<T>给定的List<K>密钥和"a "的"最佳"方法是Map<K,V>什么？在这种情况下,您将获得一些List可能的Map键,并且应该生成一个List<T>where T,这是基于Vmap值类型的某些方面构造的某种类型.
我已经探索了一些并且感到不舒服声称一种方式比另一种方式更好(可能有一个例外 - 参见代码).我将澄清"最佳"作为代码清晰度和运行时效率的组合.这些是我想出来的.我相信有人可以做得更好,这是这个问题的一个方面.我不喜欢filter大多数方面,因为它意味着需要创建中间结构和多次传递名称List.现在,我选择了例6 - 一个简单的'ol循环.(注意:代码注释中有一些神秘的想法,特别是"需要外部引用......"这意味着从lambda外部.)
public class Java8Mapping {
private final Map<String,Wongo> nameToWongoMap = new HashMap<>();
public Java8Mapping(){
List<String> names = Arrays.asList("abbey","normal","hans","delbrook");
List<String> types = Arrays.asList("crazy","boring","shocking","dead");
for(int i=0; i<names.size(); i++){
nameToWongoMap.put(names.get(i),new Wongo(names.get(i),types.get(i)));
}
}
public static void main(String[] args) {
System.out.println("in main");
Java8Mapping j = new Java8Mapping();
List<String> testNames = Arrays.asList("abbey", "froderick","igor");
System.out.println(j.getBongosExample1(testNames).stream().map(Bongo::toString).collect(Collectors.joining(", "))); …有没有更优雅的方法在Java 8中实现这一目标？
list.stream()
.map(e -> myclass.returnsOptional(e))
.filter(Optional::isPresent)
.map(Optional::get)
.collect(Collectors.toList());
我正在谈论filter(Optional::isPresent)随后map(Optional::get),我想优雅地在列表中收集Optional具有值的结果.
我正在玩下面的问题:在Stream :: flatMap中使用Java 8的Optional,并希望将一个方法添加到自定义中Optional<T>,然后检查它是否有效.
更准确地说,我想添加一个stream()我的CustomOptional<T>,如果没有值,则返回一个空流,或者如果存在,则返回一个包含单个元素的流.
但是,我得出的结论Optional<T>是宣布为最终结论.
为什么会这样？有很多类没有被声明为final,我个人认为没有理由宣布Optional<T>final.
作为第二个问题,为什么所有的方法都不能是最终的,如果担心它们会被覆盖,并且让课程不是最终的？
该IntStream班有map(),mapToObj(),mapToLong()和mapToDouble()方法,但这些方法似乎是从丢失OptionalInt类.
是否有充分的理由让这些方法丢失？
我有一段代码,其中一个接口有一个Optional返回方法,一些类实现它返回一些东西,其他没有.
为了拥抱这个辉煌的"空杀手",这是我尝试过的:
public interface Gun {
public Optional<Bullet> shoot();
}
public class Pistol implements Gun{
@Override
public Optional<Bullet> shoot(){
return Optional.of(this.magazine.remove(0));
}//never mind the check of magazine content
}
public class Bow implements Gun{
@Override
public Optional<Bullet> shoot(){
quill--;
return Optional.empty();
}
}
public class BallisticGelPuddy{
private Gun[] guns = new Gun[]{new Pistol(),new Bow()};
private List<Bullet> bullets = new ArrayList<>();
public void collectBullets(){
//here is the problem
for(Gun gun : guns)
gun.shoot.ifPresent(bullets.add( <the return I got with the method>)
}} …有一个可选的可选列表，例如：
Optional<List<Optional<String>>> optionalList = Optional.of(
Arrays.asList(
Optional.empty(),
Optional.of("ONE"),
Optional.of("TWO")));
如何遍历optionalList以打印出字符串的ONEand TWO？
有一个可选的可选流怎么样？
Optional<Stream<Optional<String>>> optionalStream = Optional.of(
Stream.of(
Optional.empty(),
Optional.of("ONE"),
Optional.of("TWO")));
更新：感谢您的回答，optionalStream 的解决方案（非嵌套）：
optionalStream
.orElseGet(Stream::empty)
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(System.out::println);
我有以下一些简化的代码无法编译,我不明白为什么:
List<Optional<Integer>> list =
new ArrayList<>();
List<Integer> flattened =
list
.stream()
.flatMap(i -> i)
.collect(Collectors.toList());
编译器告诉我:
[ERROR] ... incompatible types: cannot infer type-variable(s) R
[ERROR] (argument mismatch; bad return type in lambda expression
[ERROR] Optional<Integer> cannot be converted to Stream<? extends R>)
[ERROR] where R,T are type-variables:
[ERROR] R extends Object declared in method <R>flatMap(Function<? super T,? extends Stream<? extends R>>)
[ERROR] T extends Object declared in interface Stream
我承认我不习惯Java,但我必须参与一个项目.我在Scala中嘲笑了这一点,list.flatten并且list.flatMap(i => i)正如预期的那样等效工作:
val list = List(Some(1), …