Tutorial Scala

Resumo do tutorial Scala

Este tutorial do scala cobre todos os aspectos e tópicos do scala. Você aprenderá todos os fundamentos do zero, como o que é scala, o processo de instalação do scala, programas Scala, funções Scala, avaliação preguiçosa, interface de tipo, classes e objetos, herança, abstrações, Java e diferenças de escala, etc.

Scala é uma linguagem escalável usada para escrever software para múltiplas plataformas. Por isso recebeu o nome de “Scala”. Esta linguagem destina-se a resolver os problemas de Java enquanto simultaneamente é mais conciso. Inicialmente projetado por Martin Odersky, foi lançado em 2003.

Por que aprender Scala

Aqui estão as principais razões para aprender a linguagem de programação Scala:

• Scala é fácil de aprender para programadores orientados a objetos, Java desenvolvedores. Está se tornando uma das línguas populares nos últimos anos.
• Scala oferece funções de primeira classe para usuários
• Scala pode ser executado em JVM, abrindo caminho para a interoperabilidade com outras linguagens.
• Ele foi projetado para aplicativos simultâneos, distribuídos e resilientes orientados por mensagens. É uma das línguas mais exigentes desta década.
• É uma linguagem concisa, poderosa e pode crescer rapidamente de acordo com a demanda de seus usuários.
• É orientado a objetos e possui muitos recursos de programação funcional, proporcionando muita flexibilidade para os desenvolvedores codificarem da maneira que desejarem.
• Scala oferece muitos tipos de pato
• Tem menos clichê se você vem de Java
• Os frameworks Lift and Play escritos em Scala estão em curva de crescimento.

Como instalar Scala

Para começar a escrever programas Scala, você precisa instalá-lo em seu computador. Para fazer isso, você precisará visitar o site deles https://www.scala-lang.org/download/ para baixar a versão mais recente do Scala.

Seguindo o link, somos levados a duas opções que podemos escolher para instalar o Scala em nossas máquinas. Para este tutorial do Scala, faremos o download do IntelliJ IDEA.

Depois de visitar o link de download, você encontrará duas versões do IntelliJ IDE.

Para este tutorial do Scala, baixaremos a Community Edition, que é gratuita e vem com tudo que você precisa para escrever programas Scala.

Passo 1) Selecione a edição da comunidade
Na página, clique no menu suspenso Community Edition.

Ele nos apresenta a opção de baixar o IDE IntelliJ junto com o JBR que contém uma implementação JDK(Java Development Kit) OpenJDK que Scala precisa para compilar e executar o código.

Passo 2) Execute a instalação
Depois de baixar o IntelliJ, clique duas vezes nele para executar o assistente de instalação e siga a caixa de diálogo.

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

Se por acaso você não baixou aquele com o JDK, ainda receberemos um prompt onde podemos verificar para baixá-lo marcando a caixa de seleção.

Passo 4) Clique em próximo
Deixe os outros padrões como estão e clique em Avançar.

Passo 5) Clique no ícone de inicialização
Assim que a instalação for concluída, execute o IDE IntelliJ clicando em seu ícone de inicialização no menu de inicialização como um aplicativo normal.

Você ainda precisa passar por uma etapa adicional para adicionar o plugin Scala ao IntelliJ; você faz isso clicando no menu suspenso no menu de configuração localizado na parte inferior direita da tela e selecionando a opção de plugin.

Na aba Marketplace, uma busca por Scala apresentará o plugin como o primeiro resultado na tag Languages.

Passo 6) Instalar plugin
Clique em instalar, que iniciará o download do plugin.

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

Depois de reiniciar, você estará na mesma página de quando executamos o IDE, mas desta vez já instalamos o plugin Scala.

Programa Scala Olá Mundo

Passo 1) Selecione a opção Criar Projeto, que nos levará a uma página onde podemos selecionar o tipo de linguagem que nosso projeto utilizará.

Passo 2) escolha Scala marcando a caixa de seleção Scala e clique em próximo.

Passo 3) Selecione um local para salvar nosso arquivo de projetos e dê um nome ao nosso projeto.

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

Levará algum tempo para carregar alguns índices, então não se preocupe se você não conseguir fazer nada imediatamente enquanto houver uma barra de progresso na parte inferior do seu IDE, significa simplesmente que seu IDE está carregando alguns arquivos necessários para executar o Scala e ajuda com o preenchimento automático do IDE.

Passo 4) A seguir, clicaremos na aba de projetos à esquerda do IDE e expandiremos para podermos ver o conteúdo do nosso projeto.

