Terminal Root

Gere Circuitos Lógicos com Python

Wed, 25 Mar 2026 10:56:19 +0000

Dependências

Windows, instale o PIP e depois instale o Schemdraw com o PIP:

pip install schemdraw

Em GNU, Linux e UNIX, crie um ambiente virtual e instale com o PIP:

mkdir -p ~/.local/bin
python -m venv ~/.local/bin/venv
. ~/.local/bin/venv/bin/activate
pip install schemdraw

Código Python:

import schemdraw
import schemdraw.logic as logic

with schemdraw.Drawing() as d:
    d += logic.And(inputs=2).color('blue')
    d += logic.Or().right().color('green')
    d += logic.Not().right().color('red')
    d.draw()

Aprenda Python

https://terminalroot.com.br/python

Instale esse Scanner de Rede Moderno modo TUI

Wed, 25 Mar 2026 10:37:46 +0000

Se você já usou ferramentas como nmap e achou pesado, verboso ou lento demais para tarefas simples, o Nibble resolve exatamente esse problema.

Nibble é um scanner de rede open-source focado em simplicidade, velocidade e usabilidade. Ele permite descobrir dispositivos e serviços na sua rede local sem precisar decorar comandos complexos ou configurar nada manualmente.Funciona em GNU/Linux, macOS e Windows (x86 e ARM).

Instalação

brew install backendsystems/tap/nibble
pipx install nibble-cli
npm install -g @backendsystems/nibble
go install github.com/backendsystems/nibble@latest

Ou rodar direto com:

npx @backendsystems/nibble

Para mais informações acesse o repositório.

Os 10 Melhores Monitores para Programadores

Wed, 25 Mar 2026 10:09:59 +0000

Esses monitores são ótimos para programadores, oferecendo desde alta resolução e precisão de cores até design ergonômico para longas sessões de codificação. O tamanho, a qualidade da tela e a ergonomia são aspectos cruciais que podem melhorar significativamente a experiência de programação.

01. Dell UltraSharp P2725H

O P2725H oferece uma tela 4K de 27 polegadas, com ótima precisão de cores, ideal para programadores que precisam de clareza em detalhes.
Resolução: 3840 x 2160 (4K)
Características: IPS, excelente cobertura de cores (95% DCI-P3), portas USB-C com carregamento.
Ideal para: programadores que trabalham com gráficos, design ou precisam de uma tela com resolução muito alta.

Clique aqui para adquirir esse Monitor

02. LG 4wn80c-b ultrawide

O 4wn80c-b é um monitor ultrawide de 34 polegadas com resolução 1440p que oferece uma ótima experiência multitarefa.
Resolução: 3440 x 1440 (UltraWide)
Características: Painel IPS, design curvado, excelente para produtividade, ajuste de altura e inclinação.
Ideal para: programadores que fazem multitasking e precisam de mais espaço na tela para abrir várias janelas ou códigos simultaneamente.

Clique aqui para adquirir esse Monitor

03. ASUS ProArt PA278QV

Focado em precisão de cores, o PA278QV é perfeito para programadores que também trabalham com design ou edição gráfica.
Resolução: 2560 x 1440 (QHD)
Características: Calibração de cores de fábrica, painel IPS, suporte ergonômico (ajuste de altura, inclinação, rotação).
Ideal para: programadores que precisam de um monitor preciso para edição de imagens ou desenvolvimento de interfaces.

Clique aqui para adquirir esse Monitor

04. BenQ PD2705U

O PD2705U é um monitor 4K de 27 polegadas com excelente performance para programadores que necessitam de uma tela grande e com excelente precisão de cores.
Resolução: 3840 x 2160 (4K)
Características: Painel IPS, design ergonômico, modos de exibição especializados para programadores (como o modo de leitura).
Ideal para: programadores que precisam de alta resolução para multitarefas e atividades de design.

Clique aqui para adquirir esse Monitor

05. Samsung Odyssey AI TV 55” OLED 4K S85F

O Odyssey AI TV 55” OLED 4K S85F ** é um monitor **curvo de 55 polegadas, ideal para programadores que preferem um monitor mais imersivo e com excelente taxa de atualização.
Resolução: 3840 x 2160 (4K)
Características: Curvatura de 1000R, taxa de atualização de 240Hz, tempo de resposta rápido, painel VA.
Ideal para: programadores que também são gamers ou preferem uma tela curva para uma melhor experiência de trabalho imersivo.

