Nenhum resultado ao filtrar em um IntStream aleatório, em Java

Infinito Streampode ser loop infinito

Você inadvertidamente fez um loop infinito do seu infinito IntStream.

Seu IntStreamcriado por ThreadLocalRandom.intsé infinito, gerando continuamente um número aleatório após o outro, dentro do seu intervalo definido. Duplicatas podem ocorrer, pois o número aleatório continua gerando até que seu fluxo alcance uma operação terminal.

Você ligou findAnypara encerrar seu fluxo. Mas olhe para seus dados de amostra. Todas as suas tartarugas são jovens, onde nenhuma delas tem uma idade que atenda ao seu IntPredicateteste de exceder a MATURITYduração. Então nenhuma das suas tartarugas passa no teste de idade. Então o findAnynunca encontra nenhum Turtle, então ele nunca retorna nenhum Optional < Turtle >.

Isso significa que a geração de números aleatórios continua moendo, produzindo um número de índice após o outro. Para cada número aleatório, acessamos os Listobjetos Turtle. Mas nenhum passa no nosso teste de predicado. Portanto, nosso fluxo nunca termina . Esta rotina de teste de predicado random-generator -> List#get-> continua infinitamente. O fluxo nunca termina, neste loop infinito, dando a aparência de que nada está acontecendo. Na verdade, muita coisa está acontecendo, com um núcleo de CPU muito ocupado gerando números, acessando a lista e calculando e comparando durações, infinitamente.

Podemos demonstrar isso alterando seus dados de amostra. Inicie os peixes Bob& Daviscom hatch-dates de 7 minutos atrás em vez de 2 minutos. Execute seu código novamente para ver que qualquer um deles é escolhido aleatoriamente, e escolhido bem rápido.

        List < Turtle > turtles =
                List.of (
                        new Turtle ( "Alice" , Instant.now ( ).truncatedTo ( ChronoUnit.MINUTES ).minus ( Duration.ofMinutes ( 3 ) ) , Duration.ofMinutes ( 17 ) ) ,
                        new Turtle ( "Bob" , Instant.now ( ).truncatedTo ( ChronoUnit.MINUTES ).minus ( Duration.ofMinutes ( 7 ) ) , Duration.ofMinutes ( 16 ) ) ,
                        new Turtle ( "Carol" , Instant.now ( ).truncatedTo ( ChronoUnit.MINUTES ).minus ( Duration.ofMinutes ( 1 ) ) , Duration.ofMinutes ( 18 ) ) ,
                        new Turtle ( "Davis" , Instant.now ( ).truncatedTo ( ChronoUnit.MINUTES ).minus ( Duration.ofMinutes ( 7 ) ) , Duration.ofMinutes ( 22 ) )
                );

anArbitraryMatureTurtle = Opcional[Tartaruga[nome=Davis, chocado=2024-12-23T21:17:00Z, tempo de vida=PT22M]]

Solução

Não há solução para consertar diretamente seu código atual ^† . Você não pode usar um fluxo infinito sem uma terminação garantida.

Em vez disso, você deve reescrever seu código.

Uma reescrita poderia ser fazer uma cópia de seus Listobjetos Turtle. Embaralhe-os, colocando a lista em ordem aleatória. Então transmita essa lista randomizada até que uma seja encontrada atendendo às condições do seu teste de predicado. Se nenhuma atender a essas condições, o fluxo termina após verificar exaustivamente cada elemento, e um vazio Optionalserá retornado.

Altere sua seção Lógica para isto:

        // Logic
        List < Turtle > turtlesShuffled = new ArrayList <> ( turtles );
        Collections.shuffle ( turtlesShuffled );
        Optional < Turtle > anArbitraryMatureTurtle =
                turtlesShuffled
                        .stream ( )
                        .filter (
                                turtle -> turtle.age ( ).compareTo ( Turtle.MATURITY ) > 0
                        )
                        .findAny ( );

Não há mais índice aleatório.

Quando executado com todas as tartarugas jovens e imaturas:

anArbitraryMatureTurtle = Opcional.vazio

Essa mesma lógica poderia ser feita com um forloop convencional em vez de um Stream. Acho que a Streamsintaxe é mais expressiva neste caso em particular.

        // Logic
        List < Turtle > turtlesShuffled = new ArrayList <> ( turtles );
        Collections.shuffle ( turtlesShuffled );
        Optional < Turtle > anArbitraryMatureTurtle = Optional.empty ( );
        for ( Turtle turtle : turtlesShuffled )
        {
            if ( turtle.age ( ).compareTo ( Turtle.MATURITY ) > 0 )
            {
                anArbitraryMatureTurtle = Optional.of ( turtle );
                break;
            }
        }

Embaralhar uma coleção inteira provavelmente não é tão eficiente quanto escolher um índice aleatoriamente. Essa pode ter sido sua motivação original ao escolher a abordagem de índice aleatório. Mas, dados seus possíveis valores de dados, a abordagem de índice aleatório não é viável.

^† Errado… há uma solução que corrige essa abordagem de fluxo de números de índice aleatórios. Veja a resposta correta de tquadrat .

Tente isso para a seção Logicmain() no seu método, adicionando chamadas para Stream#distincte Stream#limit. Dessa forma, cobrimos todos os valores de índice possíveis uma vez, em uma ordem aleatória.

…
// Logic
Optional<Turtle> anArbitraryMatureTurtle = ThreadLocalRandom.current()
  .ints( 0, turtles.size() )
  .distinct()
  .limit( turtles.size() )
  .filter( (int randomIndex) -> turtles.get( randomIndex ).age().compareTo( Turtle.MATURITY ) > 0 )
  .mapToObj( turtles::get )
  .findAny();
System.out.println( "anArbitraryMatureTurtle = " + anArbitraryMatureTurtle );
…

Se nenhum Turtlepassar no teste, obtemos um . vazio Optional.

A sequência de código:

ThreadLocalRandom.current()
  .ints( 0, 5 )
  .distinct()
  .limit( 5 )
  .forEach( System.out::println );

… imprime os cinco valores 0em 4uma ordem aleatória – sempre cinco, sem duplicatas. Claro que você tem que usar turtles.size()para seu caso de uso em vez da constante 5.

Tenho algumas dúvidas de que esta seja a maneira mais eficiente de obter uma tartaruga adulta aleatória da sua lista (considerando que existe uma), mas funciona.