No momento o projeto está vazio e contém apenas uma pasta .idea e um arquivo hello-world.iml gerado pelo IDE. Nosso ponto de interesse é a pasta src. Src é onde armazenamos o código fonte do nosso projeto. É onde criaremos nosso primeiro arquivo Scala.

Passo 5) Clique com o botão direito em src para abrir um menu para criar um novo arquivo Scala.

Criaremos então um nome para o arquivo, neste tutorial do Scala usaremos hello e depois escolheremos em um menu suspenso o que colocar como conteúdo do arquivo Scala. Selecione “Objeto”

Feito isso, teremos um arquivo Scala que possui um objeto Singleton que usaremos para executar nosso código.

Agora que você tem um arquivo Scala com um objeto Hello. Você escreverá seu primeiro programa estendendo o objeto criado usando a palavra-chave App.

Estender nosso objeto com App informa ao compilador qual código executar quando iniciar seu programa. Imediatamente após estender o App, uma seta verde aparece no lado esquerdo, indicando que agora você pode executar seu programa.

Dentro do objeto Hello, escrevemos uma função println() que é usada para imprimir o texto dentro dele no console. Executaremos nosso código clicando na seta verde.

Clicar na seta nos apresenta a opção Executar, olá, ao clicar nela nosso código começará a ser compilado e após alguns segundos veremos os resultados do nosso programa impressos no console que está embutido no IDE IntelliJ.

E pronto, instalamos o Scala com sucesso e executamos nosso primeiro programa.

O que você pode fazer com Scala

• Desenvolvimento web front-end com ScalaJS
• Desenvolvimento móvel, ambos Android Desenvolvimento e IOS – com Scala Native
• Bibliotecas do lado do servidor como HTTP4S, Akka-Http, Play Framework
• Internet das coisas usando
• Desenvolvimento de jogos
• PNL – Processamento de Linguagem Natural usando um conjunto de bibliotecas ScalaNLP
• Testando técnicas avançadas de programação, como Programação Funcional e Programação Orientada a Objetos
• Construa um aplicativo de comunicação altamente concorrente usando atores de uma biblioteca para JVM inspirada em Erlang
• Use-o para aprendizado de máquina usando bibliotecas como Figaro, que faz programação probabilística, e Apache Spark que.

Funções anônimas

A linguagem Scala possui funções anônimas, que também são chamadas literais de função. Sendo Scala uma linguagem funcional, muitas vezes significa que os desenvolvedores dividem grandes problemas em muitas tarefas pequenas e criam muitas funções para resolver esses problemas. Para facilitar a criação de funções, Scala contém essas funções que podem ser instanciado sem nome. Podemos atribuí-los diretamente a variáveis ​​​​ou definições 'def' conforme mostrado no exemplo de Scala abaixo:

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

Podemos então usar a maneira normal como usamos funções, passando parâmetros para elas a seguir.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Esses métodos são úteis quando queremos um código limpo e conciso. Podemos usar funções anônimas ao definir métodos que não sejam grandes e não exijam muito código em seu corpo. Eles são muito simples e não precisam de cerimônia para serem criados.

Esses métodos não estão limitados a funções com argumentos e podem ser usados ​​para instanciar métodos que não aceitam nenhum argumento.

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

A maioria dessas funções anônimas são usadas em outras partes do nosso código onde precisamos criar uma função rápida.

Outra razão pela qual essas funções também são chamadas de funções inline. O uso de funções anônimas é um padrão comum usado amplamente na biblioteca de coleções para executar ações rápidas em uma coleção.

Por exemplo, temos o método filter que usa uma função inline/função anônima para criar outra coleção apenas com elementos que atendam aos critérios que definimos 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 os métodos que temos como funções anônimas são aqueles que verificam se o valor que obtemos da lista é ímpar e par e retornam o item.

//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

No Scala, também é possível usar curingas onde os parâmetros da nossa função anônima não são nomeados. Por exemplo

var timesTwo = (_:Int)*2

timesTwo(5)
//10

Neste cenário, não nomeamos o parâmetro que estamos passando. A única coisa que usamos é um sublinhado 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. No Scala, temos uma palavra-chave chamada preguiçoso, que ajuda a lidar com valores que não queremos que sejam avaliados até que sejam referenciados.

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

Isso pode ser útil quando avaliar um valor pode ser um cálculo caro; se o valor não for sempre necessário, podemos evitar a execução de um cálculo caro que pode tornar nosso software lento, tornando nossa 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. Eles também ajudam a lidar com questões de dependência circular no código.

