Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

qual seria o correto para usar no lugar do último peek()? return…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-opus-4-20250514’s answer.
  1. User

    qual seria o correto para usar no lugar do último peek()?

        return userService.getAccounts()
                .values()
                .stream()
                .peek(accountDTO -> logger.debug("Retrieved account from exchange: {}", accountDTO))
                // We consider that we have a new value to send to strategies in two cases:
                // - New value (AccountDTO) is already in previous values but balances are different.
                // - New value (AccountDTO) doesn't exist at all in previous values.
                .filter(accountDTO -> !Objects.equals(accountDTO, previousValues.get(accountDTO.getAccountId())))
                .peek(accountDTO -> logger.debug("Updated account: {}", accountDTO))
                // We add or replace the new value in the previous values.
                .peek(accountDTO -> previousValues.put(accountDTO.getAccountId(), accountDTO))
                .collect(Collectors.toCollection(LinkedHashSet::new));
    
  2. DeepSeek Assistant

    Para substituir o último peek() de forma adequada e segura (evitando efeitos colaterais em operações intermediárias), você deve mover a operação de atualização do mapa previousValues para uma operação terminal separada. O uso de peek() para modificar estados externos é considerado um anti-pattern em streams.

    Solução Recomendada:

    Set<AccountDTO> updatedAccounts = userService.getAccounts()
            .values()
            .stream()
            .peek(accountDTO -> logger.debug("Retrieved account from exchange: {}", accountDTO))
            .filter(accountDTO -> !Objects.equals(accountDTO, previousValues.get(accountDTO.getAccountId())))
            .peek(accountDTO -> logger.debug("Updated account: {}", accountDTO))
            .collect(Collectors.toCollection(LinkedHashSet::new));
    
    // Atualiza o mapa fora do stream
    updatedAccounts.forEach(acc -> previousValues.put(acc.getAccountId(), acc));
    
    return updatedAccounts;
    

    Por que isso é melhor?

    1. Separação de responsabilidades:

      • O stream foca em transformação/filtragem dos dados.
      • A atualização do estado (previousValues) é feita em uma etapa separada e explícita.
    2. Evita efeitos colaterais:

      • peek() deve ser usado apenas para operações não interferentes (como logs).
      • Operações que modificam estado (como put em um mapa) não pertencem a operações intermediárias.
    3. Legibilidade e manutenção:

      • O código fica mais claro e menos propenso a bugs em cenários de streams paralelos.

    Versão com Coletor Personalizado (Opcional):

    Se preferir fazer tudo em uma única expressão (embora menos legível):

    return userService.getAccounts()
            .values()
            .stream()
            .peek(accountDTO -> logger.debug("Retrieved account from exchange: {}", accountDTO))
            .filter(accountDTO -> !Objects.equals(accountDTO, previousValues.get(accountDTO.getAccountId())))
            .peek(accountDTO -> logger.debug("Updated account: {}", accountDTO))
            .collect(
                Collectors.collectingAndThen(
                    Collectors.toCollection(LinkedHashSet::new),
                    set -> {
                        set.forEach(acc -> previousValues.put(acc.getAccountId(), acc));
                        return set;
                    }
                )
            );
    

    Observações Importantes:

    • Thread Safety: Se previousValues é compartilhado entre threads, use ConcurrentHashMap ou sincronização.
    • Performance: A abordagem separada é mais eficiente em streams grandes (evita dupla iteração).
    • Boas Práticas: Sempre prefira operações terminais (forEach, collect) para modificar estados externos.

    Esta solução mantém a semântica original do código enquanto segue as melhores práticas de programação funcional com Java Streams.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.