Quando devo escolher Vector no Scala?

Parece que Vector estava atrasado para a festa das coleções Scala, e todas as publicações influentes do blog já haviam saído.

Em Java ArrayListé a coleção padrão - eu poderia usar, LinkedListmas apenas quando eu pensei em um algoritmo e me preocupei o suficiente para otimizar. No Scala, devo usar Vectorcomo padrão Seqou tentar descobrir quando Listé realmente mais apropriado?

Como regra geral, o padrão é usar Vector. É mais rápido que Listem quase tudo e mais eficiente em memória para sequências de tamanho maior que trivial. Consulte esta documentação do desempenho relativo do vetor em comparação com as outras coleções. Existem algumas desvantagens em seguir Vector. Especificamente:

• As atualizações na cabeça são mais lentas do que List(embora não tanto quanto você imagina)

Outra desvantagem antes do Scala 2.10 foi que o suporte à correspondência de padrões era melhor List, mas isso foi corrigido no 2.10 com generalização +:e:+ extratores.

Há também uma maneira mais abstrata e algébrica de abordar essa questão: que tipo de sequência você tem conceitualmente ? Além disso, o que você é fazendo conceitualmente com isso? Se eu vir uma função que retorna um Option[A], sei que ela possui alguns buracos em seu domínio (e, portanto, é parcial). Podemos aplicar essa mesma lógica às coleções.

Se eu tenho uma sequência do tipo List[A], estou afirmando efetivamente duas coisas. Primeiro, meu algoritmo (e dados) é totalmente estruturado em pilha. Segundo, estou afirmando que as únicas coisas que farei com esta coleção são cheias, O (n) travessias. Esses dois realmente andam de mãos dadas. Por outro lado, se eu tiver algo do tipo Vector[A], a única coisa que afirmo é que meus dados têm uma ordem bem definida e um comprimento finito. Assim, as afirmações são mais fracas Vectore isso leva a uma maior flexibilidade.

Bem, a Listpode ser incrivelmente rápido se o algoritmo puder ser implementado apenas com ::, heade tail. Eu tive uma lição objetiva disso muito recentemente, quando venci o Java splitgerando um em Listvez de um Array, e não consegui vencê-lo com mais nada.

No entanto, Listtem um problema fundamental: não funciona com algoritmos paralelos. Não posso dividir um Listem vários segmentos ou concatená-lo novamente, de maneira eficiente.

Existem outros tipos de coleções que conseguem lidar com o paralelismo muito melhor - e Vectoré um deles. Vectortambém possui ótima localidade - o que Listnão ocorre - o que pode ser uma vantagem real para alguns algoritmos.

Portanto, considerando todas as coisas, Vectoré a melhor opção, a menos que você tenha considerações específicas que tornam uma das outras coleções preferíveis - por exemplo, você pode escolher Streamse deseja uma avaliação e cache preguiçosos ( Iteratoré mais rápido, mas não faz cache), ouList se o algoritmo é naturalmente implementado com as operações que mencionei.