Caso as configurações sejam falsas, talvez não precisemos usar myExpensiveValue, o que pode nos levar a evitar cálculos caros, o que ajuda a garantir que os usuários se divirtam usando nosso aplicativo, pois nossas outras necessidades podem ser computadas adequadamente sem sobrecarregar o carneiro.

Caso as configurações sejam falsas, talvez não precisemos usar myExpensiveValue, o que pode nos levar a evitar cálculos caros, o que ajuda a garantir que os usuários se divirtam usando nosso aplicativo, pois nossas outras necessidades podem ser computadas adequadamente sem sobrecarregar o carneiro.

A preguiça também ajuda com argumentos de função, onde os argumentos só são usados ​​quando são referenciados dentro da função. Este 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 usam a forma de chamada por valor para avaliar argumentos. O parâmetro passado através da chamada por nome só será avaliado quando necessário no corpo da função e não será avaliado antes disso. Uma vez avaliado o valor, ele é armazenado e pode ser reutilizado posteriormente sem que seja necessário reavaliá-lo. Um conceito conhecido como memoização.

Inferência de tipo

No Scala, você não precisa declarar tipos para cada variável criada. Isso ocorre porque o compilador Scala pode fazer inferência de tipos com base na avaliação do lado direito. Isso permite que seu código seja mais conciso – nos livra de escrever clichês onde o tipo esperado é óbvio

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

Função de ordem superior

Uma função de ordem superior é uma função que pode receber funções como argumentos e retornar uma função como tipo de retorno. No Scala, as funções são consideradas cidadãs de primeira classe. Usar estas funções desta forma permite-nos ser muito flexíveis no tipo de programas que podemos fazer. Podemos criar funções dinamicamente e alimentar funcionalidades dinamicamente para outras funções.

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

Na função acima, passamos um int e uma função que recebe um int e retorna um int. Podemos passar qualquer função dessa 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 Int como saída. Um exemplo de função como essa seria aquela que gera um int aleatório para nós.

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

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

Podemos ter uma função que possui uma assinatura scala()=>Unit. Isso significa que as funções não recebem nada e não retornam um tipo. A função poderia estar fazendo algum tipo de cálculo, alterando algo para fazer algo predeterminado.

Porém, esses tipos de métodos não são incentivados, pois parecem ser uma caixa preta que pode afetar um sistema de maneiras desconhecidas. Eles também não são testáveis. Ter tipos de entrada e saída explícitos nos permite raciocinar sobre o que nossa função faz.

Uma função de ordem superior também pode retornar uma função.

Por exemplo, poderíamos criar um método que criaria uma função de potência, ou seja, pegaria um número e aplicaria potência a ele.

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

A função acima recebe um int. Nosso tipo de retorno é uma função anônima que recebe um Int x, * usamos o int x como argumento para a função de potência.

Escovando

No Scala, podemos converter uma função que recebe dois argumentos em uma que recebe um argumento por vez. Quando passamos um argumento, nós o aplicamos parcialmente e terminamos com uma função que leva um argumento para completar a função. Currying nos permite criar funções adicionando parcialmente alguns argumentos.

Isto pode ser útil para criar funções dinamicamente antes de termos um conjunto completo de argumentos

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Se precisarmos criar uma função que multiplique por algum número específico, não precisamos criar outro método de multiplicação.

Podemos simplesmente chamar .curried em nossa função acima e obter uma função que recebe primeiro um argumento e retorna uma função parcialmente aplicada

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Correspondência de padrões

Scala possui um poderoso mecanismo embutido para nos ajudar a verificar se uma variável corresponde a determinados critérios, da mesma forma que faríamos em uma instrução switch em Java ou em uma série de instruções if/else. A linguagem possui correspondência de padrões que podemos usar para verificar se uma variável é de um tipo específico. A correspondência de padrões no Scala é poderosa e pode ser usada para desestruturar os componentes que possuem um método unapply para obter os campos nos quais estamos interessados ​​diretamente da variável que estamos combinando.

A correspondência de padrões do Scala também fornece uma sintaxe mais agradável em comparação com a instrução switch.

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

Comparamos nossa variável a um conjunto de opções e, quando a variável que estamos combinando atende aos critérios, a expressão no lado direito da seta grossa (=>) é avaliada e retornada como resultado da correspondência.

Usamos um sublinhado para capturar casos que não correspondem em nosso código. Ele reflete o comportamento do caso padrão ao lidar com instruções 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 _ => //case we have a type we don't recognize do sth else
}

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

A correspondência de padrões verifica se a variável corresponde

O sublinhado funciona como um espaço reservado que corresponde a qualquer outra condição que não corresponda aos outros itens nas instruções case acima. Pegamos uma variável myItem e chamamos o método match.

