Post: [Generics] Listas genéricas – TQueue

Alessandro Medeiros

Compartilhar no whatsapp
Compartilhar no facebook
Compartilhar no twitter
Compartilhar no linkedin
Compartilhar no facebook

Fala ai Radizeiro e Radizeira, tudo bem com você?

Vamos seguir a nossa jornada de conhecimento, através da nossa série sobre generics.

Tenho certeza que esses posts aqui no blog tem sido muito proveitoso, e creio que vocês já tenham tido insights muito legais.

Coisas que você fazia dentro do seu código que davam muito trabalho, hoje com generics se tornou mais fácil.

Ainda tem bastante coisa para explorar nesse universo.

E ainda nesta série iremos explorar os quatro tipos de listas genéricas que temos dentro do Delphi.

No post anterior vimos o TList, e hoje iremos ver as filas, o TQueue.

Vamos lá?

Já aproveitei para deixar um exemplo pronto para que possamos compreender passo a passo todas as funções que poderemos fazer com a utilização do TQueue.

O que é essa fila e o que ela diferencia da lista?

Primeiro que o TQueue é realmente uma fila…rsrs

Todas as vezes que alguém chega em uma fila, ela geralmente vai para o fim dela, e o primeiro que é atendido, nenhuma novidade até agora sobre filas né…rsrs

O que diferencia dentro do Delphi a nível de programação, é que você não tem como listar a fila, não tem como percorrer ela através de index, como é feito com o TList.

O TQueue tem uma função de espionar quem é próximo da fila.

Eu vejo pouquíssimas pessoas usando isso dentro dos seus códigos, é muito raro ver um TQueue dentro do código, mas para alguns casos a fila pode ajudar muito.

Vamos conhecer as funções?

Dentro do nosso exemplo logo no primeiro botão temos o Enqueue, que quer dizer enfileirar.

Veja como é simples utilizar essa função.

procedure TForm1.Button1Click(Sender: TObject);
begin
    Fila.Enqueue(Edit1.Text);
end;

Chamamos a variável Fila, em seguida passamos o valor para o Enqueue.

Lembra que essa nossa Fila é uma fila genérica?

Antes de seguir demonstrando cada método usado no TQueue temos que criar essa variável, e claro, passar o tipo TQueue para ele.

Dentro do private do formulário irei criar uma variável Fila do tipo TQueue para sando o atributo genérico String, iremos utilizar o tipo primitivo para essa nossa fila.

Estamos trabalhando com lista simples, mas todas essas lista possuem os “parentes” que recebe o tipo object, como por exemplo, TList, tem o TObjectList, o TQueue, tem o TObjectQueue, e por aí vai.

O que diferencia um do outro, é que quando estou trabalhando com TObjectList, eu estou simplesmente setando objetos dentro dele, e quando essa lista é destruída ela vai limpar os objetos que estão dentro dessa lista.

Quando não trabalhamos com objetos temos que limpar a lista manualmente, e podemos trabalhar com filas e lista do tipo primitivos, se usarmos object não é possível, porque é específico para objetos.

Observe a declaração dessa nossa variável Fila no private do formulário.

private
    { Private declarations }
    Fila : TQueue<String>;

E no evento Create do formulário eu instancio essa variável.

procedure TForm1.FormCreate(Sender: TObject);
begin
    Fila := TQueue<String>.Create;
end;

Agora que já criamos a variável e instanciamos essa variável do tipo genérico TQueue que está recebendo o atributo primitivo String, vamos seguir visualizando cada método dessa nossa fila.

Como já mostrado logo no início do post o método Enqueue, vamos clicar no botão Enqueue do exemplo e ver como é feito o enfileiramento dos registros passados no Edit.

Observe que primeiro adicionei na fila o Edit1, e cliquei no botão Peek, ele serve justamente para mostrar qual é o primeiro registro da fila, ou seja, quem é o próximo a ser atendido, e ao clicar é possível que o primeiro da fila é o Edit1.

Mesmo adicionando o Thulio na fila, ao apertar o Peek, é mostrado somente o Edit1, porque ele é o que encontra-se em primeiro da fila.

Veja como é simples a implementação do Peek.

procedure TForm1.Button4Click(Sender: TObject);
begin
    Memo1.Lines.Add(Fila.Peek);
end;

Viu como é feito o trabalho das filas genéricas?

Eu não posso varrer a fila, mas eu sei sempre quem vai ser o próximo, o TQueue já possui funções que facilita na hora de usá-la.

O Dequeue, serve exatamente para retirar quem está na primeira posição, vamos dizer que o Edit1 foi chamado para ser atendido.

Ao clicar em Dequeue eu mostro quem está como primeiro da fila e retiro ele da fila, por exemplo, para ser atendido e direcionado para o consultório.

Observe que ao retirar ele da fila e clicar em Peek é mostrado o Thulio, pois agora, ele é o próximo da fila.

Veja agora como é simples também a implementação do Dequeue.

