Início / coding / Perguntas / 79555977
Accepted
Shiladittya Chakraborty
Asked: 2025-04-05 01:42:47 +0800 CST

Recursos de visualização do Java 24 Não é possível acessar

  • 772

Estou tentando acessar os recursos do Java 24. Mas não consigo acessar. Estou usando o programa abaixo

public static void main(String[] args) {
        Stream.of("apple", "banana", "kiwi")
              .gather((word, out) -> {
                  for (char ch : word.toCharArray()) {
                      if (Character.isLowerCase(ch)) {
                          out.accept(ch); // emit each lowercase letter
                      }
                  }
              })
              .forEach(System.out::println);
    }

Mas está me dando a exceção de tempo de compilação abaixo

The method gather(Gatherer<? super String,?,R>) in the type Stream<String> is not applicable for the arguments ((<no type> word, <no type> out) -> {})

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
    The method gather(Gatherer<? super String,?,R>) in the type Stream<String> is not applicable for the arguments ((<no type> word, <no type> out) -> {})
    Lambda expression's signature does not match the signature of the functional interface method integrator()

Eu habilitei os recursos de visualização nas propriedades

insira a descrição da imagem aqui

Mas ainda não é possível executar recursos de visualização. Estou esquecendo de algo aqui?

Estou usando a versão mais recente do Eclipse, 2025-03, 4.35

java

2 respostas

  1. Best Answer

    Os coletores não são mais um recurso de visualização no Java 24. O problema é que você está usando um lambda não compatível.

    Gatherer é uma interface funcional, mas o único método que você deve implementar é integrator(). Isso não requer argumentos. O integrador em si também pode ser definido como um lambda e leva não 2, mas 3 argumentos: o estado intermediário, o elemento e o downstream. Em outras palavras (e já que o estado intermediário não é usado, vamos deixar isso claro usando _):

    Stream.of("apple", "banana", "kiwi").gather(() -> (_, word, downstream) -> {
    for (char ch : word.toCharArray()) {
        if (Character.isLowerCase(ch)) {
            downstream.push(ch);
        }
    }
    return true;
}).forEach(System.out::println);

    Ligeiramente melhorado para fazer melhor uso de um possível falseretorno de downstream.push(não há necessidade de enviar se o downstream não quiser mais dados):

    Stream.of("apple", "banana", "kiwi").gather(() -> (_, word, downstream) -> word.chars()
        .filter(Character::isLowerCase)
        .allMatch(ch -> downstream.push((char) ch))
).forEach(System.out::println);

    Agora, isso não fica bonito com o lambda aninhado, então eu usaria o método de fábrica estático:

    Stream.of("apple", "banana", "kiwi").gather(Gatherer.of((_, word, downstream) -> word.chars()
        .filter(Character::isLowerCase)
        .allMatch(ch -> downstream.push((char) ch))
)).forEach(System.out::println);

    (Observe que não estou usando Integrator.ofporque não vejo muita utilidade nisso aqui. Também não estou tornando o integrador ganancioso porque ele simplesmente não precisa ser.)

    • 4

  2. flatMapToInt()

    Embora stream gatherers sejam ótimos e resolvam muitos problemas, no seu caso em particular você obtém um código mais claro quando não os usa. Assim como não devemos streamificar tudo, também não devemos gatherificar todas as operações de stream.

        Stream.of("apple", "banana", "kiwi")
            .flatMapToInt(String::codePoints)
            .filter(Character::isLowerCase)
            .mapToObj(Character::toChars)
            .forEach(System.out::println);

    Saída:

    a
p
p
l
e
b
a
n
a
n
a
k
i
w
i

    Para suas strings específicas String::charsfuncionaria da mesma forma que String::codePoints. Eu escolhi o último para levar todos os caracteres Unicode em conta. Para imprimir um ponto de código, eu uso Character.toChars()para converter para um array de charvalores (no nosso caso, um array de apenas 1 char). O sobrecarregado System.out.println(char[])então imprime o símbolo.

    Se você tiver um motivo para obter um fluxo de Characterobjetos, você precisa usar String::chars:

        Stream.of("apple", "banana", "kiwi")
            .flatMapToInt(String::chars)
            .mapToObj(ch -> (char) ch)
            .filter(Character::isLowerCase)
            .forEach(System.out::println);

    A saída é a mesma de antes.

    Como a biblioteca não oferece nenhum CharStreamtipo, chars()(como codePoints()) retorna IntStream. No último snippet, convertemos de primitivo intpara Characterobjetos usando .mapToObj(ch -> (char) ch)e autoboxing.

    • 0

relate perguntas