Converting Java to Scala

var i:Int=0;
while(i<len){
...
i=i+1;
}

for (i <- 0 until args.length)

var greeting = "" for (i <- 0 until args.length) { greeting += (args(i) + " ") }

for (String arg : args)
{ greeting += arg + " "; }

for (polynomialTerm sn:terms){ sn.multiplyBy(m); }

args.foreach { arg => greeting += (arg + " ") }

terms.foreach((sn:polynomialTerm) => {sn.multiplyBy(m)})

// type var_name = init_value;
int i = 0;

  

// var var_name: type = init_value;
var i : int = 0;

  

// final type var_name = init_value;
final int i = 0;

  

// val var_name: type = init_value;
val i : int = 0;

  

class Person {
  // members here
}

  

class Person {
  // members here
}

  

// RetType name(PType1 pName1, PType2 pName2...)

class Person {
  // members here
  public String getName() {
     // code here..
  }

  public void setAge(int age) {
     // code here..
  }
}

  

// def name(pName: PType1, pName2: PType2...) : RetType 

class Person {
  // members here
  def getName() : String = {
     // code here..
  }

  def setAge(age: int) : unit = {
     // code here..
  }
}

  

class Person {
    public Person(String name, int age) {
       // initialization here..
    }

    public Person(String name) {
       // call the other constructor
       this(name, 1);
    }
}

    

class Person(name: String, age: int) {
   // any method can access "name" or "age" parameter
}

    

class Person(name: String, age: int) {
   // any method can access "name" or "age" parameter
   def this(name: String) {
       // call the "primary" constructor
       this(name, 1);
   }
}

class Complex {
  def + (other: Complex) : Complex = {
     //....
  }
}

    

// call System.exit(int) using infix notation
System exit 0
// call Thread.sleep(int) using infix notation
Thread sleep 10

class Person {
  private static Person president = ....
  private static Person getPresident() {
     return president;
  }
}

  

No static members. Use singletons.

  

class President extends Person {
    // make the constructor private - so that
    // instance can not be created outside of this class
    private President() {}

    // create the singleton object here..
    private static President thePresident = new President();

    // provide accessor for singleton 
    // and add other methods here..
}

    

object President extends Person {
   // have methods of the singleton object
}

  

class Person {
}

class Graduate extends Person {
}

  

class Person {
}

class Graduate extends Person {
}

  

class Graduate extends Person {
    public Graduate(String name, int age, String degree) {
        super(name, age);
    }
}

  

class Graduate(name: String , age: int, degree: String) 
     extends Person(name, age) {
}

    

class Graduate extends Person {
  @Override public String getName() {
    // code here...
  } 
}

  

class Graduate extends Person {
  override def getName(): String = {
    // code here...
  }
}

  

abstract class Person {
  abstract public String getName();
}

  

abstract class Person {  
  def getName(): String;
}

  

• 44.+(4) is same as 44 + 4 where "+" is a method on scala.Int class.
• Also, single argument methods can be called using "infix" notation just like operator methods are. Example: System exit 4 is same as System.exit(4)

interface Runnable {
   void run();
}

  

trait Runnable {
  def run(): unit;
}

trait Runnable {  
   // parameter accepting run method
   def run(obj: AnyRef) : unit;

   // no params - assuming "null" instead
   def run() : unit = {
       System.out.println("assuming null...");
       run(null);
   }
}

// extend a single class, but can "extend"
// multiple traits with "with"

class MyClass extends AnyRef with Runnable {
   // just implement run with param. 
   // Other "run" is inherited from Runnable
   def run(obj: AnyRef) : unit = {
       System.out.println("got " + obj);
   }   
}

    

public class Book {
   private String name;
   // ...

   public Order newOrder() {
      ...
   }

   public class Order {
       private Date orderDate;
       private int quantity;
       // ...
   }   
}

  

class Book(name: String) {          

   class Order(orderDate: Date, 
               quantity : int) {
   }   

   def newOrder() : Order {
       return new Order(new Date(), 1);
   }
}

  

Unlike Java where such inner classes are members of the enclosing class, in Scala inner classes are bound to the outer object. With the above classes, in Java you can write

// Java
Book freakonomics = new Book("Freakonomics");
Book letUsKillGandhi = new Book("Let us kill Gandhi");
Book.Order o1 = freakonomics.newOrder();
Book.Order o2 = letUsKillGandhi.newOrder();

// You can assign any Book.Order 
// to any other Book.Order

o2 = o1;

// Not in Scala!
val freakonomics: Book = new Book("freakonomics");
val letUsKillGandhi : Book = new Book("Let us kill Gandhi");
var o1 = freakonomics.newOrder();
var o2 = letUsKillGandhi.newOrder();

// this line below will not compile!
// type of "o1" is "freakonomics.Order"
// and type of "o2" is "letUsKillGandhi.Order"

o2 = o1;

    

var o1 : Book#Order = freakonomics.newOrder();
var o2 : Book#Order = letUsKillGandhi.newOrder();
o1 = o2;

String.class
Object.class

  

classOf[String]
classOf[AnyRef]

  

x instanceof String
n instanceof Number

  

x.isInstanceOf[String]
n.isInstanceOf[Number]

  

String x = (String) obj;
Number n = (Number) obj;

  

x : String = obj.asInstanceOf[String];
n : Number = obj.asInstanceOf[Number];

  

