k314159's questions

Quero usar uma classe de dados com uma propriedade que tenha um valor padrão no construtor com base em outro parâmetro do construtor. Funciona exatamente como eu quero se eu usar uma classe normal (não de dados):

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)
}

Mas se eu tentar fazer um data class, ele não compila:

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

Não quero que o clockparâmetro seja uma propriedade, pois ele é usado apenas para testes. Mas quero que a classe seja a data classcom seu autogerado toString, copye outros recursos. O que posso fazer?

Tenho um conjunto de propriedades em src/main/resources/application.properties:

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

E eu quero substituir app.secondproptodos os meus testes, mantendo as propriedades restantes inalteradas. Uma opção é:

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

mas isso significa que tenho que repetir esse valor de propriedade em cada arquivo de teste.

Outra opção é usar src/test/resources/application.propertiespara sobrescrever meu arquivo de propriedades. Infelizmente, tenho que especificar todas as propriedades inalteradas, bem como a propriedade sobrescrita:

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

Se eu não especificar as propriedades inalteradas, elas não serão definidas durante os testes. Isso novamente é uma repetição indesejada.

Como posso substituir uma única propriedade para todos os testes e manter o princípio DRY?

Estou tentando o seguinte código para verificação de desempenho. Ele é puramente limitado pela CPU, faz muitos cálculos em doubletipos, single-threaded e não usa nenhum heap:

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;
    }
}

Agora, usando o mesmo arquivo de classe compilado, compare os resultados ao executar no JRE 21 versus 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

Em cada execução, há uma fase de aquecimento nas duas primeiras iterações, mas a partir da iteração 3 é o mais rápido possível.

O que mudou no Java 23 para tornar isso mais rápido? Ao olhar as notas de lançamento, tudo o que consigo encontrar sobre desempenho são melhorias no coletor de lixo. Mas não estamos usando o heap aqui, então a melhoria do coletor de lixo é irrelevante.

PS Os resultados acima são no Ubuntu Linux x64 usando um processador i7. Obtenho os mesmos resultados usando versões Temurin. Além disso, tentei Oracle JRE 22 vs 23 no Windows x64 com resultados semelhantes, mostrando que a diferença de desempenho está entre 22 e 23.

Há uma função que desejo chamar em uma biblioteca de terceiros:

fun foo(strings: Array<String>)

O array stringsé usado apenas para leitura, ou seja, foonão grava nele.

Agora, quero escrever uma função minha, assim:

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

Mas a foo(vstrings)chamada resulta em um erro de compilação:argument type mismatch: actual type is 'Array<CapturedType(out String)>', but 'Array<String>' was expected.

Não consigo alterar a assinatura de foo. Como posso passar esse parâmetro vararg como um array?

Digamos que eu tenha uma Sequence<Int>origem desconhecida (não necessariamente de uma coleção) e de tamanho desconhecido, mas finito:

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

Suponha que a sequência seja grande o suficiente para tornar indesejável transformar toda a sequência em um arquivo List.

Quero obter o último elemento da sequência:

val last = seq.last()

Mas também quero capturar qualquer elemento "inválido" que possa aparecer (digamos que números negativos sejam inválidos) e retornar o primeiro elemento:

val invalid = seq.first { it < 0 }

Mas como posso fazer as duas coisas ao mesmo tempo?

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

O problema é que ?: seq.last()não funciona porque quando o tempo firstOrNullretorna nulo, toda a sequência já foi consumida.

Posso fazer isso iterativamente, mas preferiria uma solução funcional.