Concepts for Scala

Scala is a modern, multi-paradigm programming language designed to integrate features of both object-oriented and functional programming. Developed by Martin Odersky in 2003, Scala runs on the Java Virtual Machine (JVM) and interoperates seamlessly with Java code. It features a concise syntax, type inference, and support for higher-order functions, making it expressive and productive. Scala also offers powerful abstractions such as case classes, pattern matching, and traits, facilitating code reuse and extensibility. Its strong type system ensures type safety and prevents common errors at compile time. Scala's versatility makes it suitable for a wide range of applications, from web development to big data processing, where scalability, concurrency, and maintainability are key considerations.

• Print Text

  object HelloWorld {
    def main(args: Array[String]) {
      println("Hello World!");
    }
  }

• Comments

  // one line comment
  
  /*
  multi 
  line 
  comment
  */

• Variables

  var carCount = 2;
  val name: String = "Joe";
  val isPurple: Boolean = true; 

• Data Types

  var carCount: Int = 2
  var age: Byte = 15
  var seaLevel: Short = -10000
  var usBudget: Long = 11000000000L
  var lightSpeed: Long = 11799312874L
  var myGPA: Float = 3.45f
  var piValue: Double = 3.14159265
  var lastLetter: Char = 'Z'
  var isMale: Boolean = true
  var myName: String = "Joe"

• Math Op

  var carCount = 6;
  var truckCount = 3;
  
  var total = carCount + truckCount;
  println(total);
  
  var subtract = carCount - truckCount;
  println(subtract);
  
  var multiple = carCount * truckCount;
  println(multiple);
  
  var divisible = carCount / truckCount;
  println(divisible);
  
  // performs division and gets remainder which is 0
  var modulo = carCount % truckCount;
  println(modulo);

• Math Functions

  val power = pow(3, 6);
  println(power);
  
  val root = sqrt(16);
  println(root);
  
  val floorVal = floor(3.14);
  println(floorVal);
  
  val ceilVal = ceil(4.3);
  println(ceilVal);
  
  val roundVal = round(3.4);
  println(roundVal);
  
  // random number from 0 to 100
  val ranNum = Random.between(0, 101)
  println(ranNum);

• If/Else

  var carCount:Int = 6
  
  if (carCount > 3) {
    printf("More than three cars");
  } else if (carCount == 3) {
    printf("Equal to three cars");
  } else {
    printf("Less than three cars");
  }

• Ternary

  val carCount = 3;
  
  val result = if (carCount > 2) "Yes" else "No";
  println(result);

• Switch

  val carCount: Int = 3;
        
  carCount match {
    case 1 => println("One car");
    case 2 => println("Two cars");
    case 3 => println("Three cars");
    case _ => println("More than three");
  }
   

• Functions

  def handleCars(cars: Int, wheels: Int): Int = {
    val total: Int = cars * wheels
    return total
  }
  
  val result: Int = handleCars(3, 4)
  println(result)

• Interpolation

  val name = "Joe";
  val car = "Mazda";
  val result = s"$name drives a $car";
  println(result);

• Type Casting

  def squareA(length:Int):String = {
    var result:Double = pow(length, 2);
    return result.toString;
  }
  
  var squareL = "4";
  var convertedVal:Int = squareL.toInt;
  var area:String = squareA(convertedVal);
  println(area);

• Date and Time

  import java.util.Calendar
  import java.text.SimpleDateFormat
  import java.time.format.DateTimeFormatter
  import java.util.Date;
  
  // epoch time
  val milliseconds: Long =
    System.currentTimeMillis
  println(milliseconds);
  
  // current year
  val year =
    Calendar.getInstance.get(Calendar.YEAR)
  println(year);
  
  // current month
  val month =
    Calendar.getInstance.get(Calendar.MONTH) + 1
  println(month)
  
  
  // formatted date
  val pattern = "MM/dd/yyyy";
  val fullDate = 
    new SimpleDateFormat(pattern);
  
  val formattedDate = 
    fullDate.format(new Date());
    
  println(formattedDate);

• Classes

  import scala.collection.mutable.Queue
  
  // written in Scala 2
  class Cars{
    var carList = Queue[String]();
    
    def addCar(car:String) {
      carList.enqueue(car);
    }
    def removeFirst() {
      carList.dequeue();
    }
  }
  
  val newList = new Cars();
  newList.addCar("Honda");
  newList.addCar("Mazda");
  newList.addCar("Toyota");
  newList.removeFirst();
  
  val firstCar = newList.carList.front
  print(firstCar);

• Inheritance

  class User(
    Username: String,
    Password: String
  ) {};
  
  class Admin(
    Username: String, 
    Password: String,
    Id: String
  ) extends User(
    Username,
    Password
  ) {
    val username = Username;
    val password = Password;
    val id = Id;
  }
  
  val newAdmin = new Admin(
    "alpha0",
    "pw1",
    "1FE"
  );
  
  println(newAdmin.username);
  println(newAdmin.id);

