1.2 scala basics

Type definitions
Scala Java

s: String String s
i: Int int i / Integer i

Variables
Scala: Java:

val s = “Hello World” public final String s = “Hello World”;

var i = 1 public int i = 1;

private var j = 3 private int j = 3;

Methods
Scala: Java:

def add(x: Int, y: Int): Int = { public int add(int x, int y) {
x+y return x + y;
} }

def add(x: Int, y: Int) = x + y

def doSomething(text: String) { public void doSometing(String text) {
} }

Methods (2)
Scala: Java:

myObject.myMethod(1) myObject.myMethod(1);
myObject myMethod(1)
myObject myMethod 1

myObject.myOtherMethod(1, 2) myObject.myOtherMethod(1, 2);
myObject myOtherMethod(1, 2)

myObject.myMutatingMethod() myObject.myMutatingMethod()
myObject.myMutatingMethod
myObject myMutatingMethod

Methods (3)
Scala: Java:

override def toString = ... @Override
public String toString() {...}

Classes and constructors
Scala: Java:

class Person(val name: String) public class Person {
private final String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
}

Traits (= Interface + Mixin)
Scala: Java:

trait Shape { interface Shape {
def area: Double public double area();
} }

class Circle extends Object with public class Circle extends Object
Shape implements Shape

No “static” in Scala
Scala: Java:

object PersonUtil { public class PersonUtil {
val AgeLimit = 18 public static final int
AGE_LIMIT = 18;

def countPersons(persons:
List[Person]) = ... public static int
countPersons(List<Person>
}
persons) {
...
}
}

if-then-else
Scala: Java:

if (foo) { if (foo) {
... ...
} else if (bar) { } else if (bar) {
... ...
} else { } else {
... ...
} }

For-loops
Scala: Java:

for (i <- 0 to 3) { for (int i = 0; i < 4; i++) {
... ...
} }

for (s <- args) println(s) for (String s : args) {
System.out.println(s);
}

While-loops
Scala: Java:

while (true) { while (true) {
... ...
} }

Exceptions
Scala: Java:

throw new Exception(“...”) throw new Exception(“...”)

try { try {
} catch { } catch (IOException e) {
case e: IOException => ... ...
} finally { } finally {
} }

Varargs
def foo(values: String*){ } public void foo(String... values){ }

foo("bar", "baz") foo("bar", "baz");

val arr = Array("bar", "baz") String[] arr = new String[]{"bar",
foo(arr: _*) "baz"}
foo(arr);

(Almost) everything is an expression
val res = if (foo) x else y

val res = for (i <- 1 to 10) yield i // List(1, ..., 10)

val res = try { x } catch { ...; y } finally { } // x or y

Collections – List
Scala: Java:

val numbers = List(1, 2, 3) List<Integer> numbers =
new ArrayList<Integer>();
val numbers = 1 :: 2 :: 3 :: Nil numbers.add(1);
numbers.add(2);
numbers.add(3);

numbers(0) numbers.get(0);
=> 1 => 1

Collections – Map
Scala: Java:

var m = Map(1 -> “apple”) Map<Int, String> m =
m += 2 -> “orange” new HashMap<Int, String>();
m.put(1, “apple”);
m.put(2, “orange”);

m(1) m.get(1);
=> “apple” => apple

Generics
Scala: Java:

List[String] List<String>

Tuples
Scala: Java:

val tuple: Tuple2[Int, String] = Pair<Integer, String> tuple = new
Pair<Integer, String>(1, “apple”)
(1, “apple”)

val quadruple =
... yeah right... ;-)
(2, “orange”, 0.5d, false)

Packages
Scala: Java:

package mypackage package mypackage;
... ...

Imports
Scala: Java:

import java.util.{List, ArrayList} import java.util.List
import java.util.ArrayList

import java.io._ import java.io.*

import java.sql.{Date => SDate} ???

Nice to know
Scala: Java:
Console.println(“Hello”) System.out.println(“Hello”);
println(“Hello”)

val line = Console.readLine() BufferedReader r = new BufferedReader(new
val line = readLine() InputStreamRead(System.in)
String line = r.readLine();

error(“Bad”) throw new RuntimeException(“Bad”)

1+1 new Integer(1).toInt() + new Integer(1).toInt();
1 .+(1)

1 == new Object new Integer(1).equals(new Object());
1 eq new Object new Integer(1) == new Object();

"""Asregex""".r java.util.regex.Pattern.compile(“Asregex”);

1.2 scala basics

More Related Content

What's hot (20)

Similar to 1.2 scala basics (20)

More from futurespective (11)

Recently uploaded (20)

1.2 scala basics