相关疑难解决方法(0)

在Java 8中,以下哪项更好？

Java 8:

joins.forEach(join -> mIrc.join(mSession, join));

Java 7:

for (String join : joins) {
    mIrc.join(mSession, join);
}

我有很多可以用lambdas"简化"的for循环,但使用它们真的有什么好处吗？它会改善他们的性能和可读性吗？

编辑

我还将这个问题扩展到更长的方法.我知道你不能从lambda中返回或破坏父函数,在比较它们时也应该考虑到这一点,但还有什么需要考虑的吗？

我有一个返回的界面java.lang.Iterable<T>.

我想使用Java 8 Stream API来操纵该结果.

但是Iterable不能"流".

知道如何将Iterable用作Stream而不将其转换为List吗？

我想知道为什么Iterable界面不提供stream()和parallelStream()方法.考虑以下课程:

public class Hand implements Iterable<Card> {
    private final List<Card> list = new ArrayList<>();
    private final int capacity;

    //...

    @Override
    public Iterator<Card> iterator() {
        return list.iterator();
    }
}

这是一个Hand的实现,因为你可以在玩卡片游戏时手中拿着牌.

基本上它包装a List<Card>,确保最大容量并提供一些其他有用的功能.最好直接实现它作为一个List<Card>.

现在,为了方便起见,我认为实现它会很好Iterable<Card>,这样如果你想循环它就可以使用增强的for循环.(我的Hand班级也提供了一种get(int index)方法,因此Iterable<Card>在我看来是合理的.)

该Iterable接口提供以下内容(省略javadoc):

public interface Iterable<T> {
    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator<T> …

与C#不同IEnumerable,执行管道可以根据需要执行多次,在Java中,流只能"迭代"一次.

对终端操作的任何调用都会关闭流,使其无法使用.这个"功能"消耗了很多力量.

我想这个的原因不是技术性的.这个奇怪限制背后的设计考虑是什么？

编辑:为了演示我在说什么,请考虑以下C#中的Quick-Sort实现:

IEnumerable<int> QuickSort(IEnumerable<int> ints)
{
  if (!ints.Any()) {
    return Enumerable.Empty<int>();
  }

  int pivot = ints.First();

  IEnumerable<int> lt = ints.Where(i => i < pivot);
  IEnumerable<int> gt = ints.Where(i => i > pivot);

  return QuickSort(lt).Concat(new int[] { pivot }).Concat(QuickSort(gt));
}

现在可以肯定的是,我并不是说这是一个很好的快速排序!然而,它是lambda表达式与流操作相结合的表达能力的一个很好的例子.

它不能用Java完成!我甚至无法询问流是否为空而不使其无法使用.

假设我有一个类和一个方法

class A {
  void foo() throws Exception() {
    ...
  }
}

现在我想为A一个流传递的每个实例调用foo,如:

void bar() throws Exception {
  Stream<A> as = ...
  as.forEach(a -> a.foo());
}

问题:如何正确处理异常？代码无法在我的机器上编译,因为我没有处理foo()可能抛出的异常.在throws Exception的bar似乎是没用在这里.这是为什么？

我有这个代码:

List<String> strings = Arrays.asList("a", "b", "cc");
for (String s : strings) {
    if (s.length() == 2)
        System.out.println(s);
}

我想用过滤器和lambda来编写它:

for (String s : strings.stream().filter(s->s.length() == 2)) {
    System.out.println(s);
}

我得到Can only iterate over an array or an instance of java.lang.Iterable.

我尝试:

for (String s : strings.stream().filter(s->s.length() == 2).iterator()) {
    System.out.println(s);
}

我得到了同样的错误.这甚至可能吗？我真的不想做stream.forEach()并传递消费者.

编辑:对我来说重要的是不要复制元素.

假设我有一个java.util.stream.Stream带有一些好toString方法的对象:将这个流写入文件的最短/最优雅的解决方案是什么,每个流元素一行？

对于阅读,有一个很好的Files.lines方法,所以我认为必须有一个对称的方法来写入文件,但找不到. Files.write只需要一个可迭代的.

在Java 8中,Stream该类没有任何方法来包装Iterable.

相反,我Spliterator从这里Iterable获得了,然后Stream从StreamSupport这样获得一个:

boolean parallel = true;

StreamSupport.stream(spliterator(), parallel)
                .filter(Row::isEmpty)
                .collect(Collectors.toList())
                .forEach(this::deleteRow);

是否有产生的一些其他的方式Stream上的操作Iterable,我很想念？

Stream继承一个iterator()方法来生成一个Iterator.

但我需要一个Iterable而不是一个Iterator.

例如，给定这个字符串：

String input = "this\n" +
        "that\n" +
        "the_other";

...我需要将字符串的这些部分作为 anIterable传递给特定的库。调用input.lines()产生一个Stream. 所以如果我能把它Stream变成Iterable它的一个元素，我会很高兴的。

假设我们尝试向java 8流应用一个可能抛出已检查异常的lambda:

Stream<String> stream = Stream.of("1", "2", "3");
Writer writer = new FileWriter("example.txt");

stream.forEach(s -> writer.append(s)); // Unhandled exception: java.io.IOException

这不会编译.

一种解决方法是嵌套已检查的异常,RuntimeException但它使以后的异常处理变得复杂,而且它只是丑陋:

stream.forEach(s -> {
    try {
        writer.append(s);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
});

另一种解决方法可能是转换有限的功能forEach,以普通的旧的foreach 循环是比较友好的检查的异常.

但天真的方法失败了:

for (String s : stream) { // for-each not applicable to expression type 'java.util.stream.Stream<java.lang.String>'
    writer.append(s);
}

for (String s : stream.iterator()) { // foreach not applicable to type 'java.util.Iterator<java.lang.String>'
    writer.append(s);
} …