Clique aqui para adquirir esse Monitor

06. Acer Predator X34

O X34 é um monitor ultrawide curvo de 34 polegadas, excelente para programadores que trabalham com múltiplos projetos ou janelas.
Resolução: 3440 x 1440 (UltraWide)
Características: Curvatura 1900R, taxa de atualização de 100Hz, painel IPS, suporte G-Sync.
Ideal para: programadores que buscam um monitor de alta qualidade com um campo de visão amplo para multitarefas.

Clique aqui para adquirir esse Monitor

07. Dell P2719H

O P2719H é um monitor de 27 polegadas com uma ótima relação custo-benefício, ideal para programadores que buscam um display de qualidade sem gastar muito.
Resolução: 1920 x 1080 (Full HD)
Características: Painel IPS, borda fina, design ajustável em altura, rotação e inclinação.
Ideal para: programadores que precisam de um monitor confiável e confortável para trabalhar longas horas.

Clique aqui para adquirir esse Monitor

08. Philips 276E8VJSB

Valor: R$ 750,00
O 276E8VJSB é um monitor 4K de 27 polegadas com uma ótima relação de custo-benefício, ideal para quem quer alta resolução sem gastar tanto.
Resolução: 3840 x 2160 (4K)
Características: Painel IPS, excelente desempenho em cores e contrastes.
Ideal para: programadores que querem um monitor com excelente resolução e boa qualidade de imagem para tarefas diárias e leitura de código.

Clique aqui para adquirir esse Monitor

09. LG UltraGear 27GN750-27

O LG 27UK850-W é um monitor 4K de 27 polegadas com ótima precisão de cores, sendo uma excelente escolha para programadores e profissionais criativos.
Resolução: 3840 x 2160 (4K)
Características: Conexões USB-C, painel IPS, suporte HDR10.
Ideal para: programadores que buscam um monitor com boa qualidade de imagem e conexão USB-C para facilitar a configuração.

Clique aqui para adquirir esse Monitor

10. VIVO Monitor Ultrawide + suporte para laptop

O VIVO Monitor Ultrawide + suporte para laptop é um monitor 4K de 49 polegadas que combina design minimalista com excelente precisão de cores, ideal para programadores e designers gráficos.
Resolução: 3840 x 2160 (4K)
Características: Painel IPS, ajustes ergonômicos (altura, rotação, inclinação), baixo consumo de energia.
Ideal para: programadores que buscam um monitor altamente preciso e ergonômico para trabalho prolongado.

Clique aqui para adquirir esse Monitor

Veja também:

Baixe vídeos do Youtube com esse App TUI

Tue, 24 Mar 2026 10:08:52 +0000

xytz é um projeto open source simples e muito útil pra quem curte terminal que é um frontend TUI pro yt-dlp feito em Go usando Bubble Tea.

Busca vídeos do YouTube direto no terminal
Navegação por canal (/channel) e playlist (/playlist)
Escolha de qualidade/formatos antes de baixar
Download com progresso, velocidade e ETA
Resume de downloads interrompidos
Histórico de buscas
Atalhos estilo Vim
Playback direto via mpv (sem baixar) ([pkg.go.dev][1])

Instalação

Via Go:

go install github.com/xdagiz/xytz@latest

Via cURL

curl -fsSL https://raw.githubusercontent.com/xdagiz/xytz/main/install.sh | bash

Homebrew (macOS)

brew install xdagiz/tap/xytz

Arch

paru -S xytz-bin # or yay -S xytz-bin

Scoop (Windows)

scoop bucket add xdagiz https://github.com/xdagiz/scoop-bucket.git
scoop install xdagiz/xytz

Após instalar basta rodar:

xytz

E um guia rápido em:

xytz --help

Para mais informações acesse o repositório.

Gere Arte com Python (HSV Spiral)

Mon, 23 Mar 2026 12:09:11 +0000

Usando turtle e colorsys para gerar um padrão geométrico colorido.

Dependências

No Windows com WinGet:

winget install -e --id CarlWenrich.PythonTkGuiBuilder

Em distros GNU/Linux com APT:

sudo apt install python3-tk

Código Python

main.py

import colorsys
import turtle

t = turtle.Turtle()
s = turtle.Screen()

s.bgcolor('black')
t.speed(0)

n = 36
h = 0