• verificamos se myItem é verdadeiro usando e fazemos alguma lógica no lado direito da seta gorda “=>”.
• usamos o sublinhado para corresponder a qualquer coisa que não corresponda a nenhuma das instruções case que definimos no código.

Com as classes Case, podemos ir ainda mais longe e desestruturar a classe para obter campos dentro do objeto.

Ao usar a palavra-chave selada para definir nossas classes, temos o benefício de fazer com que o compilador verifique exaustivamente os casos que tentamos comparar e nos avise se esquecermos de lidar com um caso específico.

Imutabilidade

É possível criar valores que não podem ser alterados por outras funções no Scala usando a palavra-chave val. Isto é conseguido em Java usando a palavra-chave final. No Scala, fazemos isso usando uma palavra-chave val ao criar uma variável em vez de usar var, que é a alternativa que usaríamos para criar uma variável mutável.

Uma variável definida usando a palavra-chave val é somente leitura, enquanto uma definida com var pode ser lida e alterada por outras funções ou arbitrariamente pelo usuário no código.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Tentar atribuir um valor a myNumber depois de declará-lo como val gera um erro em tempo de compilação ou “reatribuição para val”.

Por que usar Imutabilidade?

A imutabilidade nos ajuda a evitar que o código e outros programadores alterem nossos valores inesperadamente, o que levaria a resultados inesperados se eles pretendessem usar o valor que armazenamos, eles poderiam, em vez disso, fazer uma cópia dele. Dessa forma, evitam-se bugs que podem ser causados ​​por múltiplos atores alterando a mesma variável.

Classes e Objetos

Todos nós sabemos que os objetos são entidades do mundo real e a classe é um modelo que define os objetos. As classes têm estado e comportamentos. Os estados são valores ou variáveis. Os comportamentos são os métodos em Scala.

Vejamos como você pode definir uma classe, instanciá-la e usá-la usando Scala.

Aqui, a classe chamada Rectangle, que possui duas variáveis ​​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 instanciou 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 rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Todos os campos e métodos são públicos por padrão no Scala. É essencial usar override porque o método toString é definido para Object em Scala.

Herança

Scala tem vários tipos de herança (como única, multinível, múltipla, hierárquica, híbrida) que compartilham muito em comum com formas tradicionais encontradas em Java. Você pode herdar tanto de classes quanto de características. Você pode herdar os membros de uma classe para outra classe usando a palavra-chave “extends”. Isso permite a reutilização.

É possível herdar de uma classe ou de várias classes. Também é possível herdar de subclasses que possuem suas superclasses, criando uma hierarquia de herança no processo.

No exemplo Scala abaixo, a classe Base é Circle e a classe derivada é Sphere. Um círculo possui um valor chamado raio, que é herdado da classe Sphere. 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 
    }
  }

Abstração

No Scala, podemos criar métodos abstratos e campos membros usando classes e características abstratas. Dentro de classes e características abstratas, podemos definir campos abstratos sem necessariamente 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 a característica ou classe abstrata. Você pode usar características para criar contratos sobre o que nosso aplicativo deve ser capaz de fazer e implementar esses métodos posteriormente.

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

Dessa forma, podemos planejar a aparência de nosso aplicativo sem implementar os métodos que podem nos ajudar a imaginar como serão os vários métodos. Ele segue um padrão conhecido como programação para abstrações e não para a implementação real.

A classe precedida pela palavra-chave abstract pode conter métodos abstratos e não abstratos. Porém, heranças múltiplas não são suportadas na classe abstrata. Portanto, você pode estender no máximo uma classe abstrata.

Objetos Singleton

Um Singleton é uma classe que só é instanciada uma vez em um programa. É de um padrão de programação popular e útil conhecido como “padrão singleton”. É útil na criação de instâncias que devem ter vida longa e serão comumente acessadas em todo o programa, cujo estado é essencial na coordenação dos eventos de um sistema. Criar tal classe no Scala é fácil, pois o Scala nos fornece um meio simples de criar singletons usando a palavra-chave object.

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

Podemos então referenciar esse objeto em todo o nosso programa com a garantia de que todas as partes do nosso programa verão os mesmos dados, pois há 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 no Scala, por isso você precisa usar objetos singleton, que agem como membros estáticos de uma classe.

Classes implícitas

Classes implícitas são as novas funcionalidades adicionadas após a versão 2.1. É principalmente para adicionar novas funcionalidades às classes fechadas.

