Tutorial Scala

O que é Escala?

Scala Scala é uma linguagem de programação estaticamente tipada que combina programação orientada a objetos e programação funcional para melhorar a escalabilidade de aplicações. Scala roda principalmente na plataforma JVM, e desenvolvedores também podem usá-la para escrever software para plataformas nativas através do Scala-Native, ou para o navegador através do ScalaJS e do Scala.js. JavaScript tempo de execução.

Scala é uma linguagem escalável usada para construir software para múltiplas plataformas, o que explica seu nome. A linguagem foi projetada para resolver diversos problemas de verbosidade encontrados em... Java mantendo-se concisa. Martin Odersky projetou o Scala, e a primeira versão pública foi lançada em 2004.

Por que aprender Scala

Aqui estão os principais motivos para aprender a linguagem de programação Scala:

• Scala é fácil de aprender para programadores orientados a objetos e Java desenvolvedores, e se tornou uma das linguagens populares nos últimos anos.
• Scala oferece funções de primeira classe para os usuários.
• Scala pode ser executado em JVM, abrindo caminho para a interoperabilidade com outros idiomas.
• Ela foi projetada para aplicações concorrentes, distribuídas e resilientes, orientadas a mensagens, o que a torna uma das linguagens mais requisitadas desta década.
• É uma linguagem concisa e poderosa que pode crescer rapidamente de acordo com a demanda de seus usuários.
• É orientada a objetos e inclui muitos recursos de programação funcional, oferecendo aos desenvolvedores muita flexibilidade na forma como escrevem o código.
• Scala oferece Duck Typing por meio de tipos estruturais.
• Tem menos texto padrão do que Java.
• Os frameworks Lift and Play, escritos em Scala, continuam a amadurecer e a ganhar popularidade.

Como instalar Scala

Para começar a escrever programas em Scala, você precisa tê-lo instalado em seu computador. Para fazer isso, visite o site oficial em https://www.scala-lang.org/download/ Para baixar a versão mais recente do Scala.

Ao acessar o link, você encontrará duas opções para instalar o Scala. Para este tutorial de Scala, usaremos a primeira opção. IntelliJ IDEA, que oferece excelente suporte a Scala logo de início.

Ao acessar o link de download, você encontrará duas edições do IntelliJ IDE.

Para este tutorial de Scala, vamos baixar a Community Edition, que é gratuita e inclui tudo o que você precisa para escrever programas em Scala.

Passo 1) Selecione a Edição Comunitária.
Na página, clique no menu suspenso da Edição Comunitária.

Ele oferece a opção de baixar o IntelliJ IDE juntamente com o JBR, que contém uma implementação do JDK (Java Kit de Desenvolvimento (Development Kit), como o OpenJDK, que o Scala precisa para compilar e executar código.

Passo 2) Execute a instalação.
Após baixar o IntelliJ, clique duas vezes no instalador e siga o assistente na tela.

Passo 3) Selecione um local.
Escolha um local para instalar o IDE.

Se você não baixou o pacote com o JDK, o instalador ainda solicitará que você adicione o JDK por meio de uma caixa de seleção durante a instalação.

Passo 4) Clique em Avançar.
Deixe as outras configurações padrão como estão e clique em Avançar.

Programa Scala Olá Mundo

Passo 5) Clique no ícone de inicialização.
Após a conclusão da instalação, execute o IntelliJ IDE clicando no ícone de inicialização no menu Iniciar, como faria com qualquer outro aplicativo.

Você ainda precisa adicionar o plugin Scala ao IntelliJ. Clique no menu suspenso de configuração no canto inferior direito da tela e selecione a opção Plugins.

Na aba Marketplace, procure por Scala. O plugin aparecerá como o primeiro resultado na categoria Idiomas.

Passo 6) Instale o plugin.
Clique em Instalar para iniciar o download do plugin Scala.

Passo 7) Reinicie a IDE.
Após a conclusão do download, você será solicitado a reiniciar a IDE para que o plugin instalado possa começar a funcionar.