By the way, é preferível usar Seqou IndexedSeqa menos que você quer um pedaço específico de API (como List's ::), ou mesmo GenSeqou GenIndexedSeqse o seu algoritmo pode ser executado em paralelo.

Algumas das declarações aqui são confusas ou até erradas, especialmente a ideia de que é imutável. O vetor em Scala é semelhante a um ArrayList. List e Vector são estruturas de dados imutáveis ​​e persistentes (isto é, "baratas para obter uma cópia modificada"). Não existe uma opção padrão razoável, como pode ser para estruturas de dados mutáveis, mas depende do que o seu algoritmo está fazendo. List é uma lista vinculada individualmente, enquanto Vector é um número inteiro de base 32, ou seja, é um tipo de árvore de pesquisa com nós de grau 32. Usando essa estrutura, o Vector pode fornecer operações mais comuns razoavelmente rápidas, ou seja, em O (log_32 ( n)). Isso funciona para pré-acrescentar, acrescentar, atualizar, acesso aleatório, decomposição na cabeça / cauda. A iteração em ordem seqüencial é linear. A lista, por outro lado, apenas fornece iteração linear e pré-tempo constante, decomposição na cabeça / cauda.

Pode parecer que o vetor substitui a lista em quase todos os casos, mas o prefixo, a decomposição e a iteração são frequentemente as operações cruciais nas seqüências de um programa funcional, e as constantes dessas operações são (muito) maiores para o vetor devido a à sua estrutura mais complicada. Fiz algumas medições, para que a iteração seja cerca de duas vezes mais rápida para a lista, o prefixo é cerca de 100 vezes mais rápido nas listas, a decomposição na cabeça / cauda é cerca de 10 vezes mais rápida nas listas e a geração de um traversable é cerca de 2 vezes mais rápida para vetores. (Provavelmente, porque o Vector pode alocar matrizes de 32 elementos ao mesmo tempo quando você o cria usando um construtor, em vez de acrescentar ou acrescentar elementos um por um).

Então, qual estrutura de dados devemos usar? Basicamente, existem quatro casos comuns:

• Nós só precisamos transformar sequências por operações como mapear, filtrar, dobrar, etc: basicamente, não importa, devemos programar nosso algoritmo genericamente e até nos beneficiar da aceitação de sequências paralelas. Para operações seqüenciais, a lista é provavelmente um pouco mais rápida. Mas você deve compará-lo se precisar otimizar.
• Precisamos de muito acesso aleatório e atualizações diferentes, portanto devemos usar o vetor, a lista será proibitivamente lenta.
• Operamos em listas de uma maneira funcional clássica, construindo-as pré-anexando e iterando por decomposição recursiva: lista de uso, o vetor será mais lento por um fator de 10 a 100 ou mais.
• Temos um algoritmo de desempenho crítico que é basicamente imperativo e faz muito acesso aleatório em uma lista, algo como uma classificação rápida no local: use uma estrutura de dados imperativa, por exemplo, ArrayBuffer, localmente e copie seus dados de e para ele.

Para coleções imutáveis, se você deseja uma sequência, sua principal decisão é usar um IndexedSeqou a LinearSeq, o que fornece garantias diferentes de desempenho. Um IndexedSeq fornece acesso aleatório rápido a elementos e uma operação rápida. Um LinearSeq fornece acesso rápido apenas ao primeiro elemento via head, mas também possui uma tailoperação rápida . (Retirado da documentação Seq.)

Para um, IndexedSeqvocê normalmente escolheria um Vector. Ranges e WrappedStrings também são IndexedSeqs.

Para um, LinearSeqvocê normalmente escolheria um Listou seu equivalente preguiçoso Stream. Outros exemplos são Queues e Stacks.

Assim, em termos de Java, ArrayListusado da mesma forma que o Scala Vectore LinkedListda Scala List. Mas no Scala eu tenderia a usar a List com mais frequência do que Vector, porque o Scala tem um suporte muito melhor para funções que incluem a travessia da sequência, como mapeamento, dobragem, iteração etc. Você tenderá a usar essas funções para manipular a lista como um vetor. todo, em vez de acessar aleatoriamente elementos individuais.

Em situações que envolvem muito acesso aleatório e mutação aleatória, um Vector(ou - como dizem os médicos - a Seq) parece ser um bom compromisso. Isso também é o que as características de desempenho sugerem.

Além disso, a Vectorclasse parece funcionar bem em ambientes distribuídos sem muita duplicação de dados, porque não há necessidade de fazer uma cópia na gravação para o objeto completo. (Consulte: http://akka.io/docs/akka/1.1.3/scala/stm.html#persistent-datastructures )

Se você está programando imutável e precisa de acesso aleatório, o Seq é o caminho a seguir (a menos que você queira um conjunto, o que geralmente é necessário). Caso contrário, a Lista funciona bem, exceto que suas operações não podem ser paralelizadas.

Se você não precisar de estruturas de dados imutáveis, fique com o ArrayBuffer, pois é o equivalente do Scala ao ArrayList.