Rust vs Java: Performance e Segurança | Rust Brasil

import java.util.ArrayList;
import java.util.List;

public class ExemploGC {
    record Pedido(String cliente, double valor) {}

    public static void main(String[] args) {
        List<Pedido> pedidos = new ArrayList<>();

        // Milhões de alocações — o GC precisa gerenciar tudo
        for (int i = 0; i < 1_000_000; i++) {
            pedidos.add(new Pedido("Cliente " + i, Math.random() * 1000));
        }

        double total = pedidos.stream()
            .filter(p -> p.valor() > 500)
            .mapToDouble(Pedido::valor)
            .sum();

        System.out.printf("Total de pedidos acima de R$500: R$%.2f%n", total);
        // Objetos temporários do stream são coletados pelo GC eventualmente
    }
}

struct Pedido {
    cliente: String,
    valor: f64,
}

fn main() {
    let pedidos: Vec<Pedido> = (0..1_000_000)
        .map(|i| Pedido {
            cliente: format!("Cliente {i}"),
            valor: rand::random::<f64>() * 1000.0,
        })
        .collect();

    let total: f64 = pedidos
        .iter()
        .filter(|p| p.valor > 500.0)
        .map(|p| p.valor)
        .sum();

    println!("Total de pedidos acima de R$500: R${total:.2}");
} // pedidos e todos os Pedido são liberados aqui, instantaneamente

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

@SpringBootApplication
@RestController
@RequestMapping("/tarefas")
public class TarefaApp {
    record Tarefa(Long id, String titulo, boolean concluida) {}
    record CriarTarefa(String titulo) {}

    private final Map<Long, Tarefa> tarefas = new ConcurrentHashMap<>();
    private final AtomicLong contador = new AtomicLong();

    @GetMapping
    public Collection<Tarefa> listar() {
        return tarefas.values();
    }

    @PostMapping
    public Tarefa criar(@RequestBody CriarTarefa dto) {
        long id = contador.incrementAndGet();
        Tarefa tarefa = new Tarefa(id, dto.titulo(), false);
        tarefas.put(id, tarefa);
        return tarefa;
    }

    @PutMapping("/{id}/concluir")
    public Tarefa concluir(@PathVariable Long id) {
        Tarefa atual = tarefas.get(id);
        if (atual == null) throw new RuntimeException("Tarefa não encontrada");
        Tarefa concluida = new Tarefa(atual.id(), atual.titulo(), true);
        tarefas.put(id, concluida);
        return concluida;
    }

    public static void main(String[] args) {
        SpringApplication.run(TarefaApp.class, args);
    }
}

use axum::{
    extract::{Path, State},
    routing::{get, post, put},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::{atomic::{AtomicU64, Ordering}, Arc, RwLock};

#[derive(Clone, Serialize)]
struct Tarefa {
    id: u64,
    titulo: String,
    concluida: bool,
}

#[derive(Deserialize)]
struct CriarTarefa {
    titulo: String,
}

type Db = Arc<RwLock<HashMap<u64, Tarefa>>>;

async fn listar(State(db): State<Db>) -> Json<Vec<Tarefa>> {
    let tarefas = db.read().unwrap();
    Json(tarefas.values().cloned().collect())
}

async fn criar(
    State(db): State<Db>,
    State(contador): State<Arc<AtomicU64>>,
    Json(dto): Json<CriarTarefa>,
) -> Json<Tarefa> {
    let id = contador.fetch_add(1, Ordering::Relaxed) + 1;
    let tarefa = Tarefa { id, titulo: dto.titulo, concluida: false };
    db.write().unwrap().insert(id, tarefa.clone());
    Json(tarefa)
}

async fn concluir(
    State(db): State<Db>,
    Path(id): Path<u64>,
) -> Json<Tarefa> {
    let mut tarefas = db.write().unwrap();
    let tarefa = tarefas.get_mut(&id).expect("Tarefa não encontrada");
    tarefa.concluida = true;
    Json(tarefa.clone())
}

#[tokio::main]
async fn main() {
    let db: Db = Arc::new(RwLock::new(HashMap::new()));
    let contador = Arc::new(AtomicU64::new(0));

    let app = Router::new()
        .route("/tarefas", get(listar).post(criar))
        .route("/tarefas/{id}/concluir", put(concluir))
        .with_state((db, contador));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

// Java: null é onipresente
String nome = mapa.get("chave"); // pode ser null
int tamanho = nome.length(); // NullPointerException em runtime!

// Com Optional (melhora, mas é opt-in)
Optional<String> nome = Optional.ofNullable(mapa.get("chave"));
int tamanho = nome.map(String::length).orElse(0);

// Rust: Option<T> é obrigatório — null não existe
let nome: Option<&str> = mapa.get("chave").map(|s| s.as_str());

// O compilador OBRIGA você a tratar o caso None
let tamanho = match nome {
    Some(n) => n.len(),
    None => 0,
};

// Ou de forma mais concisa:
let tamanho = nome.map_or(0, |n| n.len());