exploring-scala-1

Complex.scala

def + + [B>: A, That] (that: TraversableOnce [B]) (implicit bf: CanBuildFrom [List [A], B, That]): That

FiboFunctional.scala

object FiboFunctional {
  val fibs: Stream[BigInt] =
    0 #:: 1 #:: (fibs zip fibs.tail).map { case (a, b) => a + b }
  def main(args: Array[String]) = println(fibs(1000))
}

FiboJava.java

public class FiboJava {
	private static BigInteger fibo(int x) {
		BigInteger a = BigInteger.ZERO;
		BigInteger b = BigInteger.ONE;
		BigInteger c = BigInteger.ZERO;
		for (int i = 0; i < x; i++) {
			c = a.add(b);
			a = b;
			b = c;
		}
		return a;
	}

	public static void main(String args[]) {
		System.out.println(fibo(1000));
	}
}

FiboScala.scala

object FiboScala {
  def fibo(x: Int): BigInt = {
    var a: BigInt = 0
    var b: BigInt = 1
    var c: BigInt = 0
    for (_ <- 1 to x) {
      c = a + b
      a = b
      b = c
    }
    a
  }

  def main(args: Array[String]) = println(fibo(1000))
}

ListMACsJava.java

public class ListMACsJava {
  public static void main(String[] args) {
    try {
	  Enumeration<NetworkInterface> nics = 
			  NetworkInterface.getNetworkInterfaces();
	  while (nics.hasMoreElements()) {
            NetworkInterface nic = nics.nextElement();
	    byte[] mac = nic.getHardwareAddress();
	    String macStr = "";
	    if (mac != null)
	      for (int i = 0; i < mac.length; i++) {
	        macStr += String.format("%02x", mac[i]);
	 	if (i < mac.length - 1)
	 	  macStr += ":";
	        }
	    System.out.println(macStr);
	   }
	} catch (SocketException e) {
	  System.err.println("Ooops!");
	}
  }
}

ListMACsScala.scala

import collection.JavaConverters._
import java.net.NetworkInterface

object ListMACsScala extends App {
  val nicaddresses = for {
    nic <- NetworkInterface.getNetworkInterfaces.asScala
    addrbytes <- Option(nic.getHardwareAddress)
  } yield {
    addrbytes map {"%02x" format _} mkString ":"
  }
  nicaddresses foreach println
}

QueueWithTraitsDef.scala

//Type Definition
trait IntQueue {
  def get(): Int
  def put(x: Int)
  def size(): Int
}

//ArrayBuffer implementation
class IntQueueImpl extends IntQueue {
  private[this] val buf = new collection.mutable.ArrayBuffer[Int]
  def get = buf remove 0
  def put(x: Int) { buf += x }
  def size = buf.length
}

trait Doubling extends IntQueue {
  abstract override def put(x: Int) { super.put(2 * x) }
}

trait Incrementing extends IntQueue {
  abstract override def put(x: Int) { super.put(x + 1) }
}

trait Filtering extends IntQueue {
  abstract override def put(x: Int) { if (x > 0) super.put(x) }
}

QueueWithTraitsUse.scala

//Mixing traits in type definition
class DoublePlusOneQueue extends IntQueueImpl with Incrementing with Doubling

object FilaComTrait extends App {
  val queue1 = new DoublePlusOneQueue
  queue1.put(1)
  queue1.put(2)
  println(queue1.get())
  println(queue1.get())

  //Mixing traits in object instantiation
  val queue2 = new IntQueueImpl with Filtering
  queue2.put(-1)
  queue2.put(1)
  println(queue2.size())
}