Tuplas têm um significado especial no campo dos computadores, esse nome pode soar um pouco estranho, e basicamente não existem cenários de aplicação na escrita de código, porém, surpreendentemente, tuplas estão intimamente relacionadas à programação, alguns estudantes podem não saber que outro nome acadêmico para "registros" em bancos de dados relacionais é "tuplas", um registro é uma tupla, uma tabela é uma relação, registros são compostos por tabelas, tuplas geram relacionamentos, esse é o conceito central de bancos de dados relacionais.
Tuplas são uma parte inseparável de um banco de dados relacional, mas não são tão indispensáveis na programação. Algumas linguagens de programação têm sua própria sintaxe de tuplas, como python, F#, haskell, scala, etc., enquanto outras são mais populares, mas não possuem sintaxe de tuplas, como Java, JavaScript, C++, C#, etc.
Tuplas não são elementos de programação indispensáveis como arrays e objetos, mas seu uso pode ser muito conveniente para escrever código, especialmente quando uma função precisa devolver múltiplos valores. Nesse caso, a prática comum é definir um objeto, definir o valor que a função precisa devolver como atributo do objeto e, em seguida, definir o tipo de valor de retorno da função para o tipo do objeto. Ou você pode fazer com que essa função retorne uma estrutura de dados de mapa na qual os dados específicos existem. No entanto, ambas as abordagens têm suas falhas, e o primeiro método é confiável, mas o código é incomumente inchado. Os requisitos em si são muito simples, desde que a função retorne múltiplos valores, mas esse método exige definir um tipo antecipadamente, depois instanciar, depois definir as propriedades da instância e, finalmente, retornar, o que é muito ineficiente. Embora o segundo método seja rápido, mas não suficientemente seguro, dentro da função pode saber que tipo de valor está armazenado no mapa, mas fora da função, só saber que o valor de retorno dessa função é um mapa, como quais valores estão armazenados no mapa, qual tipo não é conhecido, em projetos de desenvolvimento multi-pessoa Essa desvantagem é especialmente evidente, infelizmente essa prática é a solução preferida em algumas linguagens tipadas dinamicamente, o que também é uma das razões fundamentais pelas quais linguagens tipadas dinamicamente são reclamadas por sua baixa segurança e legibilidade. Portanto, a melhor solução para esse tipo de problema é usar tuplas.
Em linguagens onde a própria sintaxe suporta tuplas, tuplas são representadas por parênteses, como (int, bool, string) é um tipo triplo, e seu valor pode ser (1, true, "abc"). Deve-se notar que cada tipo de tupla é único, (int, bool), (bool, int), (string, double) são todos binários, mas são tuplas diferentes, se você tomar uma certa tupla aqui como valor de retorno da função, embora não seja tão boa quanto a primeira solução usando tipos personalizados mencionados anteriormente em termos de legibilidade e segurança, é muito melhor do que a segunda solução usando map; pelo menos usando tuplas pode saber quantos valores a função irá retornar, Que tipo de valor são esses valores, e tem a vantagem de ser simples e rápido codificar um segundo esquema usando map.
Felizmente, essas linguagens de programação agora suportam genéricos, e a implementação de tuplas não integradas se tornou extremamente simples, mas, afinal, é um elemento sintático incorporado não à linguagem, e definitivamente não é tão conveniente de usar quanto tuplas nativas.
O seguinte apresenta uma biblioteca de tuplas Java de terceiros, chamada Javatuples, com sua própria página oficial e centenas de estrelas no github, que quase desempenha uma posição de monopólio no campo das tuplas Java.
Javatuples definem uma tupla com comprimento máximo de 10, mas acho que o número de elementos em uma 10-tupla já é demais, e basicamente não há legibilidade. As classes de tuplas são definidas da seguinte forma:
Unidade<A> (1 elemento)
Par<A, B> (2 elementos)
Trigémeo<A, B, C> (3 elementos)
Quarteto<A,B,C,D> (4 elementos)
Quinteto<A,B,C,D,E> (5 elementos)
Sexteto<A,B,C,D,E,F> (6 elementos)
Septeto<A,B,C,D,E,F,G> (7 elementos)
Octeto<A,B,C,D,E,F,G,H> (8 elementos)
Enéade<A,B,C,D,E,F,G,H,I> (9 elementos)
Década<A,B,C,D,E,F,G,H,I,J> (10 elementos)
Essas classes arquetípicas são classes genéricas, então as letras entre colchetes podem ser substituídas por tipos arbitrários. Abaixo está um exemplo de código binário
Ao tirar inferências, os demais tipos de tuplas são usados da mesma forma.
Como as tuplas do Java não são suportadas pela própria linguagem, o código parece javanês e menos elegante. No entanto, ao escrever código, além da conveniência de escrever pode melhorar a eficiência, é mais importante prestar mais atenção ao significado expresso pelo próprio código, que é usar o significado (função) da tupla para aprimorar o código, e a forma de escrevê-la é na verdade apenas secundária.
Por fim, deve-se notar que o tipo nos colchetes genéricos não pode ser o tipo básico de Java; se você quiser usar o tipo básico, ele também deve ser o tipo básico que foi boxeado, como o tipo int deve ser convertido em inteiro, e o tipo bool corresponde ao tipo booleano. |
Publicado em 31/08/2021 11:22:41
|
|
|
|
Senhorio|
Publicado em 15/09/2021 10:55:08
|
