• High maintainability and productivity
• Less error-prone functional style
• High scalability
• Provides features of concurrent programming
• High testability

• In Scala, the arrays use regular generics, whereas arrays are bolted and have overlapping behaviors in other languages.
• Persistent immutable groups are the default and built into the traditional library.
• Scala lets ‘if blocks’, ‘for-yield loops’, and ‘code’ in braces to return a value.
• Singleton has singleton objects instead of classic static as in C++/Java/ C#. It is a cleaner solution
• Scala has no boilerplate code
• Scala has native tuples and a concise code
• Scala has immutable “val” as a first-class language feature.

Scala has two conditions that are values and variables. A value variable is regular and cannot be altered once assigned. A constant variable is immutable on the other hand, is mutable, and you can modify the value.

The types of variables are

var myVar : Int=0;

val myVal: Int=1;

• If the behavior is not reused, then create a concrete class.
• Use an abstract class to inherit it in Java code.
• If efficiency is a preference then lean towards using a class
• Create a trait if it will be reused in numerous and unrelated classes. In various parts of the class, hierarchy is the only trait that can be combined into various parts.
• Use abstract class if you want to split it in compiled form and expect outside combinations to write classes inheriting from it.

These are functions that carry different functions as parameters, or whose outcome is a function. For example: apply () function takes another function ‘f’ and a value ‘v’ and uses a function to v.

Example:
object Test {
def main(args: Array[String]) {
println( apply( layout, 10) )
}
def apply(f: Int => String, v: Int) = f(v)
def layout[A](x: A) = "[" + x.toString() + "]"
When the above code is compiled and performed, it produces the following result.
C:/>scalac Test.scala
C:/>scala Test
[10]
C:/>

In scala to append into a list, use “:+” single value
var myList = List.empty[String]
myList :+= "a"
myList :+= "b"
myList :+= "c"
use++ for appending a list
var myList = List.empty[String]
myList ++= List("a", "b", "c")

Use the .format () method to format a string in scala, you can use

Val formatted= “%s %i”.format (mystring.myInt)

• Alphanumeric identifiers
• Operator identifiers
• Mixed identifiers
• Literal identifiers

• Integer literals
• Floating-point literals
• Boolean literals
• Symbol literals
• Character literals
• String literals
• Multi-Line strings

• Akka Framework
• Bowler Framework
• Play Framework
• Spark Framework
• Neo4j Framework
• Lift Framework
• Scalding Framework

• Arithmetic Operators
• Bitwise Operators
• Relational Operators
• Assignment Operators
• Logical Operators

The app is a helper class that contains the primary method and its members concurrent. The App trait can be utilized to instantly turn objects into working programs. We can extend App classes to affect the executable code.

object Jobinterviewninjas extends App{ println(“Hello World”) }

• Null refers to the lack of data, and its type is Null with a capital N.
• Null is believed to be a list that includes zero items. Essentially, it means the end of the list.
• Nothing is also a trait without instances.
• None denotes a sensible return value.
• Unit is the return type for functions that return no value.

You can extend a base Scala class plan to an Inherited class in the similar way it is done in Java by using extends keyword, but there are two limitations: method Overriding needs the override keyword, and only the main constructor can allow parameters to the base Constructor. For example:

println("How to extend abstract class Parent and define a sub-class of Parent called Child")
  class Child=(name:String)extends Parent(name){
     override def printName:Unit= println(name)
  }
 object Child {
  def apply(name:String):Parent={
  new Child(name)
  }
}

Implicit classes permit implicit conversations with the class’s main constructor when the class is in scope. An implicit class is a class labeled with the “implicit” keyword. This characteristic was introduced in Scala 2.10 version.
//Syntax:
  object {
      implicit class Data type) {
          def Unit = xyz
       }
  }

• Java.lang._: This package provides classes that are introductory to the format of the Java programming language.
• Java.io._: This Package helps in importing every class in Scala for input-output resources.
• PreDef: It provides type aliases for types that are generally used, like the immutable group types Map, Set, and the List constructors

To define the Function in Scala use def keyword. for Example 
object add {
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
} 

Yield is used with a loop; it creates a value for each iteration. Another way to yield is to utilize map/ flatMap and filter with nomads.

for (i <- 1 to 5) yield i

• While Loop: It reiterates a statement or bunch of statements when a given condition is true. It tests the condition before performing the loop body.
• Do-While: It is the same as a while statement but it tests the condition at the end of the loop body.
• For: Runs a series of statements multiple times and shortens the code that controls the loop variable.
• Break: It is a loop control statement that ends the loop statement and moves execution to the statement instantly following the loop.

If a condition never returns false then a loop becomes an Infinite loop. If Scala the while loop is found the best to execute an infinite loop.

The following program executes an infinite loop.
object Demo {
   def main(args: Array[String]) {
      var a = 10;
       //An infinite loop.
      while( true ){
         println( "Value of a: " + a );
      }
   }
}

The Syntax for function declaration is as follows:
def functionName ([list of parameters]) : [return type] = {
   function body
   return [expression]
}

To perform string concatenation in Scala you can use any three methods:

string1.concat(string2);

“My name is “.concat(“Zara”);

“Hello,” + " world” + “!”

• String toUpperCase: Transforms all of the characters in this String to uppercase (capital case) utilizing the rules of the given Locale.
• String trim(): Returns a replica of the string, with leading and trailing whitespace omitted.
• Int length(): returns the length of this string.
• String[] split(String regex): Breaks this string near matches of the provided regular expression.
• Char[] to CharArray(): Transforms this string to a new character array.

• Scala evaluates y*z first.
• Then adds (y*z) with x

• Integer literals
• Floating-point literals
• Boolean literals
• Symbol literals
• Character literals
• String literals
• Multi-Line strings