Listas F# Mutáveis
Neste artigo, nosso objetivo é ajudá-lo a entender como criar, modificar e iterar em F# Mutable Lists . Você aprenderá como trabalhar com listas de forma funcional, independentemente do seu nível de experiência com F#.
Seja você iniciante ou um desenvolvedor experiente, este guia fornecerá informações valiosas sobre como criar, modificar e iterar nessas listas.
A programação funcional adere ao princípio fundamental de usar estruturas de dados imutáveis, mas há momentos em que estruturas de dados mutáveis são mais apropriadas.
Uma dessas instâncias é quando um algoritmo precisa modificar uma lista no local, que é um procedimento comum em muitos algoritmos.
Para esse propósito, a classe List <T> é frequentemente usada, pois define uma lista fortemente tipada de objetos que podem ser acessados por índice.
No entanto, as contrapartes mutáveis da classe List também estão disponíveis. Assim como os arrays, as listas fornecem uma maneira de acessar uma coleção de itens por meio de um índice.
No entanto, ao contrário dos arrays , as listas são redimensionáveis e o tamanho do objeto não precisa ser especificado durante o processo de declaração.
Criando listas mutáveis em F#
A forma mais simples de criar listas mutáveis em F# é usar a palavra-chave new e chamar o construtor da lista.
Isso pode ser demonstrado através do seguinte exemplo:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
open System.Collections.Generic
let fruits = new List<string>()
fruits.Add("Banana")
fruits.Add("Watermelon")
fruits.Add("Pear")
fruits.Add("Apple")
fruits.Add("Mango")
fruits.Add("Pineapple")
fruits |> Seq.iteri (fun index item -> printfn "%i: %s" index fruits.[index])
E o resultado será:
0: Banana 1: Watermelon 2: Pear 3: Apple 4: Mango 5: Pineapple
Classe F# List(T)
Essa classe List(T) se comporta como uma lista fortemente tipada de objetos cujos índices podem ser acessados para recuperar os objetos dentro dela.
Uma lista pode ser pesquisada, classificada e manipulada usando métodos fornecidos pelo programa.
Abaixo você encontrará as propriedades, construtores e métodos da classe List(T), listados nas tabelas a seguir:
| Propriedades | Visão geral |
| Capacidade | Este método pode ser usado para determinar o número total de elementos que a estrutura de dados interna é capaz de manter sem ter que redimensioná-la. |
| Contar | Ele retorna quantos elementos estão contidos na List(T). |
| Item | É usado para obter ou definir um elemento em um índice especificado por um valor de índice. |
| Construtores | Visão geral |
| Lista(T)() | Inicialmente, essa função cria uma instância vazia da classe List(T) com a capacidade inicial padrão de 1 e um item de lista vazio. |
| List(T)(IEnumerable(T)) | O construtor list() cria uma nova instância da classe List(T) na qual os elementos copiados da coleção especificada são inseridos na nova instância. Esta nova instância tem capacidade suficiente para acomodar o número de elementos copiados da coleção. |
| Lista(T)(Int32) | A classe List(T) é usada para criar novas instâncias da classe List(T) vazia que tem a capacidade inicial especificada e começa com uma lista vazia. |
| Métodos | Visão geral |
| Adicionar | Um novo objeto é adicionado ao final da List(T). |
| AddRange | Uma lista de elementos de uma coleção especificada será adicionada ao final de List(T). |
| AsReadOnly | Este método retorna um wrapper IList(T) que é somente leitura para a coleção atual. |
| Pesquisa Binária(T) | Usa o comparador padrão para procurar um elemento em uma List(T) classificada e retorna um com base no índice baseado em zero desse elemento dentro da List(T) classificada. |
| Pesquisa Binária(T, IComparer(T)) | Envolve a pesquisa de toda a lista classificada (T), usando o comparador especificado, para um elemento com base em seu índice baseado em zero e retornando o índice desse elemento. |
| BinarySearch(Int32, Int32, T, IComparer(T)) | Usando o comparador especificado, procura um elemento em um intervalo de elementos na List(T) classificada e retorna o número do índice baseado em zero do elemento como resultado da pesquisa. |
| Claro | Um método para remover todos os elementos de uma List(T). |
| contém | Esta função determina se um elemento pertence ou não à List(T). |
| ConvertAll(TOoutput) | A lista será convertida para outro tipo, e este resultado será uma lista contendo os elementos que foram convertidos. |
| CopiarPara(T[]) | A função copia cada elemento de List(T) em um array unidimensional compatível, começando desde o início do array de destino. |
| CopiarPara(T[], Int32) | Atribui a List(T) inteira ao índice especificado em uma matriz unidimensional compatível com List(T), começando no índice especificado na matriz de destino. |
| CopyTo(Int32, T[], Int32, Int32) | Existe um método que copia elementos de List(T) para uma matriz unidimensional compatível, começando no índice especificado na matriz de destino, copiando um elemento da matriz por vez. |
| Igual a (objeto) | Neste método, determinamos se o objeto especificado corresponde ao objeto atual ou não. (Herdado do objeto.) |
| Existe | List(T) é verificado para ver se os elementos em List(T) satisfazem as condições estabelecidas pelo predicado definido no teste. |
| Finalizar | A capacidade de executar outras operações de limpeza, como liberar recursos, antes que um objeto seja recuperado pela coleta de lixo, está disponível (herdada de Object). |
| Encontrar | Esse método procura elementos que atendam às condições especificadas no predicado especificado e retorna o primeiro elemento encontrado em toda a coleção de elementos contidos em List(T). |
| Encontrar tudo | Utilizando o predicado especificado na requisição, esta função retornará todos os elementos que atendem aos critérios definidos na requisição. |
| FindIndex(Predicado(T)) | Uma função de pesquisa que pesquisa em toda a lista de elementos aqueles que correspondem ao predicado especificado para retornar o índice baseado em zero da primeira instância do elemento em toda a List(T). |
| FindIndex(Int32, Predicado(T)) | Há um predicado na função List() que é usado para procurar elementos que correspondam às condições descritas pelo predicado. O resultado é o índice baseado em zero que representa a primeira ocorrência do elemento que corresponde ao predicado especificado dentro do intervalo de elementos em List(T). |
| FindIndex(Int32, Int32, Predicado(T)) | Como o predicado especifica, deve ser procurado o elemento que corresponda às condições especificadas pelo predicado, e a ordem em que ele aparece na List(T) deve ser determinada pelo índice baseado em zero alocado para a primeira ocorrência dentro do intervalo de elementos na List(T) que começa nesse índice e contém os elementos nesse intervalo. |
| FindLast | Existe um predicado que especifica as condições que precisam ser atendidas para retornar um elemento que corresponda a essas condições. Neste caso, retorna a última ocorrência encontrada em toda a List(T). |
| FindLastIndex(Predicate(T)) | A função Predicate search usa o predicado fornecido para buscar elementos que correspondam às condições definidas pelo predicado e retornará o índice baseado em zero da última ocorrência entre todos os elementos da List(T). |
| FindLastIndex(Int32, Predicado(T)) | Haverá alguns elementos dentro de List(T) que atendem aos predicados especificados pelo predicado e retornará o índice baseado em zero da última ocorrência para cada um dos elementos dentro do intervalo que se estende do primeiro elemento ao índice especificado na Lista(T). |
| FindLastIndex(Int32, Int32, Predicado(T)) | List(T) conterá alguns elementos que satisfazem os predicados especificados no predicado e, para cada elemento dentro do intervalo, começando do primeiro elemento até o índice especificado em List(T), o módulo retornará o índice de ocorrência baseado em zero de a última instância para cada elemento dentro do intervalo que se estende do primeiro elemento ao índice especificado em List(T). |
| Para cada | Especifica a ação que deve ser executada em cada elemento da List(T). |
| ObterEnumerador | Esta função retorna um enumerador capaz de iterar sobre List(T). |
| GetHashCode | Esta função é usada como a função de hash padrão. (Herdado do Objeto.) |
| GetRange | Criando uma cópia rasa de um intervalo de elementos que está contido em uma List(T) de origem. |
| GetType | O tipo da instância atual é retornado por este método. (Herdado de um objeto.) |
| IndexOf(T) | Um índice baseado em zero é retornado para indicar onde a primeira ocorrência do objeto especificado aparece em toda a List(T). |
| IndexOf(T, Int32) | Usando este método, você pode pesquisar e retornar o índice baseado em zero da primeira ocorrência do objeto especificado dentro do intervalo de elementos em List(T), começando no índice especificado e terminando com o último elemento. |
| IndexOf(T, Int32, Int32) | Esta função executa uma busca por um objeto especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo dos elementos na List(T) que contém o número especificado de elementos começando naquele índice especificado e que começa no especificado índice. |
| Inserir | Esta função insere um elemento no índice dado na List(T). |
| Intervalo de Inserção | List(T) é usado para inserir elementos de uma coleção em um índice especificado na coleção. |
| LastIndexOf(T) | Localiza o objeto especificado pelo parâmetro de objeto e retorna o índice baseado em zero que indica onde o objeto ocorreu pela última vez em toda a List(T). |
| LastIndexOf(T, Int32) | Esta função procura o objeto especificado e retorna o índice baseado em zero de sua última ocorrência do primeiro elemento da List(T) para o índice especificado dentro do intervalo de elementos na List(T). |
| LastIndexOf(T, Int32, Int32) | Retorna um índice baseado em zero da última ocorrência dentro de um Range(T) consistindo no número especificado de elementos e terminando no índice especificado dentro de um Range(T) contendo o número especificado de elementos dentro do intervalo de elementos. |
| MemberwiseClone | Este método criará uma cópia rasa do objeto atual. (Herdado do objeto.) |
| Remover | Esta função removerá a primeira instância de um objeto específico da List(T). |
| Deletar tudo | Um predicado que corresponde às condições do elemento especificado é removido da lista. |
| RemoveAt | Um método que remove o elemento no índice especificado de uma List(T). |
| RemoveRange | Existe uma opção para remover um intervalo de elementos de uma List(T). |
| Reverter() | O método reverse inverte a ordem dos elementos em toda a List(T). |
| Reverso(Int32, Int32) | Esta função inverte a ordem dos elementos dentro do intervalo especificado. |
| Organizar() | Uma operação de classificação é executada em todos os elementos em uma List(T) usando o comparador padrão. |
| Ordenar(Comparação(T)) | É um método que classifica todos os elementos de uma List(T) usando o System especificado. Fazendo uma comparação (T). |
| Sort(IComparer(T)) | Usando o comparador especificado, esse método classifica todos os elementos em toda a List(T) na ordem especificada. |
| Sort(Int32, Int32, IComparer(T)) | Usando o comparador especificado, os elementos em List(T) são classificados com base no intervalo de elementos da lista. |
| ToArray | Array() cria um novo array a partir dos elementos de List(T) copiando-os para ele. |
| Para sequenciar | A função retorna uma string contendo o nome do objeto atual. (Herdado de um objeto.) |
| TrimExcess | Ao chamar a função, o nome do objeto atual será retornado como uma string de objeto. Uma classe que herda de um objeto. |
| TrueForAll | O propósito desta função é determinar se todos os elementos em List(T) satisfazem as condições identificadas pelo predicado especificado. |
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Creating a List
open System.Collections.Generic
let fruits = new List<string>()
fruits.Add("Banana")
fruits.Add("Watermelon")
fruits.Add("Pear")
fruits.Add("Apple")
fruits.Add("Mango")
fruits.Add("Pineapple")
printfn"Total %d fruits" fruits.Count
fruits |> Seq.iteri (fun index item -> printfn "%i: %s" index fruits.[index])
fruits.Insert(1, "Roots")
printfn("\nAfter inserting at index 1")
printfn"Total %d Fruit list will be" fruits.Count
fruits |> Seq.iteri (fun index item -> printfn "%i: %s" index fruits.[index])
fruits.RemoveAt(2)
printfn("\nAfter removing from index 2")
printfn"Total %d Fruits" fruits.Count
fruits |> Seq.iteri (fun index item -> printfn "%i: %s" index fruits.[index])
E a saída será a seguinte:
Total 6 fruits 0: Banana 1: Watermelon 2: Pear 3: Apple 4: Mango 5: Pineapple After inserting at index 1 Total 7 Fruit list will be 0: Banana 1: Roots 2: Watermelon 3: Pear 4: Apple 5: Mango 6: Pineapple After removing from index 2 Total 6 Fruits 0: Banana 1: Roots 2: Pear 3: Apple 4: Mango 5: Pineapple
Exemplo de Explicação
- Você pode ver o exemplo acima do uso da linguagem de programação F# para criar uma lista de frutas. Para fazer isso, a classe List <T> do namespace System.Collections.Generic é usada. Esta classe permite armazenar elementos de qualquer tipo de dados em uma coleção, neste caso, o tipo de dados utilizado é uma string.
- Depois que a lista é criada, o método Add da classe List <T> é usado para adicionar seis frutas à lista. A propriedade Count é então usada para obter o número de elementos na lista, que é impressa usando printfn .
- Em seguida, a função Seq.iteri é usada para iterar na lista e imprimir cada elemento com seu índice. Essa função usa uma função como argumento e a aplica a cada elemento da sequência. Nesse caso, a função recebe dois argumentos: index e item, onde index é o índice do item atual e item é o próprio item atual.
- Depois disso, o código usa o método Insert da classe List <T> para inserir a string “ Roots ” no índice 1 da lista. A propriedade Count é usada novamente para imprimir o número de elementos na lista e a função Seq.iteri é usada novamente para imprimir a lista atualizada.
- O método RemoveAt da classe List <T> é usado para remover o elemento no índice 2 da lista. A propriedade Count é usada mais uma vez para imprimir o número de elementos da lista, e a função Seq.iteri é usada pela terceira vez para imprimir a lista atualizada.
Nós valorizamos o seu feedback.
+1
+1
+1
+1
+1
+1
+1
