Array em Java

add

fn main() {
    // Array original (como vetor dinâmico em Rust)
    let mut minha_vec = vec![1, 2, 3, 4, 5];

    // Novo elemento
    let novo_elemento = 6;

    // Adicionar o novo elemento ao final
    minha_vec.push(novo_elemento);

    // Imprimir o novo vetor
    println!("{:?}", minha_vec); // Saída: [1, 2, 3, 4, 5, 6]
}

size

fn main() {
    // Criando um array de inteiros com 5 elementos
    let meu_array = [10, 20, 30, 40, 50];

    // Obtendo o tamanho do array
    let tamanho = meu_array.len();

    // Exibindo o tamanho do array
    println!("O tamanho do array é: {}", tamanho);
}

get

fn main() {
    // Criando um array de inteiros
    let meu_array = [10, 20, 30, 40, 50];

    // Acessando elementos do array usando colchetes
    let primeiro_elemento = meu_array[0]; // índice 0
    let terceiro_elemento = meu_array[2]; // índice 2

    // Exibindo os elementos acessados
    println!("Primeiro elemento: {}", primeiro_elemento);
    println!("Terceiro elemento: {}", terceiro_elemento);
}

set

fn main() {
    // Criando um array mutável de inteiros
    let mut meu_array = [10, 20, 30, 40, 50];

    // Alterando o valor do terceiro elemento (índice 2)
    meu_array[2] = 35;

    // Exibindo o array após a alteração
    for i in 0..meu_array.len() {
        println!("Elemento {}: {}", i, meu_array[i]);
    }
}

remove

fn main() {
    // Criando um vetor de inteiros
    let mut meu_vec = vec![10, 20, 30, 40, 50];

    // Definindo o índice do elemento que deseja remover (ex: 2 → valor 30)
    let indice_para_remover = 2;

    // Verificando se o índice é válido
    if indice_para_remover < meu_vec.len() {
        // Remove o elemento no índice
        meu_vec.remove(indice_para_remover);
    } else {
        println!("Índice inválido para remoção.");
    }

    // Exibindo o vetor após a remoção
    for elemento in &meu_vec {
        println!("Elemento: {}", elemento);
    }
}

clear

fn main() {
    // Criando um array mutável de inteiros
    let mut meu_array = [10, 20, 30, 40, 50];

    // Limpando o array atribuindo valores padrão (zero) a todos os elementos
    for i in 0..meu_array.len() {
        meu_array[i] = 0;
    }

    // Exibindo o array após a limpeza
    for elemento in &meu_array {
        println!("Elemento: {}", elemento);
    }
}

contains

fn main() {
    // Criando um array de inteiros
    let meu_array = [10, 20, 30, 40, 50];

    // Valor que queremos verificar
    let valor_procurado = 30;

    // Variável para rastrear se o valor foi encontrado
    let mut encontrado = false;

    // Percorrendo o array e verificando se o valor está presente
    for &elemento in &meu_array {
        if elemento == valor_procurado {
            encontrado = true;
            break;
        }
    }

    // Exibindo o resultado
    if encontrado {
        println!("O valor {} está presente no array.", valor_procurado);
    } else {
        println!("O valor {} não está presente no array.", valor_procurado);
    }
}

toArray

fn main() {
    // Criando um vetor de Strings
    let lista = vec![
        String::from("Item 1"),
        String::from("Item 2"),
        String::from("Item 3"),
    ];

    // "Convertendo" o Vec para um slice (equivalente ao array em Java)
    let array: &[String] = &lista;

    // Exibindo os elementos do slice
    for item in array {
        println!("{}", item);
    }
}

indexOf

fn main() {
    // Criando um array de inteiros
    let meu_array = [10, 20, 30, 40, 50];

    // Valor que queremos encontrar
    let valor_procurado = 30;

    // Variável para armazenar o índice do valor encontrado
    let mut indice: isize = -1; // -1 indica não encontrado

    // Percorrendo o array para encontrar o índice
    for i in 0..meu_array.len() {
        if meu_array[i] == valor_procurado {
            indice = i as isize;
            break;
        }
    }

    // Exibindo o resultado
    if indice != -1 {
        println!("O valor {} foi encontrado no índice {}", valor_procurado, indice);
    } else {
        println!("O valor {} não foi encontrado no array.", valor_procurado);
    }
}

lastIndexOf

fn main() {
    // Criando um array de inteiros
    let meu_array = [10, 20, 30, 40, 30];

    // Valor que queremos encontrar
    let valor_procurado = 30;

    // Variável para armazenar o índice do último valor encontrado
    let mut ultimo_indice: isize = -1;

    // Percorrendo o array
    for i in 0..meu_array.len() {
        if meu_array[i] == valor_procurado {
            ultimo_indice = i as isize;
        }
    }

    // Exibindo o resultado
    if ultimo_indice != -1 {
        println!(
            "O valor {} foi encontrado no último índice: {}",
            valor_procurado, ultimo_indice
        );
    } else {
        println!("O valor {} não foi encontrado no array.", valor_procurado);
    }
}