for i in range(460):

    c = colorsys.hsv_to_rgb(h, 1, 0.8)
    h += 1/n
    t.color(c)
    t.left(145)

    for j in range(5):
        t.forward(300)
        t.left(150)

Depois basta rodar:

python main.py

Aprenda Python

https://terminalroot.com.br/python

Gerencie pacotes APT com interface moderna no terminal

Mon, 23 Mar 2026 11:09:49 +0000

O APTUI é uma TUI (Terminal User Interface) escrita em Go que funciona como um frontend para o APT.

A proposta é simples: fazer tudo que você já faz com APT, mas sem sair da tela e sem ficar digitando comandos repetitivos.

Principais recursos

Filtro em tempo real enquanto você digita
Busca fuzzy (não precisa nome exato)
Fallback para apt-cache search

Instalação

Via Go

go install github.com/mexirica/aptui@latest

Ou via APT (Debian/Ubuntu)

(repositório próprio disponível no projeto)

Depois basta rodar:

aptui

Para mais informações acesse o repositório.

Gerencie suas bases SQL via Terminal com esse App

Mon, 02 Mar 2026 11:01:59 +0000

Pam é uma ferramenta de linha de comando (CLI) minimalista, escrita em Go, projetada para facilitar o gerenciamento e a execução de consultas SQL em múltiplos bancos de dados. Inspirada no universo de “The Office”, Pam homenageia a personagem que organiza tudo com eficiência.

Principais Destaques

Biblioteca de Queries: Salve e organize suas consultas SQL mais usadas, facilitando o acesso e reuso.
Multi-banco de dados: Compatível com PostgreSQL, MySQL, SQLite, Oracle, SQL Server, ClickHouse e Firebird.
Interface TUI (Terminal User Interface): Navegação focada no teclado, com atalhos inspirados no Vim, permitindo manipulação eficiente dos resultados das queries.
Edição Direta: Atualize células, exclua linhas e edite SQL diretamente na tabela de resultados.
Exportação de Dados: Exporte resultados em formatos como CSV, JSON, SQL, Markdown ou HTML.
Parâmetros em Queries: Suporte a consultas parametrizadas, facilitando buscas dinâmicas sem precisar reescrever SQL.

Instalação

Você pode instalar Pam via Go, baixando o binário diretamente do repositório de releases, ou usando Nix/NixOS.

go install github.com/eduardofuncao/pam/cmd/pam@latest

Uso Básico

Após instalar, basta inicializar uma conexão com o banco de dados desejado:

pam init mydb postgres "postgresql://user:pass@localhost:5432/mydb"

Adicione queries à sua biblioteca:

pam add list_users "SELECT * FROM users"

E execute-as de forma interativa:

pam run list_users

Exemplo:

A interface TUI permite navegação com atalhos do tipo Vim (j, k, h, l), cópia de células (y), exportação de dados (x), edição de células (u), exclusão de linhas (D), entre outros comandos rápidos.

Pam armazena suas configurações em ~/.config/pam/config.yaml, permitindo ajustar limites de linhas, largura de colunas e esquemas de cores para a interface.

O aplicativo oferece exemplos de comandos para conectar-se facilmente a diversos tipos de bancos de dados, incluindo PostgreSQL, MySQL, SQL Server, Oracle, SQLite, ClickHouse e Firebird.

Para mais informações acesso o repositório

Como otimizar o comando cd para voltar várias pastas de uma só vez

Fri, 20 Feb 2026 13:13:49 +0000

Todos do mundo UNIX/GNU usam constantemente o comando cd para entrar em pastas pelo terminal.

O comando cd, também conhecido por chdir, é um comando implementado em interfaces de linha de comandos de diversos sistemas operacionais (Unix ou qualquer um do tipo Unix, DOS, Windows, OS/2 e AmigaOS).

Nos sistemas GNU(usado pela maioria das distros Linux) ele é um shell builtin, ou seja, é um pouco mais complicado de fazer um patch.

O comando cd é muito útil, no entanto, uma das coisas mais chatas é quando você entra em muitas pastas e deseja voltar somente um quantidade exata e precisa rodar comando exemplo isso:

cd ../../../../../../
# Ou
cd ..
cd ..
cd ..
cd ..
cd ..
cd ..

Em ambos os casos acima, é necessário voltar 6 vezes.

