Explorando a Classe TArray em Delphi: Métodos e Aplicações

 

No Delphi, arrays dinâmicos são uma estrutura de dados amplamente utilizada. A classe genérica TArray, introduzida na unidade System.Generics.Collections, fornece métodos utilitários que permitem manipular arrays de forma eficiente.

Embora não seja uma classe com instâncias, TArray oferece métodos estáticos que são especialmente úteis quando lidamos com arrays genéricos.

 

O que é a classe TArray?

A TArray é uma estrutura genérica no Delphi, projetada para manipular arrays dinâmicos de qualquer tipo. Ela não adiciona novos tipos de dados, mas fornece métodos genéricos que simplificam tarefas comuns como ordenação, busca e modificação de arrays.

Exemplo básico de uso:

uses
  System.Generics.Collections;

var
  MyArray: TArray<Integer>;

 

Principais métodos disponíveis em TArray

Aqui estão os métodos reais que a TArray oferece, juntamente com suas funcionalidades:

 

TArray.Sort

Ordena os elementos do array. É necessário especificar o tipo do array como parâmetro de tipo. Para personalizar a ordenação, você pode fornecer uma instância de IComparer<T>.
Exemplo:

uses
  System.Generics.Collections;

var
  Numbers: TArray<Integer>;
begin
  Numbers := [5, 1, 4, 3, 2];
  TArray.Sort<Integer>(Numbers);
  // Agora Numbers = [1, 2, 3, 4, 5]
end;

 

TArray.BinarySearch

Realiza uma busca binária em um array ordenado. Retorna True se o elemento for encontrado e fornece seu índice.
Exemplo:

var
  Found: Boolean;
  Index: Integer;
begin
  Found := TArray.BinarySearch<Integer>(Numbers, 3, Index);
  if Found then
    Writeln('Elemento encontrado no índice ', Index);
end;

 

TArray.Copy

Copia um intervalo de elementos de um array para outro.
Exemplo:

var
  CopyArray: TArray<Integer>;
begin
  SetLength(CopyArray, 3); // <-- Importante ajustar a capacidade antes da cópia
  TArray.Copy<Integer>(Numbers, CopyArray, 3); // Copia os 3 primeiros elementos
end;

 

TArray.IndexOf (Testado no Delphi 12)

Encontra a primeira ocorrência de um elemento no array e retorna o índice. Retorna -1 se o elemento não for encontrado.
Exemplo:

var
  Index: Integer;
begin
  Index := TArray.IndexOf<Integer>(Numbers, 4);
  Writeln('Índice do elemento 4: ', Index);
end;

 

TArray.LastIndexOf (Testado no Delphi 12)

Encontra a última ocorrência de um elemento no array.
Exemplo:

var
  Index: Integer;
begin
  Index := TArray.LastIndexOf<Integer>(Numbers, 4);
  Writeln('Última ocorrência do elemento 4: ', Index);
end;

 

Como aumentar a produtividade com TArray

A TArray permite que desenvolvedores manipulem arrays com menos código e mais eficiência. Veja como ela pode ser aplicada em cenários reais:

 

Ordenação com Comparadores Personalizados:

Você pode usar um IComparer<T> para definir critérios de ordenação:

uses
  System.Generics.Defaults;

var
  Comparer: IComparer<Integer>;
begin
  Comparer := TComparer<Integer>.Construct(
    function(const Left, Right: Integer): Integer
    begin
      Result := Right - Left; // Ordenação decrescente
    end);
  TArray.Sort<Integer>(Numbers, Comparer);
end;

 

Cópia de Subconjuntos:

A função TArray.Copy é útil para criar subconjuntos de arrays sem loops explícitos:

var
  Subset: TArray<Integer>;
begin
  SetLength(Subset, 3); // <-- Importante ajustar a capacidade antes da cópia
  TArray.Copy<Integer>(Numbers, Subset, 0, 0, 3); // Copia 3 elementos a partir do índice 0, para o array destino a partir do índice 0
end;

 

Busca Rápida em Dados Ordenados:

Com TArray.BinarySearch, a busca é rápida e eficiente:

if TArray.BinarySearch<Integer>(Numbers, 10, Index) then
  Writeln('Valor encontrado no índice ', Index)
