标签: java-8

基本上我有两个比较器(Comparator1和Comparator2),实现略有不同.两者都应按行的名称长度的降序对列表进行排序.

Comparator2似乎不适用于java7/java8.Comparator1始终有效.两者都适用于java 1.6实现,或者如果我设置-Djava.util.Arrays.useLegacyMergeSort = true.如果Comparator2中存在问题,则java应该抛出IllegalArgumentException,但不会抛出异常.

这在java文档中声明为"java.util.Arrays.sort使用的排序算法和java.util.Collections.sort(间接)使用的排序算法已被替换.如果新的排序实现检测到Comparable,则会抛出IllegalArgumentException违反可比较合约"

这是JRE中的错误还是Comparator2有问题？

public class Main {

public static void main(String[] args) {
    Row row1 = new Row("AAAA");
    Row row2 = new Row("BBB");
    Row row3 = new Row("CC");
    Row row4 = new Row("D");

    List<Row> list1 = new ArrayList<Row>();
    list1.add(row2);
    list1.add(row3);
    list1.add(row1);
    list1.add(row4);

    System.out.println("Before sorting:");
    System.out.println("");

    print(list1);

    Collections.sort(list1, new Comparator2());

    System.out.println("After sorting with comparator2:");
    System.out.println("");

    print(list1);

    Collections.sort(list1, new Comparator1());

    System.out.println("After sorting with comparator1:");
    System.out.println("");

    print(list1);

}

private static void print(List<Row> list) {
    for (Row row : list) …

streamToArray以下代码需要做什么？

IntStream stream = IntStream.range(0, 3);
int[] array = streamToArray(stream); // array = [0, 1, 2]

我正在用Java编写神经网络,而我在使用ArrayList.get()时没有返回变量.

    double train(ArrayList<Double> inputVector, double desiredOutput) {
    double result = output(inputVector);
    double error = desiredOutput - result;
    double delta = learningRate_ * error * result * (1.0 - result);
    for (int i = 0; i < outputLayer_.weights_.size(); i++) {
        outputLayer_.weights_.get(i).doubleValue() += delta * lastOutput_.get(i);
    }
    ArrayList<Double> hiddenDelta = new ArrayList<Double>();
    for (int j = 0; j < hiddenLayer_.size(); j++) {
        double HiddenDelta = delta * outputLayer_.weights_.get(j + 1) * lastOutput_.get(j + 1) * (1 - lastOutput_.get(j + 1));
        for (int …

我正在玩java 1.8.我读到新的集合api工作得更快,因为它在并行化的数据结构上运行操作.

我想看看这个efford.所以我写了下面的代码:

 public static void main(String[] args) {

    ArrayList<SamplePerson> persons = new ArrayList<>();

    for (long i = 0; i < 10000000; i++) {
        persons.add(new SamplePerson(EyeColour.BLUE,20,"Max Musterman",Gender.MALE));
    }

    long nsBefore = System.nanoTime();


    // using the new collection api - parallel way??
    persons.forEach(samplePerson -> samplePerson.setAge(22));

    //  sequential way
    for(int i = 0; i < persons.size(); i++){
        persons.get(i).setAge(22);
    }

    long nsAfter = System.nanoTime();

    long runtime = nsAfter - nsBefore;

    System.out.println("Time in Nanoseconds: " + runtime);      
}

我的处理器:i7-2600 CPU

使用"并行"方式的结果:以纳秒为单位的时间:74836825

使用顺序方式的结果:以纳秒为单位的时间:45071315

大家可以解释一下这个结果吗？建立这种威胁的开销是否很高？我有点困惑请帮帮我:-)

我试图用java lambda expresions替换现有的循环.

我有简单的数据结构,如下所示:

class DbObject{
    private Long objectId;

    private Long basedOnObjectId; //<- this field can be null

    public Long getObjectId() {
        return objectId;
    }

    public void setObjectId(Long objectId) {
        this.objectId = objectId;
    }

    public Long getBasedOnObjectId() {
        return basedOnObjectId;
    }

    public void setBasedOnObjectId(Long basedOnObjectId) {
        this.basedOnObjectId = basedOnObjectId;
    }
}

然后我有一个DbObjects列表

我尝试使用指定的basedOnObjectId过滤每个DbObject:

(1) list.stream().filter(object -> obejct.getBasedOnObjectId()
             .equals(basedOnObject.getObjectId()))
             .collect(Collector.of(List))

当然这个代码给了我NullPointer,因为有些od DbObject没有BasedOnObjectId因为它们是根.

很自然的事情是替换字段"Long basedOnObjectId;" 通过可选,但正如我在开始时提到的那样,现有的生产代码是不是快速修复.

所以我试着做一些改变,我评估下面的句子:

 Optional<Long> option = Optional.ofNullable(objectWithNullBasedOnId.getBasedOnObjectId());

并尝试使用.get()方法或.ifPresent(),但.get()也会抛出空指针异常,ifPresent不专用于使用流.

我注意到这一事实,当我有DbObject with null basedOnObjectId时,我不必检查值是否完全为null但只跳过此执行步骤.

所以我决定使用.orElse()方法并返回一些假值.在这种情况下,我返回0L值,因为这个索引在DB中不存在:)

所以我的代码:

 (2) List newList = …

需要逐行读取文本并根据对象Entity成员的值解析每个文本.我的实体有下一个构造函数签名:

public Entity(int id, String name, double weight)

文本文件有下一个内容:

ID,NAME,WEIGHT
1,Mario,80.2
2,Marco,91.1
...
100,Diego,78.12

使用新的Java 8:Files::readAllLines方法我的解决方案非常庞大:

public class CoolApp {

    private static final String SOURCE_FILE = "path/to/txt/file/entities.txt";

    private static final int ID     = 0;
    private static final int NAME   = 1;
    private static final int WEIGHT = 2;

    public static void main(String[] args) throws Exception {
        boolean isHeader = true;

        List<Entity> entities = new ArrayList<>();

        for (String line : Files.readAllLines(Paths.get(SOURCE_FILE))) {
            if (isHeader) {
                isHeader = …

假设我有一个天真的阶乘函数:

import java.util.stream.LongStream;

public class FactorialTest {

    static long factorial(long n, boolean parallel) {
        return (parallel
                ? LongStream.range(1, n).parallel()
                : LongStream.range(1, n))
                .reduce(1, (l, m) -> l * m);
    }

    public static void main(String[] args) {
        System.out.println(factorial(10, true));
    }
}

我觉得即使在单逻辑核心机器上,多线程减少仍然比单线程更快.如何使用流API对其进行测试或解决此问题？

是否有一种快速的方法来获取List< List<Double> >和平均它们所以我只有一个双列表,其中每列是该列中所有原始列表的平均值？

好吧,所以我注意到了(我假设由于安全漏洞)Java决定强迫人们让他们的java软件签名,传闻许可证价格在100美元到300美元之间.这应该取决于您经历的授权被许可人.然而,我正在学习JavaFX,如果我不能与世界免费分享我的软件,那么学习它有什么意义呢？

问题是在线或离线javafx应用程序是否也是如此？让我感到困扰的是,我可能需要自掏腰包支付现金并对我的软件进行测试和通过,以便对其进行验证,以便任何人都可以将其从计算机上运行.我开始考虑这个因为我刚刚开始我的第一个真正的JavaFX项目.这是一个扑克游戏,并将有各种风格的扑克,甚至可能包括二十一点.真的让我失望的是,除了我,有可能没有人会玩它.有人可以解释一下这个剧烈的变化以及它对开发人员的启动意味着什么？

我有一个java applet,它不能在64位系统上运行(浏览器和操作系统是64位),但在32位客户端系统上运行得非常好.为什么applet无法在64Bit客户端系统上执行？