Mas, podemos criar um função Bash que diminue essa quantidade de escrita para facilitar ir de forma mais rápida e like a boss para a 6º pasta atrás sem muita dificuldade, assim: cd -6, basta adicionar essa função abaixo ao final do seu ~/.bashrc:

cd() {
    if [[ "$1" =~ ^-[0-9]+$ ]]; then
        local n=${1#-}
        local path=""
        for ((i=0; i<n; i++)); do
            path+="../"
        done
        builtin cd "$path"
    else
        builtin cd "$@"
    fi
}

Depois releia o seu ~/.bashrc com o comando: exec $SHELL ou source ~/.bashrc e depois é só testar:

cd -6

Ou seja, use -(traço/menos) o número de pastas atrás que deseja, exemplos: cd -8, cd- 7, cd -11,…

Lembrando que para ir para a pasta pessoal basta rodar: cd(sem argumentos) e para retornar onde estava, use: cd - sem definir nenhum número!

Simples e prático, né?!

Vix: o 'Node.js' do C++, sem garbage collector

Fri, 30 Jan 2026 12:47:39 +0000

vix é um runtime/framework moderno em C++20 para construir aplicações back-end de alto desempenho e distribuídas (offline-first, peer-to-peer etc.) — tipo alternativa nativa ao Node/Deno, com HTTP async, roteamento, ORM e módulos.

Serve para criar servidores web, APIs e apps distribuídos em C++ com ergonomia contemporânea (sem garbage collector, sem overhead de frameworks “velhos”). Tem:

Servidor HTTP async (Asio)
Roteamento, middleware, JSON nativo
CLI pra scaffold/build/run
Módulos opcionais (ORM, WebSockets, utilitários) Tudo pensado para performance e aplicativos offline/P2P.

Instalação

Clone o repositório e compile com CMake:

git clone https://github.com/vixcpp/vix.git
cd vix
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j

Opcional: instale headers/artefatos no sistema (conforme docs do projeto).

Para usar como dependência em seu projeto, inclua os headers/libs compilados e configure CMake para linkar com “vix”.

Exemplo básico (Hello world HTTP)

Crie um arquivo main.cpp:

#include <vix.hpp>
using namespace vix;

int main() {
    App app;

    app.get("/", [](Request&, Response& res) {
        res.send("Hello world from Vix!");
    });

    app.run(8080);
}

Compile com seu CMakeLists que linka o runtime Vix. Ao rodar, acesse> localhost:8080.

Para mais informações acesse: https://github.com/vixcpp/vix

10 Recursos Modernos do Java que Desenvolvedores Sêniores Usam

Fri, 30 Jan 2026 12:34:47 +0000

Se você ainda está digitando getters, setters, equals() e hashCode() manualmente, ou se seus Data Transfer Objects (DTOs) parecem ter sido escritos em 2012, você está perdendo o segredo.

Você está escrevendo Java demais.

Já trabalhei em equipes que passaram semanas debatendo Lombok versus frameworks de imutabilidade, só para introduzir problemas complexos de build e bugs ocultos. A Java Virtual Machine (JVM) moderna — especificamente Java 17 LTS e versões posteriores — já resolveu esses problemas nativamente.

Isso não é apenas “açúcar sintático”. Esses recursos reduzem fundamentalmente o código repetitivo (boilerplate), melhoram a legibilidade do código e, mais importante, permitem otimizações mais profundas do compilador que reduzem a carga cognitiva.

Este é o verdadeiro “código secreto” para construir microsserviços mais rápidos, sustentáveis e baratos.

Aqui estão os 10 recursos que os desenvolvedores sêniores utilizam para reduzir sua base de código Java pela metade.

1. `record`: O Exterminador de Boilerplate

Esta é a maior conquista para classes centradas em dados. Se o propósito principal de uma classe é armazenar dados, use um record. Eles são imutáveis e geram automaticamente construtores, getters, equals(), hashCode() e toString().

A matemática é simples: 10 linhas de configuração se tornam uma.

A Maneira Antiga (Java < 16)

// User.java (aproximadamente 25 linhas de boilerplate + 2 campos)
public final class User {
    private final long id;
    private final String username;

    public User(long id, String username) {
        this.id = id;
        this.username = username;
    }
    // Mais 15 linhas de getters, equals, hashcode e toString...
}

A Maneira Nova (Java 17+)

// User.java (1 linha)
public record User(long id, String username) { }

// Uso:
var user = new User(42, "theIndieDev");
long userId = user.id(); // Os acessadores têm o nome do campo

Observação: Os record são imutáveis por padrão, o que quase sempre é o que você quer em uma arquitetura moderna. Se você precisa de mutabilidade, geralmente está modelando uma entidade com estado, não um DTO, e deve usar uma classe tradicional.

Aprenda Java da forma correta:

https://terminalroot.com.br/java

2. Pattern Matching para `instanceof`: Adeus ao Inferno dos Casts

Quantas vezes você já escreveu a mesma sequência cansativa: verificar o tipo e, em seguida, fazer o cast explícito? Agora o compilador faz o cast para você, dentro do bloco, desde que a verificação seja bem-sucedida.

Isso economiza uma linha, mas, mais criticamente, limpa instantaneamente a lógica aninhada.

A Maneira Antiga

public void process(Object o) {
    if (o instanceof String) {
        String s = (String) o; // Cast explícito necessário
        System.out.println("Length: " + s.length());
    }
}

A Maneira Nova

public void process(Object o) {
    // 's' é automaticamente convertida para String e está no escopo
    if (o instanceof String s) {
        System.out.println("Length: " + s.length());
    }
    // 's' está fora do escopo aqui
}

3. Expressões `switch`: O Simplificador de Fluxo

As declarações tradicionais switch eram uma fonte de bugs sutis devido ao fall-through acidental e, além disso, eram apenas declarações — você não podia atribuir o resultado a uma variável.

As expressões switch corrigem isso garantindo um resultado e usando a sintaxe de seta (->) para eliminar a necessidade do break.

A Maneira Antiga

String dayType;
switch (day) {
    case MONDAY:
    case FRIDAY:
        dayType = "Busy";
        break; // O break é crucial!
    case SATURDAY:
    case SUNDAY:
        dayType = "Weekend";
        break;
    default:
        dayType = "Normal";
}

A Maneira Nova (Uma Única Expressão)

String dayType = switch (day) {
    case MONDAY, FRIDAY -> "Busy";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Normal";
};

Aprenda Java da forma correta:

https://terminalroot.com.br/java

4. Classes Seladas (Sealed Classes): O Power-Up Arquitetural

As classes seladas, introduzidas no Java 17, não têm como objetivo direto reduzir linhas de código. Elas servem para reduzir possíveis bugs e permitir que o compilador ajude na correção.

Agora você pode declarar explicitamente quais classes ou records podem implementar ou estender um tipo selado, impondo uma hierarquia controlada.

// Impondo que apenas Circle, Square e Rectangle podem ser formas
public sealed interface Shape
    permits Circle, Square, Rectangle { }

public record Circle(double radius) implements Shape { }
public final class Square implements Shape { /* ... */ }
// Qualquer classe que não seja explicitamente 'permitida' não pode implementar Shape

A mágica acontece quando você combina isso com uma Expressão switch. O compilador agora pode garantir que você tratou todos os subtipos possíveis, eliminando a necessidade de uma cláusula default defensiva. Isso é poderoso para modelagem Domain-Driven Design (DDD).

5. Blocos de Texto (Text Blocks): O Salvador do SQL/JSON

Se seu código Java lida com strings de várias linhas — consultas SQL, payloads JSON, trechos HTML ou arquivos de configuração complexos — você provavelmente já teve strings concatenadas feias com caracteres \n inseridos manualmente.

Os Blocos de Texto ("""...""") resolvem esse problema de forma elegante.

A Maneira Antiga

String JSON_PAYLOAD = "{\n"
    + "  \"name\": \"AccountCreatedEvent\",\n"
    + "  \"timestamp\": \"" + now() + "\"\n"
    + "}";

A Maneira Nova

String JSON_PAYLOAD = """
    {
      "name": "AccountCreatedEvent",
      "timestamp": "%s"
    }
    """.formatted(now()); // Funciona muito bem com .formatted()!

6. Inferência de Tipo de Variável Local (`var`): Despoluindo o Código

Esse recurso, muitas vezes mal compreendido, tem como objetivo reduzir o ruído causado por declarações de tipo redundantes. A chave são as variáveis locais onde o tipo é claro a partir do contexto.

Você economiza na digitação, mas o benefício real são linhas mais limpas, especialmente com genéricos.

A Maneira Antiga

Map<String, List<User>> userMap = new HashMap<String, List<User>>();
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
    // ...
}

