k314159's questions

我想使用一个数据类，该数据类的属性在构造函数中具有基于另一个构造函数参数的默认值。如果我使用普通（非数据）类，它的工作方式完全符合我的要求：

import java.time.Clock
import java.time.Instant

class MyObject(
    clock: Clock = Clock.systemUTC(),
    val name: String,
    val timeCreated: Instant = clock.instant()
)

fun main() {
    val a = MyObject(name = "Fred")
    println(a.timeCreated)
}

但如果我尝试使其成为data class，它就不会编译：

Primary constructor of data class must only have property ('val' / 'var') parameters.

我不希望该clock参数成为属性，因为它仅用于测试。但我确实希望该类成为data class具有自动生成的toString和copy其他附加功能的一个类。我该怎么办？

我有一组属性src/main/resources/application.properties：

app.firstprop=2
app.secondprop=3
app.thirdprop=5
app.fourthprop=7

我想覆盖app.secondprop所有测试，同时保持其余属性不变。一种选择是：

@SpringBootTest(properties=["app.secondprop=99"])

但这意味着我必须在每个测试文件中重复这个属性值。

另一个选项是用来src/test/resources/application.properties覆盖我的属性文件。不幸的是，我必须指定所有未更改的属性以及被覆盖的属性：

app.firstprop=2
app.secondprop=99
app.thirdprop=5
app.fourthprop=7

如果我不指定未改变的属性，它们将不会在测试期间被定义。这又是不必要的重复。

如何覆盖所有测试的单个属性并遵守 DRY 原则？

我正在尝试以下代码进行性能检查。它纯粹是 CPU 密集型的，对类型进行大量计算double，单线程，并且不使用任何堆：

public class PerfTestSampleJ {
    private static final int MEASURE_COUNT = 5;
    private static final int ITERATIONS = 100_000_000;

    public static void main(String[] args) {
        var minTime = Long.MAX_VALUE;
        for (int i = 1; i <= MEASURE_COUNT; i++) {
            long start = System.nanoTime();
            double pi = calculatePi(ITERATIONS);
            long time = System.nanoTime() - start;
            System.out.printf("Iteration %2d took %8.3f ms%n", i, time / 1e6);
            if (time < minTime) {
                minTime = time;
            }
            if (Math.abs(pi - Math.PI) > 1e-14)
                throw new AssertionError(pi + " (" + (pi - Math.PI) + ")");
        }
        System.out.printf("Minimum time taken: %8.3f ms%n", minTime / 1e6);
    }

    private static double calculatePi(int iterations) {
        double pi = 0.0;
        double numerator = 4.0;
        for (int i = 1; i <= iterations; i++) {
            double n = i * 2.0;
            double denominator = n * (n + 1) * (n + 2);
            pi += numerator / denominator;
            numerator = -numerator;
        }
        return 3 + pi;
    }
}

现在，使用相同的编译类文件，比较在 JRE 21 和 JRE 23 下运行的结果：

/usr/lib/jvm/jdk-21.0.5-oracle-x64/bin/java PerfTestSampleJ
Iteration  1 took  801.058 ms
Iteration  2 took  798.392 ms
Iteration  3 took  414.688 ms
Iteration  4 took  413.959 ms
Iteration  5 took  416.867 ms
Minimum time taken:  413.959 ms

/usr/lib/jvm/jdk-23.0.1-oracle-x64/bin/java PerfTestSampleJ
Iteration  1 took  193.654 ms
Iteration  2 took  186.790 ms
Iteration  3 took  102.963 ms
Iteration  4 took  103.226 ms
Iteration  5 took  102.869 ms
Minimum time taken:  102.869 ms

在每次运行中，前两次迭代都有一个预热阶段，但第三次迭代及以后的速度几乎是最快的。

Java 23 中有哪些变化可以加快速度？查看发行说明时，我发现有关性能的所有信息都是垃圾收集器的改进。但我们这里不使用堆，因此垃圾收集器的改进无关紧要。

PS 以上结果是在使用 i7 处理器的 Ubuntu Linux x64 上得出的。我使用 Temurin 版本也得到了相同的结果。此外，我在 Windows x64 上尝试了 Oracle JRE 22 与 23，结果相似，显示性能差异在 22 和 23 之间。

我想在第三方库中调用一个函数：

fun foo(strings: Array<String>)

该数组strings仅用于读取，即foo不写入。

现在，我想编写一个自己的函数，如下所示：

fun bar(vararg vstrings: String) {
    do some things...
    foo(vstrings)
    do some more things...
}

但该foo(vstrings)调用导致编译错误：argument type mismatch: actual type is 'Array<CapturedType(out String)>', but 'Array<String>' was expected.

我无法更改的签名foo。如何将此 vararg 参数作为数组传递？

假设我有一个Sequence<Int>来源未知（不一定来自集合）且大小未知但有限的：

val seq = sequenceOf(1, 2, -3, 4, 5, /* ... */)

假设序列足够大，不希望将整个序列转换为List.

我想获取序列的最后一个元素：

val last = seq.last()

但我也想捕获可能出现的任何“无效”元素（假设负数无效）并返回第一个此类元素：

val invalid = seq.first { it < 0 }

但我怎样才能同时做这两件事呢？

val lastUnlessInvalidElementPresent = seq.firstOrNull { it < 0 } ?: seq.last()

问题是这?: seq.last()不起作用，因为当firstOrNull返回 null 时，整个序列已被消耗。

我可以迭代地执行此操作，但更喜欢功能性解决方案。