• Method Overload

  class UserForm {
    val formA:String = "alpha";
    val formB:String = "beta";
    val formC:String = "gamma";
    val formD:String = "epsilon";
    var selectForm:String = "";
    
    def getForm(age:Int) {
      if (age > 65) {
        selectForm = formA;
      }
      selectForm = formB;
    }
    
    def getForm(id:String) {
      if (id == "1FE") {
          selectForm = formA;
      }
      selectForm = formC;
    }
    
    def getForm(
      isMilitary:Boolean,
      isNasa:Boolean
    ) {
      if (isMilitary || isNasa) {
        selectForm = formD;
      }
      selectForm = formA;
    }
  }
  
  val form = new UserForm();
  val myAge = 67;
  val myId = "1FE";
  val veteran = false;
  val nasa = true;
  
  form.getForm(myAge);
  val form1 = form.selectForm;
  
  form.getForm(myId);
  val form2 = form.selectForm;
  
  form.getForm(veteran, nasa);
  val form3 = form.selectForm;
  
  println(form1);
  println(form2);
  println(form3);

• Abstract Class

  abstract class Animation {
    def walk(): Unit
    def run(): Unit
    def idle(): Unit
  }
  
  class Human() extends Animation() {
    override def walk() {
      println("Human walks" );
    }
    override def run() {
      println("Human runs" );
    }
    override def idle() {
      println("Human idles" );
    }
  }
  
  class Zombie() extends Animation() {
    override def walk() {
      println("Zombie walks" );
    }
    override def run() {
      println("Zombie runs" );
    }
    override def idle() {
      println("Zombie idles" );
    }
  }
  
  val player = new Human();
  player.walk();
  
  val boss1 = new Zombie();
  boss1.run();

• Static Class

  // No Native Support or Implementation
  

• Arrays/Lists

  var names = Array("Joe", "Sam", "David");
  names(1) = "Tom";
  var name = names(1);
  var numItems = names.length;
  
  println(name);
  println(numItems);

• Array Methods

  // lists in Scala are not mutable 
  val cars = List("Honda", "Mazda", "Toyota");
  
  // number of element in array
  println(cars.length);
  
  // drops first 2 elements
  val array1 = cars.drop(2);
  println(array1);
  
  // checks array to see that Mazda exists
  println(cars.contains("Mazda"));
  
  // checks to see that list is not empty
  println(cars.isEmpty);

• Concatenation

  var carsListKr = Array("Kia", "Hyundai", "Daewoo");
  var carsListJp = Array("Honda", "Mazda", "Toyota");
  val combined = Array.concat(carsListKr, carsListJp);
  
  println(combined(1));
  println(combined(4));

• Sort Method

  var ages = Array(5, 3, 1, 6, 7, 4, 19);
  ages.sorted;
  
  for (age <- ages) {
    println(age);
  }

• Objects

  class User(
    var first: String,
    var last: String,
    var age: Int,
    var retired: Boolean,
    var carBrands: Array[String]
  ) {
    var fullName =  s"$first $last";
  }
  
  val brands = Array("Mazda", "Toyota");
  val user = new User(
    "Joe",
    "Doe",
    23,
    false,
    brands
  );
  
  print(user.first);
  print(user.carBrands(1));
  print(user.fullName);

• Maps (Key/Value)

  import scala.collection.mutable.Map;
  
  var carMap:Map[String, String] = Map();
   
  carMap += ("Joe" -> "Toyota");
  carMap += ("Bob" -> "Mazda");
  carMap += ("Tom" -> "Ford");
  
  println(carMap("Tom"))
  
  carMap -= ("Tom");
  println(carMap.contains("Tom"));

• Sets

  var cars:Set[String] = Set();
  
  cars += "Mazda";
  cars += "Toyota";
  cars += "Honda";
  
  println(cars.contains("Honda")); 
  
  cars -= "Honda";
  println(cars.contains("Honda"));

• Stack

  import scala.collection.mutable.Stack;
  
  var cars = Stack[String]();
  
  cars.push("Mazda");
  cars.push("Toyota");
  cars.push("Honda");
  
  println(cars.top);
  
  cars.pop;
  println(cars.top);

• Queues

  import scala.collection.mutable.Queue;
  
  var cars = Queue[String]();
  
  cars.enqueue("Mazda");
  cars.enqueue("Toyota");
  cars.enqueue("Honda");
  
  println(cars.front);
  
  cars.dequeue();
  println(cars.front);