A palavra-chave implícita deve ser definida em uma classe, objeto ou característica. O construtor primário de uma classe implícita deve ter exatamente um argumento em sua primeira lista de parâmetros. Também pode incluir uma lista de parâmetros implícitos adicionais.

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

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Você precisa importar na classe onde está usando.

import StringUtil.StringEnhancer

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

Programação Orientada a Objetos (OOP) vs. Programação Funcional (FP)

Na POO, os programas são construídos agrupando dados e as funções que operam nesses dados em unidades altamente conectadas. Os objetos carregam seus dados nos campos e métodos que operam neles. Neste estilo de programação, a principal abstração são os dados, pois os métodos criados têm como objetivo operar nos dados.

Programação funcional, por outro lado, separa os dados e as funções que operam nos dados. Isso permite que os desenvolvedores tratem as funções como abstração e força motriz ao modelar programas.

Scala permite a programação funcional tendo funções como cidadãos de primeira classe, permitindo que sejam passadas como valores para outras funções e também retornadas como valores. A combinação desses dois paradigmas fez do Scala uma ótima opção na construção de software complexo em diversos setores, como Data Science.

Frameworks importantes no Scala

Aqui estão alguns frameworks importantes do Scala

• Jogar é uma estrutura de aplicativo da web de código aberto que usa Arquitetura MVC. Lançado em 2007 e agora licenciado sob Apache, tornou-se o framework mais popular no GitHub em 2013. Empresas como LinkedIn, Walmart, Samsung, Eero usam este framework.
• Levantar é outro framework web gratuito escrito em Scala lançado em 2007. Foursquare usa o framework Lift. É de alto desempenho e mais rápido de construir uma estrutura.
• Como
• Gatos - Leecork
• Spark

Suporte de simultaneidade

• Os valores em Scala são imutáveis ​​por padrão. Isso o torna muito adaptável ao ambiente simultâneo.
• Existem muitos recursos no Scala que o tornam ideal para aplicativos simultâneos.
• Futuros e Promessas facilitam o processamento de dados de forma assíncrona, apoiando assim o paralelismo.
• Akka – kit de ferramentas que usa modelo de simultaneidade de ator. Existem vários atores que atuam quando recebem mensagens.
• Simultaneidade usando threads de Java também pode ser suportado em Scala.
• O processamento de fluxo é outro ótimo recurso que permite o processamento contínuo de dados em tempo real.

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

• Nativo Java tópicos
• Fibras de bibliotecas como Vertex
• ZIO – uma biblioteca que possui primitivas para nos ajudar a lidar com simultaneidade e computação assíncrona
• STM – Transação
• Futuro – embutido na linguagem Scala

Java vs.

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

Scala	Java
Mais compacto e conciso	Pedaços de código comparativamente maiores
Projetado e desenvolvido para ser uma linguagem orientada a objetos e funcionais. Suporta uma ampla variedade de recursos de programação funcional, como simultaneidade e imutabilidade.	Originalmente desenvolvida como uma linguagem orientada a objetos e começou a oferecer suporte a recursos de programação funcional nos últimos dias. Ainda não é forte como linguagem de programação funcional.
Usa modelo de ator para suportar simultaneidade que é moderna	Usa o modelo convencional baseado em thread para simultaneidade.
Suporta estruturas – Play, Lift	Suporta Spring, Grails e muito mais
Suporta avaliação preguiçosa	Não suporta avaliação preguiçosa
Nenhum membro estático	Contém membros estáticos
Suporta sobrecarga do operador	Não suporta sobrecarga do operador
A compilação do código-fonte é comparativamente lenta	A compilação do código-fonte é mais rápida que Scala
Características – agir como Java 8 interfaces	Java 8 interfaces tentam preencher a lacuna entre classes e interfaces
É necessário reescrever	Não é necessário reescrever
Nenhuma garantia sobre os códigos livres de bugs	Garantia completa de defeitos menores
Suporta compatibilidade com versões anteriores.	Scala não suporta compatibilidade com versões anteriores.
Operators são tratados de forma diferente em Java e não são chamadas de método.	Todos os operadores nas entradas são através de um método chamado em Scala.
Suporta múltiplas heranças usando classes, mas não por classes abstratas	Não suporta múltiplas heranças usando classes, mas sim por interfaces
O código é escrito em formato compacto.	O código é escrito em formato longo.
Scala não contém a palavra-chave estática.	Java contém a palavra-chave estática.

Resumo

Neste tutorial, você aprendeu como começar a usar Scala. Você também aprendeu os recursos funcionais e orientados a objetos. Você também descobriu as semelhanças e diferenças entre Java e Scala. Este tutorial deve ter ajudado você com uma ampla variedade de exemplos bem demonstrados.