Object HelloScala{ def main(args :Array[String]){ println "Welcome to scala" } }
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 { def main(args: Array[String]) { println("Hello, world!") val list = List.range(50,500); val listList = List(List("a"),List("fat"),List("Cat")); println(list.filter(x=> x%2==1 && x>50 && x<300)); println(listList); val other = listList.toList.map(x=>x.toString); val characters = "Hello World!"; for(char <- characters) { println(char); } } }
object HelloWorld { def main(args: Array[String]) { println("Hello, world!") } }
import org.apache.spark.SparkContext import org.apache.spark.SparkConf object HelloWorld { def main(args: Array[String]) { val conf = new SparkConf().setAppName("HelloWorld") //create spark context object val sc = new SparkContext(conf) val text = sc.textFile("/tmp/wordcount.txt") val counts = text.flatMap(line => line.split(" ")).map(word => (word,1)).reduceByKey(_+_) counts.collect } }
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...") } } }
object HelloWorld { def main(args: Array[String]) { val constant = 87 val myList = List(2, 4, 6,8,10,12) val kv :: kovi :: thanooj = myList var first = kv println("myFirstFunctiom : "+ myFirstFunctiom(first.toString)) println("myStringFunction : "+ myStringFunction) println("MaxFunction : "+ max(1,2)) listOfmultiType(1) listOfmultiType("hi") println( myList.foldLeft(0) { (a ,b)=> a+b }) println( myList.foldLeft(0) { ( _ + _ )}) val hasUpperCase = myStringFunction.exists(_.isUpper) println("hasUpperCase : "+ hasUpperCase) install myList.foreach(print) } def myFirstFunctiom(data:String) :String = { return data } def myStringFunction() ="this is the sample text from myStringFunction" def max(a:Int,b:Int) :Int = { if(a>b) a else b } def listOfmultiType[CustomType] (value:CustomType) =List(value) def break = new RuntimeException("break exception") def install = { val env = System.getenv("SCALA_HOME") if(env == null) break println("found the scala home lets countinue the operation") } }
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) } }
We use cookies to provide and improve our services. By using our site, you consent to our Cookies Policy. Accept Learn more