Após reiniciar, você retorna à mesma página de antes, mas agora o plugin Scala está instalado e pronto para uso.

Passo 8) Selecione "Criar projeto", que o levará a uma página onde você poderá escolher o idioma do projeto.

Passo 9) Selecione Scala marcando a caixa de seleção Scala e clique em Avançar.

Passo 10) Selecione um local para salvar o arquivo do projeto e dê um nome ao projeto.

Se o diretório não existir, o IntelliJ solicitará permissão para criar a pasta. Aceite e clique em Concluir. Você será então direcionado para o seu projeto Scala, que atualmente não contém nenhum código Scala.

O carregamento dos índices leva algum tempo, portanto, não se preocupe se não conseguir interagir com a IDE enquanto uma barra de progresso é exibida na parte inferior. A IDE está carregando os arquivos necessários para executar o Scala e fornecer o recurso de autocompletar.

Passo 11) Clique na aba Projeto, à esquerda da IDE, e expanda-a para visualizar o conteúdo do projeto.

Neste ponto, o projeto está vazio e contém apenas uma pasta .idea e um arquivo hello-world.iml gerado pela IDE. O ponto de interesse é a pasta src, que contém o código-fonte do projeto. É aqui que você cria seu primeiro arquivo Scala.

Passo 12) Clique com o botão direito do mouse em src para abrir um menu e criar um novo arquivo Scala.

Escolha um nome para o arquivo. Para este tutorial de Scala, use OláEm seguida, selecione "Objeto" no menu suspenso para o tipo de conteúdo do arquivo Scala.

Feito isso, você terá um arquivo Scala que contém um objeto singleton que você usará para executar o código.

Agora que você tem um arquivo Scala com um objeto Hello, escreva seu primeiro programa estendendo o objeto que você criou usando a palavra-chave App.

Estender o objeto com `App` informa ao compilador qual código executar quando o programa for iniciado. Imediatamente após estender `App`, uma seta verde aparece no lado esquerdo, indicando que o programa agora está pronto para ser executado.

Dentro do objeto Hello, escreva a função println() para imprimir o texto no console. Execute o programa clicando na seta verde.

Clicar na seta apresenta a opção Executar Olá. Selecionando-a, o código é compilado e, após alguns segundos, a saída do programa aparece no console do IntelliJ.

Você instalou o Scala com sucesso e agora pode executar seu primeiro programa.

O que você pode fazer com Scala

Scala é amplamente utilizado em diversos domínios devido à sua flexibilidade e interoperabilidade com a JVM. Casos de uso comuns incluem:

• Desenvolvimento web front-end com ScalaJS.
• Desenvolvimento móvel para Android e iOS com Scala Native.
• Bibliotecas do lado do servidor, como HTTP4S, Akka-Http e o Play Framework.
• Aplicações da Internet das Coisas (IoT).
• Desenvolvimento de jogos.
• Processamento de linguagem natural usando o conjunto de bibliotecas ScalaNLP.
• Praticar técnicas avançadas como programação funcional e programação orientada a objetos em conjunto.
• Aplicações de comunicação altamente concorrentes usando atores, uma biblioteca para a JVM inspirada em Erlang.
• Aprendizado de máquina com bibliotecas como Figaro para programação probabilística e Apache Spark para processamento de dados em larga escala.

Funções anônimas

A linguagem Scala suporta funções anônimas, também chamadas de funções anônimas. literais de funçãoComo Scala é uma linguagem funcional, os desenvolvedores frequentemente dividem grandes problemas em muitas tarefas pequenas e criam muitas funções. Para facilitar isso, Scala permite que as funções sejam instanciado sem nomeVocê pode atribuí-los diretamente a variáveis ​​ou a definições usando def, conforme mostrado no seguinte exemplo em Scala:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n * 3

Você pode então usá-las como funções regulares, passando parâmetros:

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Esses métodos são úteis quando você deseja um código limpo e conciso. Funções anônimas são úteis para definir métodos pequenos que não exigem muito código em seu corpo. Elas são muito simples e não precisam de nenhuma formalidade para serem criadas.