procedure TForm1.Button2Click(Sender: TObject);
begin
    Memo1.Lines.Add(Fila.Dequeue);
end;

Veja na imagem abaixo que o Dequeue retorna uma String, o TQueue é uma lista genérica que recebeu o atributo genérico do tipo primitivo String, sendo assim, ele irá retornar somente o tipo definido, mas poderia retornar outros tipo, desde que ele fosse definido no genérico da nossa fila.

Sendo assim, o primeiro a ser adicionado na fila, é o primeiro a sair, e quem for entrando posteriormente vai ficando para o fim da fila.

Se eu adicionar o José agora na fila o Thulio irá permanecer como o primeiro da fila, e quando o Thulio for atendido, o próximo da fila é o José.

Viu como é simples trabalhar com filas?

A função Extract é praticamente a mesma coisa do Dequeue, o que muda nele é o comportamento na hora do OnNotify, falei sobre o OnNotify no post anterior.

Assim como o TList o TQueue também tem as notificações, trabalha também com eventos, onde sabemos quando um objeto é extraído da fila, ele não é limpo da memória, vamos dizer assim, ele mantém ainda o espaço reservado para um outro objeto ser adicionado na fila.

Essa é a diferença do Extract para o Dequeue.

Observe que o José era o primeiro da fila, e ao executar o Extract, ele é retirado e dando lugar para o Joao que foi adicionado à fila.

Assim como na TList, o TQueue tem também o Count, onde ele mostra quantos registros possuo na fila.

Ao clicar no Count, é mostrado a quantidade que tem na fila, que é 1, e esse registro é o Joao que adicionamos anteriormente.

Executando o Dequeue, podemos observar que não possuímos mais ninguém na fila, ao clicar no Count.

Mas lembra no post anterior que falamos sobre o Capacity?

O Capacity, faz referência a quantos de espaços foi reservado para fila.

Observe que ao clicarmos no Capacity é mostrado que temos 4 espaços reservados, mas não possuímos ninguém na fila.

Para que não venhamos ter espaços reservados na memória não utilizados, que existe o método TrimExcess.

O TrimExcess limpou aquele excesso que eu tinha na fila, mesmo adicionando e removendo, não removemos da memória, então eu tenho que chamar essa função TrimExcess para fazer essa limpeza.

Por exemplo, adicionei novamente o Joao, e logo em seguida a capacidade vai para 4, porque ele já reservou esse espaço na memória para 4 registros, agora se eu chamar o TrimExcess, e mandar chamar o Capacity, ele vai para 1, ou seja, para a real quantidade que encontra-se na fila.

Agora vou adicionar mais um registro e vamos verificar novamente o Capacity.

Observe que já tínhamos o Joao na fila, e com apenas um registro, ao adicionar mais um registro na fila, ele vai multiplicando pelo número de registros, como mostrado no post anterior, ao executar o TrimExcess, ele vai para o valor real de registros da fila novamente.

Observe como é simples a implementação do TrimExcess.

procedure TForm1.Button5Click(Sender: TObject);
begin
    Fila.TrimExcess;
end;

Viu como é simples trabalhar com o TrimExcess?

Se usarmos sempre o TrimExcess sempre iremos ter nossa fila enxuta, sem ocupar mais espaços do que ela deveria.

Você que trabalha com filas, tem que gerenciar senhas de atendimento, o TQueue é muito legal e vai te poupar algumas linhas de códigos.

Muito legal né, as listas genéricas são incríveis, e espero que essa nossa série de generics tenha sido de grande proveito e tenha auxiliado em seu dia a dia.

Tem sido muito prazeroso poder levar esses conteúdos para vocês toda semana.

Utilizando generics, suas implementações ficam mais claras e limpas, as manutenções do seu software ficará mais fácil.

E caso você tenha interesse de conhecer mais sobre generics acessa o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI, onde você não só terá conteúdos relacionados aos generics, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.

CLIQUE AQUI E SAIBA MAIS SOBRE O CLUBE DOS PROGRAMADORES DELPHI




Faça sua busca

CATEGORIAS

POSTS RECENTES

E caso você tem interesse de conhecer mais sobre [Generics] Listas genéricas – TQueue, acesse o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI
Você não terá só conteúdos relacionados ao [Generics] Listas genéricas – TQueue, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.
Gostou?
Compartilhe:
Compartilhar no whatsapp
Compartilhar no facebook
Compartilhar no twitter
Compartilhar no linkedin
Compartilhar no facebook

Embarque no foguete com milhares de devs para aprender desenvolvimento, evoluir de forma contínua e se manter relevante no mercado.

Sobre
Dúvidas
Cadastre-se em nossa lista

Para ter acesso em primeira mão, a tudo que acontece na Academia do Código, basta se cadastrar em nossa lista

Grupo Thulio Bittencourt | Academia do Código

#FaçaPartedaHistória

Copyright © 2021 – Todos os direitos reservados