A Maneira Nova

// O tipo é óbvio a partir do lado direito (RHS)
var userMap = new HashMap<String, List<User>>();

// Ainda suficientemente explícito para legibilidade
try (var reader = new BufferedReader(new FileReader("data.txt"))) {
    // ...
}

Sabedoria do Dev Sênior: Use var apenas onde o tipo seja imediatamente óbvio no lado direito (RHS). Não o use para ofuscar tipos de retorno de métodos ou para campos.

7. Melhorias no `Optional`: Menos Código Defensivo

A classe Optional é essencial para programação no estilo funcional, mas versões mais antigas tornavam tarefas comuns muito verbosas. O Java adicionou métodos mais limpos para tornar o tratamento de erros e efeitos colaterais mais elegantes.

A Maneira Antiga (Pré-Java 11)

// Tratando um valor ausente com erro
String result = optionalValue.orElseThrow(
    () -> new NoSuchElementException("Missing value"));

// Tratando efeitos colaterais de sucesso ou falha
optionalValue.ifPresent(
    (v) -> doSomething(v)
);
if (!optionalValue.isPresent()) {
    doSomethingElse();
}

A Maneira Nova (Java 11+)

// Maneira mais limpa de lançar uma exceção
String result = optionalValue.orElseThrow(
    NoSuchElementException::new);