else
  Writeln('Valor não encontrado.');

 

Exemplo Completo

Vamos criar um programa que demonstra alguns dos métodos da classe TArray:

(*
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*)
program Project2;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils, System.StrUtils, System.Generics.Collections;

var
  Numbers: TArray;
  Subset: TArray;
  Found: Boolean;
  Index: Integer;
  I : Integer;
begin
  // Inicializando o array
  try
    Numbers := [10, 20, 30, 40, 50, 60];

    // Ordenar o array
    TArray.Sort(Numbers);

    // Buscar um elemento
    Found := TArray.BinarySearch(Numbers, 30, Index);
    if Found then
      Writeln('Elemento 30 encontrado no índice ', Index);

    // Copiar um subconjunto
    SetLength(Subset, 3); // <-- Importante ajustar a capacidade antes da cópia
    TArray.Copy(Numbers, Subset, 0, 0, 3); // Copia os elementos 20, 30, 40

    // Escrevendo os dados copiados no console
    Write('Elementos copiados: ');
    for I := Low(Subset) to High(Subset) do
    begin
      Write(Subset[i].ToString, IfThen(I < High(Subset), ', ', ''));
    end;

    Readln;  // pausa
  except On E: Exception do
    begin
      Writeln('Error: ' + E.Message);

      Readln; // pausa
    end;
  end;
end.

 

Copiar uma quantidade fixa de elementos (sem índices específicos)

var
  SourceArray, DestinationArray: TArray<Integer>;
begin
  SourceArray := [10, 20, 30, 40, 50];
  SetLength(DestinationArray, 3); // Define o tamanho necessário no destino

  TArray.Copy<Integer>(SourceArray, DestinationArray, 3); 
  // Copia os 3 primeiros elementos do SourceArray para DestinationArray
  // DestinationArray = [10, 20, 30]
end;

 

Erros comuns e como evitá-los

 

Array de destino não inicializado ou com tamanho insuficiente:

var
  SourceArray, DestinationArray: TArray<Integer>;
begin
  SourceArray := [10, 20, 30, 40, 50];
  // DestinationArray não tem tamanho suficiente!
  TArray.Copy<Integer>(SourceArray, DestinationArray, 3); 
  // Resultado: "Range Check Error"
end;

Correção: Use SetLength para ajustar o tamanho do array destino antes de realizar a cópia.

 

Índices fora dos limites do array:

TArray.Copy<Integer>(SourceArray, DestinationArray, 10, 0, 3); 
// Tentativa de acessar um índice fora do limite do SourceArray

Correção: Sempre valide os limites do array antes de usar índices personalizados.

 

Exemplo visual

Considere o array fonte:
SourceArray = [10, 20, 30, 40, 50]

Após o comando:

TArray.Copy<Integer>(SourceArray, DestinationArray, 1, 0, 3);

O array destino será preenchido com os seguintes valores:
DestinationArray = [20, 30, 40]

 

Conclusão

A classe TArray é uma ferramenta poderosa que pode aumentar significativamente a produtividade de desenvolvedores Delphi. Seus métodos prontos para uso simplificam a manipulação de arrays e incentivam práticas de codificação mais limpas e eficientes.

O método TArray.Copy é uma ferramenta poderosa, mas requer atenção ao configurar os arrays de origem e destino, bem como os parâmetros. Garantir que o array destino tenha o tamanho apropriado é crucial para evitar erros durante a execução.

Experimente a TArray em seus próximos projetos e veja a diferença que ela pode fazer!

 

 

Gostou do conteúdo? 😊

Tem alguma dica, dúvida ou experiência para compartilhar sobre o uso da classe TArray no Delphi? 💻

Deixe seu comentário aqui embaixo!

Vamos trocar ideias e aprender juntos! 🚀👇

 

 

💻 Compartilhe o post com outras pessoas se ele te ajudou! 😊

 

 

 

📚 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando! 👩‍💻 🔍✨

Até o próximo post. Valeu! 👋📖

 

 

 

#Delphi #Programação #TArray

#Produtividade #DesenvolvimentoDeSoftware

#DicasDeCódigo #DevLife #Desenvolvedores

#GiovaniDaCruz