小编gon*_*ard的帖子

我正在寻找一种简洁的方法来将Iterator一个Stream或更具体的转换为"视图"迭代器作为流.

出于性能原因,我想在新列表中避免使用迭代器的副本:

Iterator<String> sourceIterator = Arrays.asList("A", "B", "C").iterator();
Collection<String> copyList = new ArrayList<String>();
sourceIterator.forEachRemaining(copyList::add);
Stream<String> targetStream = copyList.stream();

根据评论中的一些建议,我也尝试使用Stream.generate:

public static void main(String[] args) throws Exception {
    Iterator<String> sourceIterator = Arrays.asList("A", "B", "C").iterator();
    Stream<String> targetStream = Stream.generate(sourceIterator::next);
    targetStream.forEach(System.out::println);
}

但是,我得到了NoSuchElementException(因为没有调用hasNext)

Exception in thread "main" java.util.NoSuchElementException
    at java.util.AbstractList$Itr.next(AbstractList.java:364)
    at Main$$Lambda$1/1175962212.get(Unknown Source)
    at java.util.stream.StreamSpliterators$InfiniteSupplyingSpliterator$OfRef.tryAdvance(StreamSpliterators.java:1351)
    at java.util.Spliterator.forEachRemaining(Spliterator.java:326)
    at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
    at Main.main(Main.java:20)

我已经看过StreamSupport和Collections,但我没有发现任何东西.

我想把一个转换anonymous class成一个lambda expression.但这个匿名类我使用this关键字.

例如,我写了这个简单的Observer/Observable模式:

import java.util.ArrayList;
import java.util.Collection;

public static class Observable {
    private final Collection<Observer> notifiables = new ArrayList<>();

    public Observable() { }

    public void addObserver(Observer notifiable) { notifiables.add(notifiable); }
    public void removeObserver(Observer notifiable) { notifiables.add(notifiable); }

    public void change() {
        notifiables.forEach(notifiable -> notifiable.changed(this));
    }
}

public interface Observer {
    void changed(Observable notifier);
}

这个带有匿名类的示例代码(使用this关键字):

public class Main {

    public static void main(String[] args) {
        Observable observable = new Observable();
        observable.addObserver(new …

有没有办法自动转换这个静态方法调用(Arrays.asList):

import java.util.Arrays;
import java.util.List;

public class StaticImport {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("hello", "world");
        System.out.println(list);
    }
}

使用以下命令进行此调用static import:

import static java.util.Arrays.asList;

import java.util.List;

public class StaticImport {
    public static void main(String[] args) {
        List<String> list = asList("hello", "world");
        System.out.println(list);
    }
}

我知道我可以使用此配置代码完成Window » Preferences » Java » Editor » Content Assist » Favorites,如本答案中所述.

我的问题是关于转换现有的静态方法调用.理想情况下,我不想配置"最喜欢的导入".

我的应用程序需要预先注册的数据集才能工作.所以我需要在设置应用程序时将它们插入数据库中.

Laravel提出了两种机制:

• 数据库迁移:"它们允许团队修改数据库模式并在当前模式状态下保持最新."
• 数据库播种:"Laravel还包括一种使用种子类为测试数据播种数据库的简单方法."

当我读到这个描述时,这些解决方案似乎都没有适应.

在stackoverflow上已经提出了类似的问题并回答了问题.答案建议使用数据库播种器通过检测当前环境来填充数据库:

<?php

class DatabaseSeeder extends Seeder {

    public function run()
    {
            Eloquent::unguard();

            if (App::environment() === 'production')
            {
                $this->call('ProductionSeeder');
            }
            else
            {
                $this->call('StagingSeeder');
            }
    }

}

当然,这个解决方案有效.但我不确定这是否是正确的方法,因为通过使用播种机插入数据,您将失去迁移机制提供的所有优势(数据库升级,回滚......)

我想知道在这种情况下最佳做法是什么.

在java 8中,只有一个抽象方法的抽象类不是函数接口(JSR 335).

这interface是一个功能界面:

public interface MyFunctionalInterface {
    public abstract void myAbstractMethod();
    public default void method() {
        myAbstractMethod();
    }
}

但这abstract class不是:

public abstract class MyFunctionalAbstractClass {
    public abstract void myAbstractMethod();
    public void method() {
        myAbstractMethod();
    }
}

所以我不能使用抽象类作为lambda表达式和方法引用的目标.

public class Lambdas {
    public static void main(String[] args) {
        MyFunctionalAbstractClass functionalAbstractClass = () -> {};
    }
}

编译错误是:The target type of this expression must be a functional interface.

为什么语言设计师强加了这个限制？

为什么编译器能够String在函数返回类型的情况下正确推断类型参数.

public class Generics {
    private static List<String> function() {
        return new ArrayList<>();
    }
}

但是当要推断的类型是方法参数时它会失败:

public class Generics {
    public static void main(String[] args) {
        method(new ArrayList<>());
    }    

    private static void method(List<String> list) {

    }
}

这种情况下的错误是:

The method method(List<String>) in the type Generics is not applicable 
for the arguments (ArrayList<Object>)

有没有办法用java 8填充数组Supplier？

我想写:

Supplier<Object> supplier = () -> new Object();
Object[] array = new Object[size];
Arrays.fill(array, supplier);

注意:我知道我可以编写自己的方法.

这段代码示例

Collection<Number> values = transform(
        getValuatedObjects(),
        input -> getValueProvider().apply(input).getValue());

违反了声纳规则:

尽可能用方法引用替换lambdas

它是声纳虫吗？或者我真的可以使用方法参考吗？

我使用一个库,其中一个抽象类覆盖了一个从Object抽象方法继承的具体方法:

public abstract class A {
    @Override
    public abstract boolean equals(Object obj);
}

要扩展此类,我必须实现该equals方法:

public class B extends A {
    @Override
    public boolean equals(Object obj) {
        return obj != null && obj.getClass() == B.class;
    }
}

为什么抽象方法(A::equals)会覆盖具体方法(Object::equals)？我没有看到这个目标.

我希望在javafx 2.2中或至少在javafx 8中执行类似的操作.我浏览了没有结果的Text javadoc和css引用.

可以通过在WebView中显示和svg来实现此效果.但我的应用程序必须显示大量具有此效果的文本.WebView是一个太重的组件,用于绘制具有此效果的文本.

我在oracle技术网络上问了同样的问题.