小编aku*_*ykh的帖子

我看过这个问题，但还有几个关于assert关键字用法的问题。我正在与其他一些编码人员讨论如何使用assert. 对于此用例，有一种方法可以在满足某些先决条件时返回 null。我编写的代码调用该方法，然后断言它不返回 null，并继续使用返回的对象。

例子：

class CustomObject {
    private Object object;

    @Nullable
    public Object getObject() {
        return (object == null) ? generateObject() : object;
    }
}

现在想象我像这样使用它：

public void useObject(CustomObject customObject) {
    object = customObject.getObject();
    assert object != null;
    // Do stuff using object, which would throw a NPE if object is null.
}

有人告诉我应该删除assert，它们不应该用于生产代码，只能用于测试。真的吗？

我在 main 方法中执行如下：

int secrete = 42;
for (int i = 0; i < 5; i++) {
    Consumer<String> myprinter2 =
                    msg -> {
                        System.out.println("consuming " + msg + " ," + secrete);
                    };
     myprinter2.accept(myprinter2.toString());
}

上述代码的输出是：

int secrete = 42;
for (int i = 0; i < 5; i++) {
    Consumer<String> myprinter2 =
                    msg -> {
                        System.out.println("consuming " + msg + " ," + secrete);
                    };
     myprinter2.accept(myprinter2.toString());
}

如果我改为secretefinal，那么输出是：

consuming Main$$Lambda$1/1324119927@6d311334 ,42
consuming Main$$Lambda$1/1324119927@682a0b20 ,42
consuming Main$$Lambda$1/1324119927@3d075dc0 ,42 …

在Java中，我有两个不同的语句，它们通过使用三元运算符来完成相同的结果，如下所示：

1. num < 0 ? 0 : num;
2. num * (num < 0 ? 0 : 1);

看起来第二个语句不必要地复杂并且比第一个语句花费的时间更长，但是当我使用以下代码记录每个花费的时间时，结果如下：

final long startTime = System.currentTimeMillis();

Random rand = new Random();
float[] results = new float[100000000];
for (int i = 0; i < 100000000; i++) {
    float num = (rand.nextFloat() * 2) - 1;
    results[i] = num < 0 ? 0 : num;
    //results[i] = num * (num < 0 ? 0 : 1);
}

final long endTime = System.currentTimeMillis();

System.out.println("Total Time: " …

由于该方法show()已被弃用，此代码是不好的做法吗？在这里覆盖可以吗？

public class Window extends JFrame {

    public Window() {
        // Do things.
    }

    public void show() { // <- Comes up with a warning as deprecated code.
        // Do other things.
    }
}

我找不到任何好的来源来解释原因：

abstract class AA {
    public static void log() {}
}

class BB extends AA {
    public void log() {} //error
}

interface CC {
    public static void log() {}
}

class DD implements CC {
    public void log() {} //Ok
}

我尝试在 Windows 10 上手动安装 java 14。我按照这张图片设置系统变量。

但是当我使用命令“java -version”时，实际上什么也没有发生......

C:\WINDOWS\system32>java -version

C:\WINDOWS\system32>

肯定有什么地方出了问题，但我不知道是什么......

GraphQL 的主要目标是解决许多 REST API 面临的过度获取问题，它通过仅查询查询中提到的特定字段来实现这一点。

但在 REST API 中，如果我们使用fields参数，它也会做同样的事情。那么如果 REST 可以解决这样的过度获取问题，为什么还需要 GraphQL呢？

参考Java 的 Fork/Join vs ExecutorService - 何时使用哪个？，一个传统的线程池通常用于处理很多独立的请求；和 aForkJoinPool用于处理连贯/递归任务，其中一个任务可能会产生另一个子任务并稍后加入。

那么，为什么默认parallelStream使用Java-8ForkJoinPool而不是传统的执行器呢？

在很多情况下，我们forEach()在stream()orparallelStream()之后使用，然后提交一个功能接口作为参数。在我看来，这些任务是独立的，不是吗？

在下面的例子中，由于主线程没有得到子线程的通知，它应该永远等待。但是主线程正在执行，下面示例的输出是：

c
l
total: 19900

为什么主线程被执行？

c
l
total: 19900

想象一下这些版本中的一个函数：

int faculty(const unsigned int n) {
    return n == 1 ? n : n * faculty(n - 1);
}

int faculty(const unsigned int n) {
    return n == 1 ? 1 : n * faculty(n - 1);
}

唯一的区别是我n在第一个和1第二个中返回，具体取决于n. 结果是相同的，但是在忽略重要性的同时，您是否可以意识到其他任何差异？

我知道编译器很有可能会从中生成相同的汇编指令，但是嘿，我只是好奇。

想象一下这些版本中的一个函数：

    static int fibonacciIterative(int n) {
        int previous = 0;
        int current = 1;
        for (int i = 1; i < n; i++) {
            int temp = current;
            current += previous;
            previous = temp;
        }
        return current;
    }

    static int fibonacciIterative(int n) {
        int previous = 0;
        int current = 1;
        int temp;
        for (int i = 1; i < n; i++) {
            temp = current;
            current += previous;
            previous = temp;
        }
        return current;
    }

唯一的区别是变量temp声明一次又一次地 …

我环顾了不同的来源：

• 在 Java 中创建随机颜色？
• 如何在 Java 中创建随机颜色
• 如何在 Java 中随机化颜色？
• “随机颜色生成器javascript堆栈溢出”代码答案

但是，这些答案都不是我正在寻找的。

我想要做的是获得 2 种颜色范围内的随机颜色，例如紫色和粉红色。对于紫色#6A0DAD和粉红色#FFC0CB，我想在这两种颜色的范围内抓取一种颜色，但要随机一种。所以我会得到例如#D982B5，这是品红色粉红色。

到目前为止，除了制作随机数之外，我不知道从哪里开始。

想象一下下面的程序。

class Main {


    static class Whatever {
        int x = 0;
    }


    public static void main(String[] args) {
        Whatever whatever = new Whatever();

        Thread t = new Thread(() -> {
            whatever.x = 1;
        });
        t.start();
        try {
            t.join();
        }
        catch (InterruptedException e) {
        }

        System.out.println(whatever.x);
    }
}

主线程已缓存whatever并x设置为0。另一个线程启动、缓存whatever并将缓存设置x为1.

输出是

1

所以主线程已经看到了写入。这是为什么？

为什么写入共享缓存，为什么主线程使其缓存失效以从共享缓存读取？为什么我不需要volatile这里？