// an interface with a type parameter
interface Stack<E> {
    void push(T t);
    T pop();
    boolean isEmpty();
}

// a class with two type parameters
class Pair<K, V> {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    // more code...
}

  

// a trait with a type parameter
trait Stack[E] {
    def push(o: E) : unit;
    def pop() : E;
    def isEmpty(): boolean;
}

// a class with two type parameters
class Pair[K, V](key: K, value: V) {
    // code here...
}

  

class Test {
  public <T> List<T> dup(T t, int n) {
    //....
  }
}

  

class Test {
  def dup[T](x: T, n: Int): List[T] = {
    if (n == 0) Nil
    else x :: dup(x, n - 1)
  }
}

  

// upper bound
class Foo<E extends SomeType> {
   // ... code here
}

// lower bound
class Foo<E super SomeType> {
  // ...
}

// type parameter in bound
class Stack<E extends Comparable<E>> {
  // ...
}

  

// upper bound
class Foo[E <: SomeType] {
  // ...
}

// lower bound
class Foo[F >: SomeType] {
  // ...
}

// type parameter in bound
class Stack[E extends Comparable[E]] {
  // ...
}

  

// upper bound
ArrayList<? extends Number> l = ...

// lower bound
ArrayList<? super Number> l = ...

// wildcard without bound
List<?> list = ...

  

// annotation +T declares type T to be used 
// only in covariant positions.
class Foo[+A] {
  // ...
}


// annotation -T declares type T to be used 
// only in contravariant positions.
class Foo[-A] {
}

    

Example: In Scala, Lists are immutable and List has covariant annotation. So, List[B] is subtype of List[A] whenever B is subtype of A.

String[] s = new String[10];

  

var s : Array[String] = new Array[String](10);

  

int[] a = new int[3];
a[0] = 3;
System.out.println(a[0]);

  

var a : Array[int] = new Array[int](3);
a(0) = 3;
System.out.println(a(0));

Array element access and update are actually method
calls on Array[T]. You may be wondering how method call
appears on the right side (for element update). No,
Scala does not have C++ style reference (&) types.
a(i) = 10 is translated as a.update(i, 10)
  

class Calc {
   public static int sum(int... values) {
       int res;
       for (int i in values) {
           res += i;
       }
       return res;
   } 
}

// with the above definition, caller can use
Calc.sum(3, 44)
Calc.sum(4, 4, 5,45, 45);

  

object Calc {
  def sum(values: int*): int = {
    var res: int = 0;
    for (val v <- values) {
       res = res + 1;
    }
    return res;
  }
}

// With the above definition, caller can use
Calc.sum(3, 44);
Calc.sum(4, 5, 6, 6);

  

• You can leave types for in var and val. Based on initial value type is inferred.
• You can leave return type for non-recursive methods as well. Based on return expression return type is inferred.

// int type for "i" inferred
val i = 10;

// String type for "s" inferred
var s = "hello"

// "int" return type inferred
def add(i: int, j:int) = i * j

// "unit" return type inferred
def sayHello = System.out.println("hello world")

// scala.List[java.lang.String] inferred
var v = List("hello", "world");

// with class Pair[K, V](k: K, v: V) {...}
// Pair[int, String] is inferred for the following.
var p = new Pair(2, "hello");

    

// function
def add(i: int, j: int) = i + j

// functions are first-class objects
// accepts a callback function as parameter
def oncePerSecond(callback: ()=>unit): unit = {
   while (true) { callback(); Thread.sleep(1000);
}

def printHello() = {
   System.out.println("hello world");
}

// pass printHello as parameter
oncePerSecond(printHello);

// define anonymous function and call it
((i:int, j:int) => i+j)(3, 4)

// anonymous function passed as parameter
oncePerSecond(()=>System.out.println("hello"));

// nested functions too
def outer() = {
  def inner() = {
     System.out.println("I am inner");
  }
  inner();
}

// inner functions can access outer's locals
// and arguments
def outer(s: String) = {
  def inner() = {
     System.out.println("outer's 's': " + s);
  }
  inner();
}

// Java closure proposals talk about converting
// closures to interfaces automatically. I think
// we can use views in Scala.

// define conversion from any parameterless function 
// to java.lang.Runnable
implicit 
def asRunnable(func : ()=>unit) : Runnable = {
   new Runnable() {
       def run() {
           func()
       }
   }
}

def main ( args : Array[String] ) = { 
    // create a new thread -
    // passing an anonymous function
    // for Runnable
    var t = new Thread(()=>Console.println("hello"));
    t.start();

    // you can now initialize Runnable
    // with any function
    var r : Runnable = ()=>Console.println("I am running!")
    r.run();
} 

    

// create a List with "List" function (which is actually
// an object with "apply")

var names : List[String] = List("Java", "JavaScript")

// :: is the cons operator
// creates a new list with first element as "Scala"
// and rest of the elements from "names" list
val l = "Scala" :: names

// :: becomes method call on List -- unlike 
// other operators :: takes right-side value 
// as list as target object to call method on!

  

// make a new list that contains only short names
// shortNames is of type List[String]
var shortNames = names.filter(n=>n.length() < 6)

// make a new list that has lengths of names
// "lengths" is of type List[int]
var lengths = names.map(n=>n.length())

val graduates:List[Graduate] =...
val persons:List[Person] = graduates;