Please note, this is a STATIC archive of website www.tutorialspoint.com from 11 May 2019, cach3.com does not collect or store any user information, there is no "phishing" involved.
object HelloWorld {
def main(args: Array[String]) {
println("Hello, world!1")
println(gcdLoop(2,28))
}
def gcdLoop(x: Long, y: Long): Long = {
var a = x
var b = y
while (a != 0) {
val temp = a
a = b % a
b = temp
}
b
}
}
object HelloWorld {
sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A](head: A, tail: List[A]) extends List[A]
object List {
def sum(ints: List[Int]): Int = ints match {
case Nil => 0
case Cons(x,xs) => x + sum(xs)
}
def product(ds: List[Double]): Double = ds match {
case Nil => 1.0
case Cons(0.0, _) => 0.0
case Cons(x,xs) => x * product(xs)
}
def apply[A](as: A*): List[A] =
if (as.isEmpty) Nil
else Cons(as.head, apply(as.tail: _*))
def tail[A](ls: List[A]): List[A] = ls match {
case Nil => Nil
case Cons(_,t) => t
}
def setHead[A](ls: List[A], nHead: A): List[A] = ls match {
case Nil => Nil
case Cons(_,t) => Cons(nHead,t)
}
def drop[A](l: List[A], n: Int): List[A] = l match {
case Cons(h,t) => if (n>0) drop(t,n-1) else l
}
def dropWhile[A](l: List[A], f: A => Boolean): List[A] = l match {
case Nil => Nil
case Cons(h,t) => if (!f(h)) l else dropWhile(t,f)
}
def init[A](l: List[A]): List[A] = l match {
case Nil => Nil
case (_,Nil) => Nil
case Cons(h,t) => Cons(h,init(t))
}
}
def main(args: Array[String]) {
val a = List(22,2,3,4,5) match { case Cons(_,t) => t }
val b= List.dropWhile(List(22,11,22,44,55), (x:Int) => x==22 )
val c= List.drop(List(22,11,22,44,55), 2 )
println(c)
}
}
//Scala é uma linguagem compilada, então antes de executar o código,
//é necessário compilar o arquivo
import Array._
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
//Define uma classe
object HelloWorld {
//Inicio do main
def main(args: Array[String]) {
//É necessário o println() para os comandos pois diferentemente do Clojure o resultado não é retornado no final
//Operadores
println((1 + 2) * 3)
//Strings podem ser concatenadas com '++'
println("Hello, " ++ "Scala!")
//utilizando o operador s juntamente com o println podemos
//concatenar variaveis em uma string
val name = "James"
println(s"Hello, $name")
//O mesmo pode ser feito para expressões
println(s"1 + 1 = ${1 + 1}")
//Métodos
//São chamados com .nomeMetodo e não são necessários os ( )
//caso não sejam utilizados argumentos
println("Hello, Scala".size)
println("Hello, Scala".toUpperCase)
println("foo".drop(1))
println("bar".take(2))
println(1.to(10))
println((0 until 10).contains(10))
//Operadores são métodos com nomes simbólicos
//Expressões aritméticas podem também ser escritas como abaixo
println((3).+(2))
//equivalente a
println(3 + 2)
//Como a linguagem é compilada, os tipos serão verificados,
//então expressões como a abaixo geram erro
//1.to("5")
//Declaração de variáveis
//val ou var nomeDaVariavel : DataType = [valor]
var minhaVariavel : String = "sou mutável"
val minhaVariavel2 : String = "sou imutável"
println(minhaVariavel)
//Scala permite ARMAZENAR FUNÇÕES DENTRO DE VARIÁVEIS
val sum = (x: Int, y: Int) => x + y
//Em C++
//...
//function <int, int> sum = [](x, y) {return (x + y); };
//...
//No exemplo abaixo a Lista numbers é filtrada com valores em que isPar for verdadeiro
//Será criada uma Lista nova com os valores pares
val isPar = (x : Int) => x % 2 == 0
val numbers = List(1,2,3,4,5,6,7,8,9)
println(numbers.filter(isPar))
//O método map percorre toda a coleção aplicando alguma alteração desejada
//No exemplo abaixo, o map irá retornar o número da posição x ao quadrado
println(numbers.map(x => x * x))
numbers.foreach(println)
//Uma função atribuindo uma variável, que também é uma função
val f = (x: Int) => 2 * x
def g(f: Int => Int, x: Int) = f(x)
println("g chama função f: " + g(f, 3) )
//Função que faz a tabuada
// int *tabuada(int n) {
// int vet[11];
// for(i=0; i<=10; i++){
// if( (i*n)%2 == 0)
// vet[i] = i*n;
// }
// return *vet;
// }
//Com scala:
def tabuada(n: Int) = (0 to 10) map {_*n} filter {_%2 == 0}
print(tabuada(2))
//O tipo pode ser omitido, e assim a variavel será do tipo do valor atribuido a ela
var variavelInteira = 10
println(variavelInteira.getClass)
//Associação múltipla
//Se um bloco de código ou um método retornar uma Tupla, esta tupla poderá ser associada a uma variável
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")
println(myVar1, myVar2)
//Sintaxe função
//def functionName ([list of parameters]) : [return type]
def square(x: Double) = x * x
println(square(3.0))
//Outro exemplo de função
def soma(a: Int, b: Int ) : Int = {
var sum: Int = 0
sum = a + b
return sum
}
println(soma(2,6))
//Podem também ser usadas funções recursivas
def fatorial(n: Int): Int = if (n == 1) 1 else fatorial(n - 1) * n
println("Fatorial de 3 = " + fatorial(3))
//Array Sintaxe:
var meuArray: Array[String] = new Array[String](3)
//ou
var meuArray2 = new Array[String](3)
meuArray = Array("Scala", "Haskell", "Clojure")
//A linguagem também possui metodos de iteração
// Printar todos os elementos do array
for ( x <- meuArray ) {
println( x )
}
//Array multidimensional
// necessário usar import Array._
var minhaMatrix = ofDim[Int](3,3)
// inicializando a matrix com número da coluna
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
minhaMatrix(i)(j) = j;
}
}
// Mostra os valores de um array Bi-dimensinal
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + minhaMatrix(i)(j));
}
println();
}
//IF-ELSE Sintaxe:
var x = 30;
if(x > 10){
println("é maior que 10")
} else{
println("é menor ou igual a 10")
}
//Tratamento de Exceções
//necessário importar as exceções
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
} finally {
println("Exiting finally...")
}
}
}
//Scala é uma linguagem compilada, então antes de executar o código,
//é necessário compilar o arquivo
import Array._
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
//Define uma classe
object HelloWorld {
//Inicio do main
def main(args: Array[String]) {
//É necessário o println() para os comandos pois diferentemente do Clojure o resultado não é retornado no final
//Operadores
println((1 + 2) * 3)
//Strings podem ser concatenadas com '++'
println("Hello, " ++ "Scala!")
//utilizando o operador s juntamente com o println podemos
//concatenar variaveis em uma string
val name = "James"
println(s"Hello, $name")
//O mesmo pode ser feito para expressões
println(s"1 + 1 = ${1 + 1}")
//Métodos
//São chamados com .nomeMetodo e não são necessários os ( )
//caso não sejam utilizados argumentos
println("Hello, Scala".size)
println("Hello, Scala".toUpperCase)
println("foo".drop(1))
println("bar".take(2))
println(1.to(10))
println((0 until 10).contains(10))
//Operadores são métodos com nomes simbólicos
//Expressões aritméticas podem também ser escritas como abaixo
println(3.+(2))
//equivalente a
println(3 + 2)
//Como a linguagem é compilada, os tipos serão verificados,
//então expressões como a abaixo geram erro
//1.to("5")
//Declaração de variáveis
//val ou var nomeDaVariavel : DataType = [valor]
var minhaVariavel : String = "sou mutável"
val minhaVariavel2 : String = "sou imutável"
println(minhaVariavel)
//O tipo pode ser omitido, e assim a variavel será do tipo do valor atribuido a ela
var variavelInteira = 10
println(variavelInteira.getClass)
//Associação múltipla
//Se um bloco de código ou um método retornar uma Tupla, esta tupla poderá ser associada a uma variável
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")
println(myVar1, myVar2)
//Sintaxe função
//def functionName ([list of parameters]) : [return type]
def square(x: Double) = x * x
println(square(3.0))
//Outro exemplo de função
def soma(a: Int, b: Int ) : Int = {
var sum: Int = 0
sum = a + b
return sum
}
println(soma(2,6))
//Podem também ser usadas funções recursivas
def fatorial(n: Int): Int =
if (n == 1)
1
else
fatorial(n - 1) * n
println("Fatorial de 3 = " + fatorial(3))
//Array Sintaxe:
var meuArray: Array[String] = new Array[String](3)
//ou
var meuArray2 = new Array[String](3)
meuArray = Array("Scala", "Haskell", "Clojure")
//A linguagem também possui metodos de iteração
// Printar todos os elementos do array
for ( x <- meuArray ) {
println( x )
}
//Array multidimensional
// necessário usar import Array._
var minhaMatrix = ofDim[Int](3,3)
// inicializando a matrix com número da coluna
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
minhaMatrix(i)(j) = j;
}
}
// Mostra os valores de um array Bi-dimensinal
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + minhaMatrix(i)(j));
}
println();
}
//IF-ELSE Sintaxe:
var x = 30;
if(x > 10){
println("é maior que 10")
} else{
println("é menor ou igual a 10")
}
//Tratamento de Exceções
//necessário importar as exceções
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
} finally {
println("Exiting finally...")
}
}
}
abstract class Currency(symbol: String){
val s:String = symbol
}
class Euro(eu: Int, cen: Int = 0) extends Currency("EUR") with Ordered[Euro] {
var euro: Int = eu
var cents: Int = cen
var inCents: Int = (euro * 100) + cents
def +(x: Euro): Unit = {
val a = x.cents + cents
val b = x.euro + euro + (a / 100)
cents = a % 100
euro = b
}
def *(that: Int): Unit = {
val a = cents * that
val b = euro * that + (a / 100)
cents = a % 100
euro = b
}
override def toString: String = {
s + " " + euro + "," + (if (cents == 0) "--" else cents)
}
override def compare(that: Euro): Int = {
if (inCents > that.inCents) {
1
} else if (inCents == that.inCents) {
0
} else {
-1
}
}
}
object Euro {
def fromCents(cents: Int): Euro = {
new Euro(cents / 100, cents % 100)
}
}
object HelloWorld {
def main(args: Array[String]): Unit ={
val e = new Euro(12,0)
println(e)
}
}