• Linked List

  class Node(Value:String, Next:Node = null) {
    var value = Value;
    var next = Next;
  };
  
  class LinkedList {
    var head:Node = _
    
    def add(value:String) {
      var newNode = new Node(value);
      
      if (head == null) {
        head = newNode;
      } else {
        var current = head;
        
        while(current.next != null) {
          current = current.next;
        }
        current.next = newNode;
      }
    }
    
    def traverse() {
      var current = head;
      while(current != null) {
        print(current.value + "\n");
        current = current.next;
      }
    }
  }
  
  var carList = new LinkedList();
  carList.add("Mazda");
  carList.add("Toyota");
  carList.add("Honda");
  
  print(carList.head.value + "\n");
  carList.traverse();

• Graphs

  import scala.collection.mutable.Map
  import scala.collection.mutable.ArrayBuffer
  import scala.collection.mutable.Stack
  import scala.collection.mutable.Queue
  
  class Graph {
    var graphMap:Map[String, ArrayBuffer[String]] = Map()
    
    def addNode(value:String) {
      graphMap += (value -> ArrayBuffer[String]());
    }
    
    def addVertices(node1:String, node2:String) {
      if(graphMap.contains(node1) == false) {
        graphMap += (node1 -> ArrayBuffer());
      }
      
      if(graphMap.contains(node2) == false) {
        graphMap += (node2 -> ArrayBuffer());
      }
      
      graphMap(node1).append(node2);
      graphMap(node2).append(node1);
    }
    
    def breadthTraverse(start:String) {
      var queue = Queue(start);
      var visited:Map[String, Boolean] = Map();
      visited += (start -> true);
       
      while(queue.size > 0) {
        var currentVal = queue.front;
        print(currentVal + "\n");
        queue.dequeue;
        
        var tempArr = graphMap(currentVal)
        
        for (tempVal <- tempArr) {
          if(visited.contains(tempVal) == false) {
            queue.enqueue(tempVal);
            visited += (tempVal -> true);
          }
        }
      }
    }
    
    def depthTraverse(start:String) {
      var stack = Stack(start);
      var visited:Map[String, Boolean] = Map();
      visited += (start -> true);
       
      while(stack.size > 0) {
        var currentVal = stack.top;
        print(currentVal + "\n");
        stack.pop();
        
        var tempArr = graphMap(currentVal);
        
        for (tempVal <- tempArr) {
          if(visited.contains(tempVal) == false) {
            stack.push(tempVal);
            visited += (tempVal -> true);
          }
        }
      }
    }
  }
  
  val newGraph = new Graph;
  newGraph.addNode("a");
  newGraph.addVertices("a", "b");
  newGraph.addVertices("a", "c");
  newGraph.addVertices("b", "d");
  newGraph.addVertices("b", "e");
  newGraph.addVertices("d", "f");
  newGraph.addVertices("d", "g");
  newGraph.addVertices("d", "h");
  newGraph.addVertices("e", "i");
  newGraph.addVertices("e", "j");
  
  newGraph.breadthTraverse("a");
  newGraph.depthTraverse("a");

• For Loops

  var names = Array("Joe", "Alex", "Bob");
  
  for (name <- names) {
    println(name)
  }

• While Loops

  import scala.collection.mutable.Queue;
  
  var carList = Queue("Mazda", "Toyota", "Honda");
  
  while(carList.length > 0) {
    println(carList.front);
    carList.dequeue();
  }
  
  println(carList.length)

• Loop Breaks

  import scala.util.control._;
  
  var cars = Array("Toyota", "Honda", "Mazda");
  val loop = new Breaks;
  
  loop.breakable {
    for (i <- cars.indices) {
      if (cars(i) == "Honda") {
        println(s"Found at index $i");
        loop.break;
      }
      println(s"Visited index $i");
    }
  }

• Recursion

  import scala.collection.mutable.Queue;
  
  def getSum(arr: Queue[Int]): Int = {
    if (arr.length == 0) return 0;
    var curVal = arr.front;
    arr.dequeue();
    return curVal + getSum(arr);
  }
  
  var testArr = Queue(1, 2, 4, 5);
  var sum = getSum(testArr);
  println(sum);

• Regex Words

  import scala.util.matching.Regex;
  
  val phrase = "I am legend";
  val pattern: Regex = "\\w+".r;
  val result = pattern.findFirstMatchIn(phrase);
  
  print(result);

• Regex Numbers

  import scala.util.matching.Regex;
  
  val phrase = "I am 23";
  val pattern: Regex = "[0-9]+".r;
  val result = pattern.findFirstMatchIn(phrase);
  
  print(result);

• Regex Test

  import scala.util.matching.Regex;
  
  val phrase = "Bob Lee";
  val pattern: Regex = "Lee".r;
  val result =
    pattern.findAllIn(phrase).hasNext;
  
  print(result);

• Regex Characters

  import scala.util.matching.Regex
  
  val phrase = "##I am legend##";
  val pattern: Regex = "#+[a-zA-Z]+".r;
  val result = pattern.findFirstMatchIn(phrase);
  
  print(result);