// Maneira mais limpa de lidar com efeitos colaterais
optionalValue.ifPresentOrElse(
    this::doSomething,
    this::doSomethingElse
);

Aprenda Java da forma correta:

https://terminalroot.com.br/java

8. Melhorias na API de Streams (`takeWhile` / `dropWhile`)

A API de Streams é a base do Java funcional moderno. takeWhile e dropWhile permitem uma filtragem poderosa, baseada em condições e com curto-circuito.

Em vez de consumir todo o stream com um filter genérico, você pode parar a iteração imediatamente quando uma condição for atendida, levando a um processamento mais rápido de grandes conjuntos de dados.

O Conceito

// Dados: [1, 2, 4, 6, 9, 10, 12]

// takeWhile: Pega elementos *enquanto* o predicado for verdadeiro, depois para.
// Exemplo: takeWhile(n -> n < 5) retorna [1, 2, 4]
// dropWhile: Descarta elementos *enquanto* o predicado for verdadeiro, depois retorna o restante.
// Exemplo: dropWhile(n -> n < 5) retorna [6, 9, 10, 12]

9. `Collectors.toUnmodifiableList/Set/Map`: Defensivo por Padrão

Em versões mais antigas do Java, os desenvolvedores constantemente se esquecia de encapsular coleções mutáveis em cópias defensivas (por exemplo, Collections.unmodifiableList(...)). Essa é uma fonte clássica de problemas de concorrência e corrupção de estado.

Agora, você pode coletar diretamente em uma lista imutável.

A Maneira Antiga

List<String> mutableResults = sourceList.stream()
    .filter(...)
    .collect(Collectors.toList());
// Mais tarde, você poderia retornar assim, permitindo modificação externa:
// return mutableResults; // PERIGO!

// A maneira defensiva era verbosa:
List<String> safeList = sourceList.stream()
    .filter(...)
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        Collections::unmodifiableList
    ));

A Maneira Nova (Java 10+)

// Uma linha, garantidamente imutável e segura
List<String> safeList = sourceList.stream()
    .filter(...)
    .toList(); // Esta é a sintaxe simplificada do [Java](https://terminalroot.com.br/java/) 16+

// OU (para [Java](https://terminalroot.com.br/java/) 10+)
List<String> safeList = sourceList.stream()
    .filter(...)
    .collect(Collectors.toUnmodifiableList());

Aprenda Java da forma correta:

https://terminalroot.com.br/java

10. `Stream::toList()`: O Finalizador de Streams

Embora Collectors.toList() exista há muito tempo, o método de instância Stream::toList() (Java 16+) é uma maneira concisa e sem boilerplate de finalizar um stream em uma List padrão e imodificável.

É o máximo economizador de linhas para a operação de Stream mais comum.

A Maneira Antiga (Verbosamente)

List<String> names = employees.stream()
    .map(Employee::getName)
    .collect(Collectors.toList());

A Maneira Nova (Conciso e Seguro)