Esses métodos não se limitam a funções com argumentos e podem ser usados ​​para instanciar métodos que não recebem argumentos.

val sayHello = () => { println("hello") }

A maioria dessas funções anônimas é usada em outras partes do código onde você precisa de uma função rápida e eficiente. Por esse motivo, elas também são chamadas de... funções inlineO uso de funções anônimas é um padrão comum que aparece em toda a biblioteca de coleções para executar ações rápidas em uma coleção.

Por exemplo, o método filter recebe uma função inline para criar outra coleção contendo apenas os elementos que atendem aos critérios definidos na função anônima.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

Aqui, as funções anônimas verificam se o valor da lista é par ou ímpar e retornam o item correspondente.

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

Em Scala, também é possível usar curingas quando o parâmetro da função anônima não possui um nome. Por exemplo:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

Nesse cenário, você não nomeia o parâmetro. O sublinhado é usado para representá-lo.

Avaliação Preguiçosa

A maioria das linguagens avalia variáveis ​​e parâmetros de função sequencialmente, um após o outro. Em Scala, a palavra-chave lazy Ajuda a lidar com valores que você não deseja avaliar até que sejam referenciados.

Uma variável marcada como preguiçosa não é avaliada no local onde é definida, o que é comumente conhecido como avaliação imediata. Ela só é avaliada quando é referenciada posteriormente no código.

Isso pode ser útil quando avaliar um valor envolveria um cálculo dispendioso. Se o valor não for sempre necessário, você evita executar um cálculo custoso que pode tornar o software mais lento, tornando a variável preguiçosa.

lazy val myExpensiveValue = expensiveComputation

def runMethod() = {
    if(settings == true) {
        use(myExpensiveValue)
    } else {
        use(otherValue)
    }
}

Este não é o único caso de uso para variáveis ​​preguiçosas. Elas também ajudam a lidar com dependências circulares no código.

Se a opção de configuração estiver definida como falsa, você não precisa usar `myExpensiveValue`, o que evita cálculos dispendiosos. Isso garante uma experiência mais fluida para os usuários, pois os recursos não são desperdiçados com valores que nunca são lidos.

A abordagem lazy também é útil com argumentos de função, onde os argumentos são usados ​​apenas quando são referenciados dentro da função. Esse conceito é chamado de parâmetros de chamada por nome.

def sometimesUsedString(someValue:String, defaultValue: => String) = {
 if(someValue != null) {
   use(defaultValue)
 } else {
   use(someValue)
   }
 }

Muitas linguagens utilizam a abordagem de chamada por valor para avaliar argumentos. Um parâmetro passado por nome só é avaliado quando necessário dentro do corpo da função. Uma vez avaliado, o valor é armazenado e pode ser reutilizado posteriormente sem necessidade de reavaliação, um conceito conhecido como memoização.

Inferência de tipo

Em Scala, você não precisa declarar tipos para cada variável que cria, pois o compilador Scala pode inferir os tipos a partir do lado direito de uma expressão. Isso permite que seu código seja mais conciso e evita que você escreva código repetitivo onde o tipo esperado é óbvio.

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compiler infers that third is of type String

Função de ordem superior

Uma função de ordem superior é uma função que pode receber outras funções como argumentos e retornar uma função como tipo de retorno. Em Scala, as funções são consideradas cidadãs de primeira classe. Usar funções dessa forma permite grande flexibilidade nos tipos de programas que você pode construir. Você pode criar funções dinamicamente e passar funcionalidades dinamicamente para outras funções.

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int = {
    myMathFunction(n)
}

Na função acima, você passa um Int e uma função que recebe um Int e retorna um IntVocê pode passar qualquer função com essa assinatura. Por assinatura, queremos dizer a entrada e a saída de uma função. Uma assinatura de Int => Int Significa que uma função recebe um Int como entrada e retorna um Int como saída.

