Strings em Rust

replace

fn main() {
    let original = "Hoje é um lindo dia!";
    let substituida = original.replace("lindo", "maravilhoso");

    println!("{}", substituida); // Saída: "Hoje é um maravilhoso dia!"
}

length

fn main() {
   let minha_string = "Olá, mundo!";
   let tamanho = minha_string.len();

   println!("O tamanho da string é: {}", tamanho); // Saída: "O tamanho da string é: 12"
}

substring

fn main() {
   let original = "Isso é uma String de exemplo.";
   // Usando chars() para contar corretamente os caracteres
   let sub: String = original.chars().skip(8 - 1).take(13 - 8).collect();

   println!("{}", sub); // Saída: "uma S"
}

charAt

fn main() {
   let minha_string = "Olá, mundo!";

   let primeiro_caractere = minha_string.chars().nth(0).unwrap(); // 'O'
   let quinto_caractere = minha_string.chars().nth(4).unwrap(); // ' '

   println!("Primeiro caractere: {}", primeiro_caractere);
   println!("Quinto caractere: {}", quinto_caractere);
}

indexOf

Código em Java como comparação:

String minhaString = "Isso é um exemplo de indexOf em Java.";
int indice = minhaString.indexOf("exemplo");
System.out.println("A substring 'exemplo' começa no índice: " + indice); // Saída: "A substring 'exemplo' começa no índice: 13"

Código Rust

fn main() {
   let minha_string = "Isso é um exemplo de indexOf em Java.";

   // Retorna posição em bytes
   if let Some(indice_bytes) = minha_string.find("exemplo") {
// Converte de bytes para índice em caracteres
       let indice = minha_string[..indice_bytes].chars().count();

       println!("A substring 'exemplo' começa no índice: {}", indice);
       // Saída: "A substring 'exemplo' começa no índice: 10"
   } else {
       println!("Substring não encontrada.");
   }
}

lastIndexOf

fn last_index_of(s: &str, pat: &str) -> isize {
    if let Some(i) = s.rfind(pat) {
        s[..i].chars().count() as isize
    } else {
        -1
    }
}

fn main() {
    let minha_string = "Isso é um exemplo de lastIndexOf em Java. lastIndexOf é útil para encontrar a última ocorrência de uma substring.";
    let indice = last_index_of(minha_string, "lastIndexOf");

    println!("A última ocorrência de 'lastIndexOf' começa no índice: {}", indice);
    // A última ocorrência de 'lastIndexOf' começa no índice: 42
}

toLowerCase

fn main() {
   let minha_string = "ISSO É UMA STRING DE EXEMPLO.";

   println!("{}", minha_string); // Saída: "ISSO É UMA STRING DE EXEMPLO."

let em_minusculas = minha_string.to_lowercase();

   println!("{}", em_minusculas); // Saída: "isso é uma string de exemplo."
}

toUpperCase

fn main() {
   let minha_string = "Isso É Uma String De Exemplo.";

   println!("{}", minha_string); // Saída: "Isso É Uma String De Exemplo."

   let minha_string = "Isso É Uma String De Exemplo.";
   let em_maiusculas = minha_string.to_uppercase();

   println!("{}", em_maiusculas); // Saída: "ISSO É UMA STRING DE EXEMPLO."
}

compareTo

use std::cmp::Ordering;

#[warn(unused_imports)]

fn compare_to(a: &str, b: &str) -> i32 {
    match a.cmp(b) {
        Ordering::Less => -1,
        Ordering::Equal => 0,
        Ordering::Greater => 1,
    }
}

fn main() {
    let string1 = "abacate";
    let string2 = "banana";

    let resultado = compare_to(string1, string2);

    if resultado < 0 {
        println!("string1 é menor que string2");
    } else if resultado == 0 {
        println!("string1 é igual a string2");
    } else {
        println!("string1 é maior que string2");
    }
}

compareToIgnoreCase

use std::cmp::Ordering;

#[warn(unused_imports)]
fn compare_to_ignore_case(a: &str, b: &str) -> i32 {
    match a.to_lowercase().cmp(&b.to_lowercase()) {
        Ordering::Less => -1,
        Ordering::Equal => 0,
        Ordering::Greater => 1,
    }
}

fn main() {
    let string1 = "maçã";
    let string2 = "MaÇÃ";

    let resultado = compare_to_ignore_case(string1, string2);

    if resultado < 0 {
        println!("string1 é menor que string2 (ignorando a diferença entre maiúsculas e minúsculas)");
    } else if resultado == 0 {
        println!("string1 é igual a string2 (ignorando a diferença entre maiúsculas e minúsculas)");
    } else {
        println!("string1 é maior que string2 (ignorando a diferença entre maiúsculas e minúsculas)");
    }
}

equals

Código em Java como comparação:

String string1 = "Olá, mundo!";
String string2 = "Olá, mundo!";
String string3 = "OLÁ, MUNDO!";

boolean saoIguais1 = string1.equals(string2); // Retorna true
boolean saoIguais2 = string1.equals(string3); // Retorna false

Código em Rust

fn main() {
   let string1 = "Olá, mundo!";
   let string2 = "Olá, mundo!";
   let string3 = "OLÁ, MUNDO!";

   let sao_iguais1 = string1 == string2; // true
   let sao_iguais2 = string1 == string3; // false

   println!("string1 é igual a string2? {}", sao_iguais1);
   println!("string1 é igual a string3? {}", sao_iguais2);
}

equalsIgnoreCase

fn main() {
   let string1 = "Olá, mundo!";
   let string2 = "OLÁ, MUNDO!";

   // Comparação ignorando maiúsculas/minúsculas (Unicode)
   let sao_iguais = string1.to_lowercase() == string2.to_lowercase();

   println!("As strings são iguais (ignorando maiúsculas/minúsculas)? {}", sao_iguais);
}