Fluxos de scala

Scala é facilitar operações preguiçosas. Como todos os cálculos nessas coleções são adiados, eles não são estritamente definidos. Exploraremos os fluxos de Scala, que são os tipos únicos de listas neste artigo sobre fluxos em Scala. A coleção Scala, que armazena os dados também inclui o fluxo da Scala. A única diferença que separa isso de uma lista em Scala é quando é necessário para o scala quando os valores do fluxo são calculados. Como eles não carregam os dados de uma só vez, os fluxos de Scala são listas preguiçosas que apenas avaliam os valores conforme necessário. Isso melhora o desempenho do programa.

Sintaxe do fluxo em Scala no Ubuntu 20.04

A principal diferença entre um fluxo de Scala e uma lista é que os elementos de um fluxo são calculados lentamente, e não de uma vez. Nosso aplicativo é mais rápido, já que apenas os elementos que solicitamos são calculados. O fluxo de Scala, no entanto, é rápido.

Val Stream = 1 #:: 2 #:: 3 #:: Stream.vazio

Um fluxo pode ser criado usando a abordagem e o fluxo do #::.vazio no final da expressão em oposição a uma lista em Scala que pode ser criada com o operador ::.vazio. Um fluxo de números é dado como a especificação do fluxo. Nesse caso, 1 representa a cabeça do fluxo. Enquanto 2 e 3 representam a cauda do fluxo. Os comandos de Take, como os seguintes, podem ser usados ​​para recuperar os valores:

fluxo.levar (valor)

Exemplo 1: Criando um fluxo em Scala

Os exemplos para criar um fluxo em scala são dados nas seguintes ilustrações. Os elementos de um riacho são mantidos após serem avaliados.

Construímos o objeto como "stream1". Ele contém a definição principal do método dentro do bloco do método principal. Fizemos o código do fluxo do Scala. Para isso, declaramos primeiro a variável de palavra -chave "val" como "mystream". A variável "MyStream" é definida com um fluxo de três números. Usamos 2, 4 e 10 como números inteiros para o fluxo. Aqui, 2 é chamado de cabeça e os próximos dois números inteiros, 4 e 10, são chamados de cauda do fluxo. Utilizamos a hashtag "#" e a resolução de escopo "::" Operador entre os números inteiros. O fluxo.vazio está empregado no final do fluxo. Em seguida, chamamos a variável "MyStream" dentro da função Println para imprimir o fluxo especificado.

Os resultados mostram que a segunda parte não foi avaliada. Nesse caso, o elemento é substituído por um ponto de interrogação. As listas não são avaliadas pelo Scala até que sejam necessárias. A cauda não está impressa, pois ainda não foi calculada. Os fluxos são designados para computação preguiçosa.

Exemplo 2: Criando um fluxo com o fluxo.Pacote contras em scala

Fluxo.Contras também podem ser usados ​​para construir um fluxo. Para gerar fluxos, use o pacote importar “scala.coleção.imutável.Fluxo.contras ”.

Mencionamos o pacote scala “scala.coleção.imutável.Fluxos.contras ”em nossa seção de cabeçalho. Depois disso, fizemos um objeto como "stream2". A definição principal do método é fornecida para este objeto. Criamos a variável "s" com a ajuda da palavra -chave "val". Atribuímos o fluxo [int] para a variável "s". Então, chamamos os contras do fluxo. Cada contras do fluxo estão fechados dentro do outro. No final, usamos o fluxo.vazio nos últimos contras. Em seguida, temos o método println para imprimir o fluxo.Contras elementos. Utilizamos a interpolação da string "$ s" para imprimir os elementos do fluxo.

O fluxo imutável é gerado na tela de saída a seguir. Somente os elementos da cabeça do fluxo são obtidos e a cauda não é avaliada:

Exemplo 3: Usando a função Take on Stream em Scala

Para extrair os elementos de um fluxo, use a função Take.

Estabelecemos o objeto "Stream3" e designamos o método principal para ele. O método principal contém a declaração variável e a declaração de impressão para exibir. A variável é declarada aqui como "ST" e inicializada com o fluxo de três números ímpares. O fluxo é criado com o operador "#::" e o fluxo.vazio no final do riacho.

Após a criação do fluxo, exibimos -o com a função de impressão. Em seguida, pegamos os dois primeiros elementos do fluxo fornecido, passando o valor "2" no ST.Take () método. Em seguida, obtivemos os cinco primeiros elementos do fluxo passando o "5" no método do stream Take ().

Na primeira avaliação do fluxo, apenas um elemento é obtido. Depois de usar o comando do fluxo, recuperamos os dois primeiros elementos do fluxo. Além disso, buscamos os cinco primeiros elementos do fluxo. Como apenas três elementos são fornecidos ao fluxo, apenas três são acessados ​​na última saída. Observe que nenhum erro é lançado.

Exemplo 4: Usando o mapa no fluxo em scala

Usamos a função de mapa em um fluxo em um programa Scala. As operações do fluxo são realizadas usando a função do mapa.

Temos um objeto "Stream4", onde a principal definição do programa é chamada. Dentro do objeto "Stream4" da função, definimos uma variável "Stream". Aqui, criamos o fluxo com o operador "#::". O fluxo.vazio é usado no final da expressão do fluxo. O fluxo criado é impresso passando a variável "Stream" para a função Println. Em seguida, chamamos a função do mapa dentro de outra função impressa. Transformamos o fluxo de entrada com o novo fluxo com a ajuda da função do mapa.

A primeira saída obtida é o vapor e o próximo é o novo fluxo de mapa do fluxo anterior.

Exemplo 5: Inicializando um fluxo vazio em Scala

Um fluxo vazio pode ser inicializado usando o seguinte código:

Dentro do objeto "Stream5", classificamos o método principal. No método principal, criamos a variável "s_empty" e definimos o fluxo vazio. Em seguida, exibimos o fluxo vazio utilizando o método println e passamos a variável "s_empty".

A saída mostra que o fluxo está vazio. Além disso, ele exibe o fluxo vazio, mas não joga nenhum tipo de exceção.

Conclusão

Este é um manual de referência de fluxo de Scala. Aqui, passamos por como criar a função de fluxos em scala usando os exemplos de programação apropriados. Não calculamos o valor de um elemento de uma só vez no fluxo de Scala, mas um de cada vez. Quando o desempenho for um problema, use isso. Quando se trata de adquirir um elemento de fluxo, ele usa o método mais recente. Como apenas uma entrada é calculada por vez, o stream usa menos memória do que a lista.