---
# System prepended metadata

title: '**Primeiras escaladas com Scala**'

---

# **Primeiras escaladas com Scala**
Fernando Sá, Guilherme Schoenell, Vitor Hugo Haberkamp, Luiz Thomasini e Willian Rosa.

![](https://i.imgur.com/F8uoipT.png)

## Introdução
Scala é uma linguagem multiparadigma de propósito geral, que integra características da orientação a objetos e linguagem funcional. Foi desenvolvida em 2001 na Suíça, com seu primeiro lançamento ao público em 2003, sendo remodelado em 2006 na versão 2.0.

A linguagem foi criada numa tentativa de corrigir erros do java, e aproveitar algumas partes dela. Por exemplo, uma das características que ajudaram a linguagem a ganhar  popularidade é a interoperabilidade com o java, pois é traduzida para Java Bytecodes, podendo assim utilizar a Java Virtual Machine, mantendo assim grande parte das vantagens do java, como o suporte a multi-plataformas e multi-threads, mas tenta, através de elementos de linguagens funcionais, corrigir erros como a verbosidade. Além disso, a linguagem também importa todas as classes dentro do pacote “java.lang”.

Se diz que Scala é orientada a objetos pois todo valor é um objeto, e características como herança estão presentes. Se diz que é funcional pois toda função é um valor, fornecendo uma sintaxe mais leve.

Hoje a linguagem já é utilizada por grandes empresas, como LinkedIn, Twitter, Netflix e Airbnb. Entretanto o uso é diferente em diferentes empresas. No LinkedIn, é utilizada com outras linguagens juntamente com outras ferramentas, no Twitter o interesse é pela performance e flexibilidade. Na Netflix é utilizado pelos algoritmos de busca, APIs e recomendações. Tumblr utilizou a linguagem desde o início devido a escalabilidade, enquanto o Airbnb utiliza scala para toda parte financeira, especialmente pela sua tipagem segura, boa performance e alta confiabilidade. 


****
## Hello World!
```
package main

object Main {

    def main(args:Arrays[String]) {
        print(“Hello World!”)
    }
}
```
Analisando o **Hello World** em **Scala**, é possível notar que o seu código é muito semelhante ao do **Java**.

Primeiramente é definido um object e dentro dele existe o método main. Dentro do método main é feito a chamada da função print, passando como parâmetro a String **Hello World!**. Note que uma das características da linguagem Scala é que o uso de ponto e vírgula ao final da linha é opcional, diferentemente do Java.

****
## Variáveis e tipos de dados
Na linguagem Scala, temos **variáveis** e **valores**. Enquanto variáveis podem ser reatribuídas, valores são constantes e não podem ser reatribuídos. 

Veremos também que as variáveis são tipadas e o tipo precisa ser declarado explicitamente. 

### Variáveis
Para visualisarmos melhor as diferenças entre **variáveis** e **valores**, vamos declarar uma variável "num", do tipo Inteiro e atribuir 7 à ela. Depois vamos reatribuir à ela o inteiro 21.
```
var num: Int = 7
num = 21
```
Agora, tentaremos atribuir um ponto flutuante e observe o erro que é disparado.
```
num = 7.21
```
```
<console>:25: error: type mismatch;
 found : Double(7.21)
 required: Int
 num = 7.21
```
### Valores
Agora para os valores, vamos criar uma string com o nome do CEO da Amazon, "Jeff Bezos".
```
val nome_ceo = “Jeff Bezos”
```
Observe agora o que acontece se tentarmos atribuir "Elon Musk" ao valor.
```
nome_ceo = “Elon Musk”
```
```
<console>:25: error: reassignment to val
nome_ceo = “Elon Musk”
```

### Tipos de Dados
Assim como no Java, Scala suporta os seguintes tipos de dados:
* Inteiros
* Ponto flutuantes
* Texto
* Booleanos
* Outros (byte, long, char, null, ...)

Aqui vamos comentar os 4 primeiros citados porque consideramos os mais importantes para quem está iniciando.

#### Inteiros e Ponto flutuantes
Para os tipos numéricos inteiro e ponto flutuante, Scala usa as definições Integer e Double. A declaração é a seguinte:
```
var inteiro: Int = 7
var ponto_flutuante: Double = 7.21
```

#### Texto
Valores textuais são atribuidos à variáveis do tipo String. Para isso utilizamos aspas duplas. Dessa forma:
```
var string: String = "Texto"
```

#### Booleanos
Booleanos são valores binários de verdadeiro ou falso. São atribuidas em letra minúscula, dessa forma:
```
var bool: Boolean = true
```

### Estruturas de Dados
* Tuplas
* Listas
* Arrays
* Sets
* Maps
 
#### Tuplas
Tuplas são **imutáveis** e pode armazenar elementos de diferentes tipos. Por exemplo:
```
val tuple = (7, 7.21, “Kill Bill”, true)
```
#### Listas
No Scala, listas são **imutáveis** e elas podem ou não ser tipadas para um tipo específico de dado, ou não. Por exemplo:
```
val cidades: List[String] = ("Montenegro", "Sapucaia", "Farroupilha")
```
Ou
```
val lista_aleatória = List("Monenegro", 7.21, false)
```
#### Arrays
Uma das maiores diferenças entre listas e arrays é que as listas são imutáveis, e os arrays não. Isso significa que **podemos mudar o valor dos elementos de um array**.
Para declarmos um array fazemos assim:
```
val array_aleatório = Array("Monenegro", 7.21, false)
```
#### Sets
Sets são coleções que guardam apenas elementos únicos, que não são duplicados. Na Scala, podemos criar sets mutáveis e imutáveis. Por padrão eles serão imutáveis.
Veremos aqui como explicitamente criar sets imutáveis e mutáveis:
```
val set_imutavel = Set(1, 2, 3)

val set_mutavel = collection.mutable.Set(1, 2, 3)
```
Agora vamos utilizar duas maneiras diferentes para adicionar dois novos valores ao nosso set mutável:
```
set_mutavel.add(4)
set_mutavel += 5
```
#### Mapas
Mapas são a implementação em Scala de uma estrutura de dados mais conhecida como array associativo. Um mapa consiste em uma coleção de pares de chave-valor. Cada par chave-valor mapeia a chave ao seu valor associado. Em Scala, mapas podem ser mutáveis ou imutáveis.
Podemos criar um mapa dessa forma:
```
val mapa_animais = Map(("cachorro", 10), ("gato", 20), ("rato", 30))
```
Podemos acessar um valor no mapa com o index de sua chave:
```
mapa_animais("cachorro")
```
O resultado da linha acima será o valor associado a chave passada ao mapa. No caso obteremos o número '10'.

Agora vamos criar um mapa mutável e adicionar outro par chave-valor:
```
val mapa_animais_mutavel = collection.mutable.Map(("cachorro", 10), ("gato", 20), ("rato", 30))
mapa_animais_mutavel += ("pato" -> 40)
```

Outras funções dos mapas é conseguir resgatar todos os elementos das chaves ou valores em formato de lista. Fazemos isso desta forma:
```
mapa_animais_mutavel.keys
mapa_animais_mutavel.values
```

****
## Operações básicas

### Operações aritméticas
O Scala conta com os seguintes operadores aritméticos: 



| Representação | Operador          |
| --------      | --------          | 
| +             | menos             |
| -             | mais              |
| *             | multiplicação     |
| /             | divisão           |
| %             | restante          |

Abaixo, exemplos da utilização dos operadores aritméticos: 
```
object Test {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;
      var c = 25;
      var d = 25;
      println("a + b = " + (a + b) );
      println("a - b = " + (a - b) );
      println("a * b = " + (a * b) );
      println("b / a = " + (b / a) );
      println("b % a = " + (b % a) );
      println("c % a = " + (c % a) );
      
   }
}
```

### Operações relacionais
A linguagem também possui operadores relacionais, entre eles estão: 

|Representação  | Operador 		   |
|---------------|------------------|
|== 			|igual             |
|!= 			|não é igual       |
|> 	    		|maior que         |
|< 				|menor que         |
|>=     		|maior que ou igual|
|<=     		|menor que ou igual|

A seguir um exemplo da utilização dos operadores relacionais:

```
object Test {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;
      println("a == b = " + (a == b) );
      println("a != b = " + (a != b) );
      println("a > b = " + (a > b) );
      println("a < b = " + (a < b) );
      println("b >= a = " + (b >= a) );
      println("b <= a = " + (b <= a) );
   }
}

```

### Operações lógicas
Outros operadores que a linguagem scala contempla, são os operadores lógicos:

|Representação  | Operador 		   |
|---------------|------------------|
|&& 			|lógico "e"        |
|\|\|			|lógico "ou"       |
|!	    		|lógico "negação"  |

Na sequência a aplicação dos operadores lógicos:
```
object Test {
   def main(args: Array[String]) {
      var a = true;
      var b = false;

      println("a && b = " + (a&&b) );

      println("a || b = " + (a||b) );

      println("!(a && b) = " + !(a && b) );
   }
}

```

****
## Estrutura da linguagem

### Controle de fluxo
Instruções if: Na linguagem Scala, as instruções if seguem a lógica "if" -> "else if" -> "else", mas vamos começar com um exemplo simples.
Primeiramente, vamos criar uma variável chamada “numero” e atribuímos o valor 30 para ela.
```
var numero:int = 30
```
Agora faremos nossa primeira instrução if, que testa se o resto da divisão do valor contido na variável numero por 2 é zero, ou seja, se o número é um número par.
```
if (numero % 2 == 0){
	println("Par!")
} 
```
A seguir, faremos um exemplo de uma instrução if com uma cláusula “else if”, testando se a variável numero é menor que dez ou se ele está entre 10 e 80.
```
if (numero < 10){
    println("Menor que dez!")
} else if ((numero >= 10) && (numero <= 80)) {
    println("Entre dez e oitenta!")
}
```
Por fim, adicionaremos a cláusula “else”, que é executada por padrão caso a condição dos dois primeiros testes não seja aceita, ou seja, quando o valor da variável numero for maior que 80 neste exemplo.
```
if (numero < 10){
    println("Menor que dez!")
} else if ((numero >= 10) && (numero <= 80)) {
    println("Entre dez e oitenta!")
} else {
    println("Maior que oitenta!")
}
```
### Repetições
**Loops com for:** Para exemplificar o funcionamento do for em Scala, primeiramente vamos criar uma lista de animais.
```
var animais = List("cachorro", "gato", "cobra")
```
Agora vamos criar um loop usando essa lista.
```
for(item <- animais){
    println("É um animal!")
}
```
Neste exemplo, para cada item da lista animais, será exibido na tela a frase "É um animal!".

Também podemos imprimir cada item individualmente da lista:
```
for(item <- animais){
    println(item)
}
```
Por fim, vamos usar o for para percorrer um intervalo usando o formato "Array.range(start, stop, step)" para criar um intervalo de 0 a 20, usando como argumento step o número 5, o que fará com que o resultado avance de 5 em 5 números.
```
for(number <- Array.range(0,20,5)){
    println(number)
}
```
Perceba que o resultado impresso na tela ao executar esse bloco de código será:
```
0
5
10
15
```
Isso acontece porque na linguagem Scala, assim como em outras, o intervalo vai até 20 mas não inclui ele.

**Loops com while:** Os loops com while possuem um formato bem semelhante aos loops com for na linguagem Scala. 
Vamos criar um loop com while, usando uma variável "x" definida como "0". Se "x" for menor que 10, imprimiremos "x" e adicionaremos 1 a ele.
```
var x = 0

while(x < 10){
    println(s"x é atualmente $x; adicionando 1 para x")
    x = x + 1
}
```
Como resultado, teremos a seguinte saída:
```
x é atualmente 0; adicionando 1 para x
x é atualmente 1; adicionando 1 para x
x é atualmente 2; adicionando 1 para x
x é atualmente 3; adicionando 1 para x
x é atualmente 4; adicionando 1 para x
x é atualmente 5; adicionando 1 para x
x é atualmente 6; adicionando 1 para x
x é atualmente 7; adicionando 1 para x
x é atualmente 8; adicionando 1 para x
x é atualmente 9; adicionando 1 para x
```

### Funções
**Função de impressão simples:** Nesta função que criaremos como exemplo, vamos imprimir “Hello World!”.
```
def hello_print():  Unit = {
    println("Hello World!")
}

hello_print()
```
Usamos “def” para criar a função e precisamos fornecer o tipo de dado de saída, neste exemplo usamos o tipo “Unit”, Que é um tipo de dado geral.

**Função de retorno:** Para este exemplo de função de retorno, vamos criar uma função que recebe um argumento do tipo String: “Nome”. Esta função retornará uma frase de boas vindas concatenando o argumento recebido.
```
def bemVindo(nome: String): String = {
    return "Seja bem-vindo " + nome + "!"
}

bemVindo("Fernando")
```
Ao executar o código, teremos o seguinte resultado de saída:
```
Seja bem-vindo Fernando!
```

### Tratamento de exceções
O tratamento de exceções na linguagem Scala é muito semelhante ao que vemos na linguagem Java. Podemos tratar as exceções de duas formas: Usando throw ou usando try/catch.

Exemplo com throw:
```
def bemVindo(nome: String): String = {
  throw NullPointerException(s"Nome está vazio! Entre com um nome válido.")
  else return "Seja bem-vindo " + nome + "!"
}
```
Exemplo com try/catch:
```
def bemVindo(nome: String): String = {
  try
  {
    Var novoNome = nome.toUpperCase()
  } Catch {
    Case NullPointerException(msg) => msg
  }
  return "Seja bem-vindo " + novoNome + "!"
}
```
Em ambos os exemplos, testamos se a variável do tipo String passada por parâmetro na função, não está nula. A diferença é que com o throw capturamos o erro antes  e com o try/catch, tentamos executar a ação primeiro e caso o erro ocorra, lançamos a exceção.

### Classes
As classes na linguagem Scala são templates estáticos que podem ser instanciados com outros objetos em tempo de execução. Veja o exemplo:
```
class Ponto(var x: Int, var y: Int) {
  def move(dx: Int, dy: Int): Unit = {
    x = x + dx
    y = y + dy
  }
  override def toString: String =
    "(" + x + ", " + y + ")"
}
```
As classes em Scala são parametrizadas com argumentos de construtor. No exemplo acima, definimos dois parâmetros: x e y. Ambos são acessíveis em toda a classe.
Esta classe também possui dois métodos, move e toString. O método move recebe dois parâmetros do tipo Int mas não retorna nenhum valor. Note que o tipo de retorno Unit, equivale ao void do Java.
Já o método toString, não recebe nenhum parâmetro de entrada, mas retorna um valor do tipo String. Note que o toString sobrescreve o método pré-definido toString, o mesmo é marcado com a palavra-chave override.
Perceba que em Scala, não é preciso declarar um “return” em um método, pois o valor retornado será simplesmente o último valor no corpo do método.

****
## Bibliotecas
A linguagem Scala contém como tipos padrões: Int, Float, Array ou Option. Estes tipos são acessíveis em todas as compilações da linguagem e com isso não tem uma qualificação explícita ou que tenha necessidade de realizar a importação de bibliotecas.
    
A seguir, iremos mostrar as bibliotecas que fazem parte do projeto raiz do scala. 


### Bibliotecas com importação explícita

#### Scala Collection
É um pacote que contém uma coleção de frameworks que contém vectores, listas, estrutura de chaves e valor entre outros que serão mostrados logo a seguir. 
```
scala.collection
```

##### Immutable
É uma subpacote do scala collection que armazena as estruturas de dados sequenciais e imutavéis como por exemplo: Vector, List, Range, HashMap ou Hashset. 
```
scala.collection.immutable
```
##### Mutable
É uma subpacote do scala collection que armazena as estruturas de dados sequenciais e mutavéis como por exemplo: ArrayBuffer e StringBuilder.
```
scala.collection.mutable
```
#### Concurrent
É uma subpacote do scala collection que armazena as estruturas de dados concorrentes e mutavéis como por exemplo: TrieMap.
```
scala.collection.concurrent
```

#### Concurrent
É uma biblioteca de dados primitivos para programação simultânea como por exemplo: Futures e Promises.
```
scala.concurrent
```

#### IO
É uma biblioteca para entradas e saída de dados.
```
scala.io
```

#### Math
É uma biblioteca para operações básicas de matemáticas e tipos númericos adicionais como BigInt e BigDecimal.
```
scala.math
```

#### Sys
É uma biblioteca para interação com outros processos e o sistema operacional.
```
scala.sys
```

#### Matching
É uma biblioteca para utilização de expressão regulares.
```
scala.util.matching 
```

### Bibliotecas adicionais

As bibliotecas adicionais fazem parte da biblioteca principal do scala, porém estão separadores em arquivos ".jar". 

##### Reflect (scala-reflect.jar) 
É uma biblioteca de reflexão do Scala, que serve para um programa de se inspecionar e, possivelmente, até de se modificar.
```
scala.reflect 
```

##### XML (scala-xml.jar)
É uma biblioteca para realizar operações relacionadas a manipulação, serialização e análise em arquivos XML.
```
scala.xml
```

##### Parallel (scala-parallel-collections.jar)
É uma biblioteca inspirada na programação paralela (Parallel Programming).
```
scala.collection.parallel
```

##### Parsing (scala-parser-combinators.jar)
É uma biblioteca para conversão de dados de forma que ela análise o dado e combina.
```
scala.util.parsing
```

##### Swing (scala-swing.jar)
É uma biblioteca com base no JAVA GUI, que resumidamente serve para a parte de interface de gráfica.
```
scala.swing
```

****
## Conclusão
Acreditamos que o nosso tutorial pode servir como forma de auxílio para pessoas iniciantes, que acabam não entendendo nada sobre a linguagem e tem um conhecimento básico em outras linguagens de programação. Quem gostaria de um overview mais geral sobre o ambiente de desenvolvimento, não recomendamos este artigo, pois não ensinamos como configurar a IDE e suas "parafernalhas", entretanto no próximo tópico, iremos comentar sobre algumas dicas de onde buscar este conhecimento.

Mas falando em geral sobre o Scala, a linguagem apresenta uma sintaxe muito parecida e tende a ser menos verbosa ao Java, o que facilita no seu entendimento. Porém analisando o mercado brasileiro neste momento, o Scala ainda não é uma linguagem fortemente utilizada pelas empresas e com isso, vemos que é importante ainda saber pelo menos um pouco mais sobre o JAVA e depois se aprofundar mais nessa nova linguagem. 


### Próximos para quem quer se aprofundar
Para maior aprofundamento sobre a linguagem, recomendamos, principalmente os cursos da Udemy, que além de você aprender os conceitos de forma visual e prática, no final dos cursos é possivel emitir um certificado, o que é muito interessante para pessoas que utilizam Linkedin. Com isso, achamos o seguinte curso : "Dê os Primeiros Passos à Scala Lang de Forma Prática", que parece apresentar tópicos interessantes e também apresenta uma avaliação excelente por alunos. (Link https://www.udemy.com/course/introducao-a-scala-lang-primeiros-passos/)

Infelizmente, os cursos da Udemy são pagos, mas não são tão caros comparados a outros oferecidos na internet, além de que também não existem muitos cursos grátis para a linguagem. Entretanto achamos um curso básico no Youtube que pode servir de auxílio nos ensinos nos maiores picos da "escalagem" para a linguagem de programação. O curso está disponivel no canal do "JCranky" pelo link https://youtu.be/gtREsSfseyk.

****
## Referências

https://sysgears.com/articles/how-tech-giants-use-scala/

https://docs.scala-lang.org/pt-br/tour/tour-of-scala.html

http://www.w3big.com/pt/scala/scala-operators.html

https://www.scala-lang.org/api/current/

https://www.devmedia.com.br/conheca-a-linguagem-scala/32850

http://www.pt.w3ki.com/scala/scala_exception_handling.html

https://docs.scala-lang.org/pt-br/tour/classes.html

https://github.com/hjhuney/An-Intro-to-Scala

https://www.scala-lang.org/docu/files/ScalaTutorial-pt_BR.pdf

https://medium.com/@alessandroheres/scala-programming-an-introduction-33464b390d57