Uma assinatura de () => Int Significa que uma função não recebe nada como entrada e retorna um inteiro como saída. Um exemplo de tal função é uma que gera um inteiro aleatório.

def generateRandomInt() = {
 return scala.util.Random.nextInt()
}

A função acima possui uma assinatura () => Int.

Uma função também pode ter uma assinatura. () => UnitIsso significa que a função não recebe nada como parâmetro e não retorna nenhum tipo. Em vez disso, a função pode alterar algum estado ou executar uma ação predeterminada.

Esses tipos de métodos não são recomendados porque podem funcionar como uma caixa preta, afetando o sistema de maneiras desconhecidas. Além disso, são mais difíceis de testar. Ter tipos de entrada e saída explícitos permite que você entenda o que sua função faz.

Uma função de ordem superior também pode retornar uma função. Por exemplo, você poderia criar um método que retorna uma função de potenciação, que recebe um número e aplica um valor a ele.

def powerByFunction(n:Int): Int=>Int = {
  return (x:Int) => scala.math.pow(x,n).toInt
}

A função acima recebe um Int. Seu tipo de retorno é uma função anônima que recebe um Int. x e a utiliza como argumento para a função potência.

Escovando

Em Scala, você pode converter uma função que recebe dois argumentos em uma que recebe um argumento por vez. Ao passar um argumento, você o aplica parcialmente e obtém uma função que recebe o argumento restante para completar a chamada. O currying permite construir funções adicionando argumentos parcialmente.

Isso é útil para criar funções dinamicamente antes de se ter um conjunto completo de argumentos.

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

Se você precisa de uma função que multiplique por um número específico, não precisa criar outro método de multiplicação. Você pode aplicar um argumento à função curried e reutilizar o resultado:

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Correspondência de padrões

Scala possui um mecanismo integrado poderoso que ajuda a verificar se uma variável corresponde a determinados critérios, de forma semelhante a uma instrução switch em Python. Java ou uma cadeia de instruções if/else. A linguagem suporta casamento de padrões, que você pode usar para verificar se uma variável é de um tipo específico. O casamento de padrões em Scala é poderoso e pode desestruturar componentes que possuem um unapply Método para obter os campos que lhe interessam diretamente da variável que está sendo comparada.

O casamento de padrões em Scala também oferece uma sintaxe mais agradável do que uma instrução switch.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Você compara a variável a um conjunto de opções. Quando a variável atende aos critérios, a expressão à direita da seta grossa (=>) é avaliada e retorna o resultado da correspondência.

O sublinhado captura casos que não são correspondidos no código, espelhando o comportamento do caso padrão em uma instrução switch.

class Animal(var legs:Int, var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //unknown type, do something else
}

No código acima, você pode detectar o tipo do myItem variável e, com base nisso, ramificar para um código específico.

A correspondência de padrões verifica se a variável corresponde a cada caso em ordem.

O sublinhado funciona como um marcador que corresponde a qualquer condição que as outras instruções `case` não abranjam. Você pega uma variável myItem e ligue para o match método.

• Verifique se myItem is true e execute a lógica no lado direito da seta grossa “=>”.
• Use o sublinhado para indicar qualquer coisa que não corresponda a nenhuma das instruções `case` definidas no código.

Com classes de caso, você pode desestruturar a classe para extraccampos t dentro do objeto.

Ao utilizar a blockchain da sealed Ao usar a palavra-chave para definir classes, você obtém o benefício de ter o compilador verificando exaustivamente os casos que você tenta corresponder e avisando se você esquecer de tratar algum deles.

Imutabilidade

É possível criar valores que não podem ser alterados por outras funções em Scala usando o val palavra-chave. Isso é alcançado em Java usando o final palavra-chave. Em Scala, você usa um val ao criar uma variável em vez de var, que é a alternativa para variáveis ​​mutáveis.

Uma variável definida usando o val A palavra-chave é somente leitura, enquanto uma definida com var Pode ser lido e alterado posteriormente por outras funções ou pelo usuário no código.

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Tentando atribuir um valor a myNumber após declará-lo como um val gera um erro de tempo de compilação: “reatribuição para val”.