List<String> names = employees.stream()
    .map(Employee::getName)
    .toList(); // Uma única chamada de método

Conclusão: Pare de Escrever Código Descartável

A complexidade no software empresarial raramente está na lógica de negócio em si; está no “tecido conjuntivo” — o código repetitivo (boilerplate), as cópias defensivas, as instruções break esquecidas e os casts manuais.

O Java moderno (17+) foi projetado para eliminar esse “tecido conjuntivo”. Ao adotar esses 10 recursos, você não está apenas agradando ao compilador; está libertando seu cérebro da carga cognitiva. O código que você não escreve é código que não pode ter bugs.

Se você mantém uma grande base de código, insisto fortemente para que você pare de usar os padrões antigos e verbosos e comece a migrar seus DTOs para record hoje mesmo. Essa única mudança sozinha lhe dará uma redução imediata e quantificável de 50% na contagem de linhas em seus modelos de dados.

Pare de escrever código descartável. Comece a escrever lógica de negócio.

Curso de Java para Iniciantes

https://terminalroot.com.br/java

Via: medium.com/@martinastaberger/

Terminal Root

Gere Circuitos Lógicos com Python

Dependências

Aprenda Python

https://terminalroot.com.br/python

Instale esse Scanner de Rede Moderno modo TUI

Instalação

Os 10 Melhores Monitores para Programadores

01. Dell UltraSharp P2725H

02. LG 4wn80c-b ultrawide

03. ASUS ProArt PA278QV

04. BenQ PD2705U

05. Samsung Odyssey AI TV 55” OLED 4K S85F

06. Acer Predator X34

07. Dell P2719H

08. Philips 276E8VJSB

09. LG UltraGear 27GN750-27

10. VIVO Monitor Ultrawide + suporte para laptop

Veja também:

Baixe vídeos do Youtube com esse App TUI

Instalação

Gere Arte com Python (HSV Spiral)

Dependências

Código Python

Aprenda Python

https://terminalroot.com.br/python

Gerencie pacotes APT com interface moderna no terminal

Instalação

Via Go

Ou via APT (Debian/Ubuntu)

Gerencie suas bases SQL via Terminal com esse App

Principais Destaques

Instalação

Uso Básico

Como otimizar o comando cd para voltar várias pastas de uma só vez

Vix: o 'Node.js' do C++, sem garbage collector

Instalação

Exemplo básico (Hello world HTTP)

10 Recursos Modernos do Java que Desenvolvedores Sêniores Usam

1. record: O Exterminador de Boilerplate

A Maneira Antiga (Java < 16)

A Maneira Nova (Java 17+)

2. Pattern Matching para instanceof: Adeus ao Inferno dos Casts

A Maneira Antiga

A Maneira Nova

3. Expressões switch: O Simplificador de Fluxo

A Maneira Antiga

A Maneira Nova (Uma Única Expressão)

4. Classes Seladas (Sealed Classes): O Power-Up Arquitetural

5. Blocos de Texto (Text Blocks): O Salvador do SQL/JSON

A Maneira Antiga

A Maneira Nova

6. Inferência de Tipo de Variável Local (var): Despoluindo o Código

A Maneira Antiga

A Maneira Nova

7. Melhorias no Optional: Menos Código Defensivo

A Maneira Antiga (Pré-Java 11)

A Maneira Nova (Java 11+)

8. Melhorias na API de Streams (takeWhile / dropWhile)

O Conceito

9. Collectors.toUnmodifiableList/Set/Map: Defensivo por Padrão

A Maneira Antiga

A Maneira Nova (Java 10+)

10. Stream::toList(): O Finalizador de Streams

A Maneira Antiga (Verbosamente)

A Maneira Nova (Conciso e Seguro)

Conclusão: Pare de Escrever Código Descartável

Curso de Java para Iniciantes

https://terminalroot.com.br/java

1. `record`: O Exterminador de Boilerplate

2. Pattern Matching para `instanceof`: Adeus ao Inferno dos Casts

3. Expressões `switch`: O Simplificador de Fluxo

6. Inferência de Tipo de Variável Local (`var`): Despoluindo o Código

7. Melhorias no `Optional`: Menos Código Defensivo

8. Melhorias na API de Streams (`takeWhile` / `dropWhile`)

9. `Collectors.toUnmodifiableList/Set/Map`: Defensivo por Padrão

10. `Stream::toList()`: O Finalizador de Streams