13.11.2024

Aula 010: Trabalhando com Coleções em Rust

Em Rust, coleções são estruturas de dados que podem armazenar múltiplos valores. Elas vêm em vários tipos, incluindo arrays, vetores, strings, mapas hash e mais. Nesta aula, vamos explorar essas coleções, seus casos de uso e fornecer exemplos para ajudar você a entender como trabalhar com elas de forma eficaz.

Arrays

Um array é uma coleção de tamanho fixo de elementos do mesmo tipo. Uma vez definido, o tamanho de um array não pode ser alterado.

Exemplo: Arrays

fn main() {
    let numeros: [i32; 5] = [1, 2, 3, 4, 5]; // Um array de 5 inteiros

    // Acessando elementos
    println!("Primeiro número: {}", numeros[0]);
    println!("Segundo número: {}", numeros[1]);

    // Iterando sobre um array
    for numero in &numeros {
        println!("{}", numero);
    }
}

Vetores

Vetores são coleções dinâmicas que podem aumentar ou diminuir de tamanho. Eles são implementados como um array alocado na heap que pode crescer.

Exemplo: Vetores

fn main() {
    let mut numeros = vec![1, 2, 3];

    // Adicionando um elemento
    numeros.push(4);
    println!("Após adicionar: {:?}", numeros);

    // Removendo o último elemento
    numeros.pop();
    println!("Após remover: {:?}", numeros);

    // Acessando elementos
    println!("Primeiro número: {}", numeros[0]);

    // Iterando sobre um vetor
    for numero in &numeros {
        println!("{}", numero);
    }
}

Strings

Strings em Rust são essencialmente coleções de caracteres. Elas podem ser criadas como literais de string ou como tipos de string mutáveis.

Exemplo: Strings

fn main() {
    let mut saudacao = String::from("Olá");

    // Adicionando a uma string
    saudacao.push_str(", mundo!");
    println!("{}", saudacao);

    // Acessando caracteres
    let primeiro_caractere = saudacao.chars().nth(0).unwrap();
    println!("Primeiro caractere: {}", primeiro_caractere);

    // Iterando sobre uma string
    for c in saudacao.chars() {
        println!("{}", c);
    }
}

Mapas Hash

Mapas hash são coleções de pares chave-valor. Eles são úteis para armazenar dados que estão associados a uma chave única.

Exemplo: Mapas Hash

use std::collections::HashMap;

fn main() {
    let mut pontuacoes = HashMap::new();

    // Adicionando pares chave-valor
    pontuacoes.insert(String::from("Alice"), 10);
    pontuacoes.insert(String::from("Bob"), 15);

    // Acessando valores
    let pontuacao_alice = pontuacoes.get("Alice").unwrap();
    println!("Pontuação da Alice: {}", pontuacao_alice);

    // Iterando sobre um mapa hash
    for (chave, valor) in &pontuacoes {
        println!("{}: {}", chave, valor);
    }
}

Conclusão

Nesta aula, cobrimos várias coleções importantes em Rust: arrays, vetores, strings e mapas hash. Cada tipo de coleção serve a propósitos diferentes e possui características únicas. Compreender como trabalhar com essas coleções é fundamental para dominar Rust.

Sinta-se à vontade para experimentar os exemplos fornecidos e explorar os vários métodos e funcionalidades associadas a cada tipo de coleção. Boa programação!

Navigation