Por que usar Imutabilidade?

A imutabilidade ajuda a impedir que o código e outros programadores alterem valores inesperadamente, o que levaria a resultados imprevisíveis. Se os usuários de um valor precisarem alterá-lo, podem simplesmente fazer uma cópia. Dessa forma, evitam-se erros causados ​​por múltiplos agentes alterando a mesma variável.

Classes e Objetos

Objetos são entidades do mundo real, e uma classe é um modelo que define objetos. Classes possuem estado e comportamentos. Os estados são valores ou variáveis. Os comportamentos são os métodos em Scala.

A próxima seção mostra como definir uma classe, instanciá-la e usá-la em Scala.

Aqui está uma classe chamada Retângulo que possui dois valores e duas funções. Você também pode usar os parâmetros. l e b diretamente como campos no programa. Você tem um objeto que possui um método principal e instancia a classe com dois valores.

Exemplo:

class Rectangle(l: Int, b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

Em Scala, todos os campos e métodos são públicos por padrão. É essencial usar override Porque toString já está definido para cada objeto em Scala.

Herança

Scala possui múltiplos tipos de herança (simples, multinível, múltipla, hierárquica e híbrida) que compartilham muitas semelhanças com as formas tradicionais encontradas em linguagens de programação. JavaVocê pode herdar tanto de classes quanto de características. Você herda os membros de uma classe para outra usando a palavra-chave `herdate`. extendsIsso possibilita a reutilização.

É possível herdar de uma ou de múltiplas classes. Também é possível herdar de subclasses que, por sua vez, possuem suas próprias superclasses, criando assim uma hierarquia de herança.

No exemplo em Scala abaixo, a classe base é Circlee a classe derivada é SphereUm círculo possui um valor chamado raio, que é herdado na classe Esfera. O método calcArea é substituído usando a palavra-chave override.

Exemplo:

class Circle {
  val radius = 5
  def calcArea = {
    println(radius * radius)
  }
}
class Sphere extends Circle {
 override def calcArea = {
    println(radius * radius * radius)
  }
}
  object SphereObject {
    def main(args : Array[String]) {
      new Sphere().calcArea
    }
  }

Abstracção

Em Scala, você pode criar abstracmétodos t e campos de membros usando abstracclasses e características. Dentro de abstracPara classes e características, você pode definir abstraccampos t sem implementá-los.

Exemplo:

trait MakesSound {
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int) {
    val creatureName:String

    def printLegs():String = {
        return s"$creatureName has this number of legs: $legs"
    }
}

Esses campos são implementados pelas classes que estendem o trait ou abs.tracclasse t. Você pode usar características para criar construções.tracDefina o que um aplicativo deve fazer e, em seguida, implemente esses métodos posteriormente.

trait DatabaseService {
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

Dessa forma, você pode planejar a aparência de um aplicativo sem implementar os métodos, ajudaping Você imagina como vários métodos aparecerão. Isso segue um padrão conhecido como programação para abs.tracções em vez de à implementação real.

Uma aula precedida por abstract A palavra-chave pode conter ambos os abstract e não-abstracmétodos t. No entanto, a herança múltipla não é suportada em abstracclasses t, então você só pode estender um abs.tracclasse t.

Objetos Singleton

Um singleton é uma classe que é instanciada apenas uma vez em um programa. Ele vem de um padrão de programação popular e útil conhecido como "padrão singleton". É útil para criar instâncias que devem ter longa duração e serem acessadas com frequência ao longo do programa, onde o estado é essencial para coordenar eventos em um sistema. Criar uma classe desse tipo em Scala é fácil porque Scala fornece um meio simples de criar singletons usando o `std::string`. object palavra chave.

object UserProfile {
    var userName = ""
    var isLoggedIn:Boolean = false
}

Você pode então referenciar esse objeto em todo o programa com a garantia de que todas as partes do programa veem os mesmos dados, pois existe apenas uma instância dele.

def getLoggedInStatus():Boolean = {
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean = {
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return UserProfile.isLoggedIn
}

O conceito de membros estáticos não existe em Scala, razão pela qual você usa objetos singleton que se comportam como membros estáticos de uma classe.

Classes implícitas

Classes implícitas são um recurso adicionado na versão 2.10 e são usadas principalmente para adicionar novas funcionalidades a classes fechadas existentes.

O implicit A palavra-chave deve ser definida em uma classe, objeto ou trait. O construtor principal de uma classe implícita deve ter exatamente um argumento em sua primeira lista de parâmetros. Ele também pode incluir uma lista de parâmetros implícitos adicionais.

No exemplo em Scala abaixo, foi adicionada uma nova funcionalidade para substituir vogais de uma String por *.

object StringUtil {
  implicit class StringEnhancer(str: String) {

    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Você precisa importar a classe implícita na classe onde você a está utilizando.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Programação Orientada a Objetos (POO) vs. Programação Funcional (PF)

Em POO, os programas são construídos por grupos.ping Os dados e as funções que operam sobre esses dados são agrupados em unidades altamente conectadas. Os objetos carregam seus dados em campos e os métodos operam sobre eles. Nesse estilo de programação, a principal abstraçãotracA essência está nos dados, pois os métodos criados têm como objetivo operar sobre eles.

Programação funcionalPor outro lado, separa os dados das funções que operam sobre eles. Isso permite que os desenvolvedores tratem as funções como o absoluto.tracção e força motriz na modelagem de programas.

Scala possibilita a programação funcional ao tratar funções como cidadãs de primeira classe, permitindo que sejam passadas como valores para outras funções e retornadas como valores também. A combinação desses dois paradigmas tornou Scala uma ótima escolha para a construção de softwares complexos em setores como o de ciência de dados.

Frameworks importantes no Scala

Aqui estão alguns frameworks importantes para Scala:

• Jogar é uma estrutura de aplicativo da web de código aberto que usa Arquitetura MVCLançado em 2007 e agora licenciado sob a Apache, tornou-se um dos frameworks mais populares no GitHub em 2013. Empresas como o LinkedIn, WalmartSamsung e Eero usam essa estrutura.
• Levantar é outro framework web gratuito escrito em Scala, lançado em 2007. O Foursquare utiliza o framework Lift. É um framework de alto desempenho e rápido para desenvolvimento.
• Como Fornece um conjunto de ferramentas para construir aplicações orientadas a mensagens altamente concorrentes, distribuídas e resilientes na JVM.
• Gatos - Leecork é uma biblioteca que fornece abstracções para programação funcional.
• Spark É um mecanismo de análise unificado para processamento de dados em larga escala, amplamente utilizado em fluxos de trabalho de big data e aprendizado de máquina.

Suporte de simultaneidade

• Em Scala, os valores são imutáveis ​​por padrão, o que torna a linguagem muito adaptável a ambientes concorrentes.
• Scala possui muitas características que a tornam ideal para aplicações concorrentes.
• Futuros e Promessas facilitam o processamento de dados de forma assíncrona, apoiando assim o paralelismo.
• Akka é um conjunto de ferramentas que utiliza o modelo de concorrência de atores. Os atores agem quando recebem mensagens.
• Simultaneidade usando threads de Java Também é compatível com Scala.
• O processamento de fluxos de dados é outro excelente recurso que permite o processamento contínuo e em tempo real dos dados.

Scala tem algumas das melhores bibliotecas de simultaneidade do Java ecossistema:

• Nativo Java tópicos.
• Fibras de bibliotecas como o Vertx.
• ZIO é uma biblioteca que possui primitivas para auxiliar no tratamento de concorrência e computação assíncrona.
• Memória transacional de software (STM) para transações.
• Futuro, que já está integrado à linguagem Scala.

Java vs.

Aqui estão os principais diferenças entre Java e escala.

Perguntas Frequentes