SCALA Interview Questions for freshers experienced :-
1. What is Scala?
Scala is a Java-based Hybrid programming language which is the fusion of both Functional and Object-Oriented Programming Language features. It can integrate itself with Java Virtual Machine and compile the code written.
2. How Scala is both Functional and Object-oriented Programming Language?
Scala treats every single value as an Object which even includes Functions. Hence, Scala is the fusion of both Object-oriented and Functional programming features.
3.Write a few Frameworks of Scala
Some of the Frameworks supported by Scala are as follows:
- Akka Framework
- Spark Framework
- Play Framework
- Scalding Framework
- Neo4j Framework
- Lift Framework
- Bowler Framework
4. Explain the types of Variables in Scala? And What is the difference between them?
The Variables in Scala are mainly of two types:
Mutable Variables
- We Declare Mutable Variables by using the var keyword.
- The values in the Mutable Variables support Changes
Immutable Variables
- We declare Immutable Variables using the val keyword.
- The values in Immutable Variables do not support changes.
5. Explain Streams in Scala.
In simple words, we define Stream as a Lazy list which evaluates the elements only when it needs to. This sort of lazy computation enhances the Performance of the program.
6. Mention the Advantages of Scala
Some of the major Advantages of Scala are as follows:
- It is highly Scalable
- It is highly Testable
- It is highly Maintainable and Productive
- It facilitates Concurrent programming
- It is both Object-Oriented and Functional
- It has no Boilerplate code
- Singleton objects are a cleaner solution than Static
- Scala Arrays use regular Generics
- Scala has Native Tuples and Concise code
7. Explain the Operators in Scala
The following are the Operators in Scala:
- Arithmetic Operators
- Relational Operators
- Logical Operators
- Bitwise Operators
- Assignment Operators
8. What is Recursion tail in Scala?
‘Recursion’ is a function that calls itself. For example, a function ‘A’ calls function ‘B’, which calls the function ‘C’. It is a technique used frequently in Functional programming. In order for a Tail recursive, the call back to the function must be the last function to be performed.
9. Explain the use of Tuples in Scala?
Scala tuples combine a Finite number of items together so that the programmer can Pass a tuple around as a Whole. Unlike an Array or List, a tuple is Immutable and can hold objects with different Datatypes.
10. How is a Class different from an Object?
Class combines the data and its methods whereas an Object is one particular Instance in a class.
11. Why do we need App in Scala?
App is a helper class that holds the main method and its Members together. The App trait can be used to quickly turn Objects into Executable programs. We can have our classes extend App to render the executable code.
object Edureka extends App{
println(“Hello World”)
}
12. What are Higher-order functions?
A Higher-order function is a function that does at least one of the following: takes one or more Functions as Arguments, returns a Function as its result.
13. Explain the scope provided for variables in Scala.
There are three different scopes depending upon their use. Namely:
Fields:
Fields are variables declared inside an object and they can be accessed anywhere inside the program depending upon the access modifiers. Fields can be declared using var as well as val.
Method Parameters:
Method parameters are strictly Immutable. Method parameters are mainly used to Pass values to the methods. These are accessed inside a method, but it is possible to access them from outside the method provided by a Reference.
Local Variables:
Local variables are declared inside a method and they are accessible only inside the method. They can be accessed if you return them from the method.
14. What is a Closure?
Closure is considered as a Function whose return value is Dependent upon the value of one or more variables declared outside the closure function.
Course Curriculum
Apache Spark and Scala Certification Training
Instructor-led SessionsReal-life Case StudiesAssessmentsLifetime Access
Example:
val multiplier = (i:Int) => i * 10
Here the only variable used in the function body, i * 10 , is i, which is defined as a parameter to the function
15. Explain Traits in Scala.
A Trait can be defined as a unit which Encapsulates the method and its variables or fields. The following example will help us understand in a better way.
trait Printable{
def print()
}
class A4 extends Printable{
def print(){
println(“Hello”)
}
}
object MainObject{
def main(args:Array[String]){
var a = new A4()
a.print()
}
}
16. Mention how Scala is different from Java
A few scenarios where Scala differs from Java are as follows:
- All values are treated as Objects.
- Scala supports Closures
- Scala Supports Concurrency.
- It has Type-Inference.
- Scala can support Nested functions.
- It has DSL support [Domain Specific Language]
- Traits
17. Explain extend Keyword
You can extend a base Scala class and you can design an Inherited class in the same way you do it in Java by using extends keyword, but there are two restrictions: method Overriding requires the override keyword, and only the Primary constructor can pass parameters to the base Constructor. Let us understand by the following 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)
}
}
18. Explain implicit classes with syntax
Implicit classes allow Implicit conversations with the class’s Primary constructor when the class is in scope. Implicit class is a class marked with the “implicit” keyword. This feature was introduced in with Scala 2.10 version.
//Syntax:
object {
implicit class Data type) {
def Unit = xyz
}
}
19. Explain the access Modifiers available in Scala
There are mainly three access Modifiers available in Scala. Namely,
Private:
The Accessibility of a private member is restricted to the Class or the Object in which it declared.
The following program will explain this in detail.
class Outer {
class Inner {
private def f() { println(“f”) }
class InnerMost {
f() // OK
}
}
(new Inner).f() // Error: f is not accessible
}
Protected:
A protected member is only Accessible from Subclasses of the class in which the member is defined.
The following program will explain this in detail.
package p
class Super {
protected def f() { println(“f”) }
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Error: f is not accessible
}
}
Public:
Unlike Private and Protected members, it is not required to specify Public keyword for Public members. There is no explicit modifier for public members. Such members can be accessed from Anywhere.
Following is the example code snippet to explain Public member
class Outer {
class Inner {
def f() { println(“f”) }
class InnerMost {
f() // OK
}
}
(new Inner).f() // OK because now f() is public
}
20. What is a Monad in Scala?
A Monad is an object that wraps another object. You pass the Monad mini-programs, i.e functions, to perform the data manipulation of the underlying object, instead of manipulating the object directly. Monad chooses how to apply the program to the underlying object.
21. Explain the Scala Anonymous Function.
In the Source code, Anonymous functions are called ‘Function literals’ and at run time, function literals are instantiated into objects called Function values. Scala provides a relatively easy Syntax for defining Anonymous functions.
//Syntax
(z:Int, y:Int)=> z*y
Or
(_:Int)*(_Int)
22. How do I Append data in a list?
In Scala to Append into a List, We have the following methods:
use “:+” single value
var myList = List.empty[String]
myList :+= “a”
23. Why Scala prefers Immutability?
Scala prefers Immutability in design and in many cases uses it as default. Immutability can help when dealing with Equality issues or Concurrent programs.
24. Give some examples of Packages in Scala
The three important and default Packages in Scala are as follows:
- Java.lang._ : Java.lang._ package in Java. Provides classes that are fundamental to the design of the Java programming language.
- Java.io._ : Java.io._ Package used to import every class in Scala for input-output resources.
- PreDef: Predef provides type aliases for types which are commonly used, such as the immutable collection types Map, Set, and the List constructors
25. Why is an Option used in Scala?
Option in Scala is used to Wrap the Missing value.
26. Mention the Identifiers in Scala.
There are four types of Scala Identifiers:
- Alphanumeric identifiers
- Operator identifiers
- Mixed identifiers
- Literal identifiers
//Scala program to demonstrate Identifiers in Scala.
object Main
{
//Main method
def main(args: Array[String])
{
//Valid Identifiers
var ‘name = “Hari”‘
var age = 20;
var Branch = “Computer Science”
println()
println()
println()
}
}
27. How do you define a function in Scala?
def keyword is used to define the Function in Scala.
object add {
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
28. How is the Scala code compiled?
Code is written in Scala IDE or a Scala REPL, Later, the code is converted into a Byte code and transferred to the JVM or Java Virtual Machine for compilation.
Big Data Training
29. Explain the functionality of Yield.
Yield is used with a loop, Yield produces a value for each iteration. Another way to do is to use map/flatMap and filter with nomads.
for (i <- 1 to 5) yield i
30. Differentiate between Null, Nil, None and Nothing
They appear similar but different in their behaviour:
- Null Nil None Nothing
- Null represents the absence of a value. Nil denotes the end a List None is the value of an Option with no value. Nothing is lowest type in type System.
31. Explain If-Else-If terminology
If-Else-If statement executes one of the three statements.
Example:
object Demo {
def main(args: Array[String]) {
var x = 30;
if( x == 10 ){
println(“Value of X is 10”)
} else if( x == 20 ){
println(“Value of X is 20”);
} else if( x == 30 ){
println(“Value of X is 30”);
} else{
println(“This is else statement”);
}
}
}
32. Describe Loops in Scala.
There are mainly three types of loops in Scala.
- While Loop: Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.
- Do-While: Like a while statement, except that it tests the condition at the end of the loop body.
- For: Executes a sequence of statements multiple times and abbreviated the code that manages the loop variable.
- Break: Break is a loop control statement which Terminates the loop statement and transfers execution to the statement immediately following the loop.
33. Generate an Infinite loop
A loop becomes an Infinite loop if a condition never becomes false. If you are using Scala, the while loop is the best way to implement an infinite loop.
The following program implements an infinite loop.
object Demo {
def main(args: Array[String]) {
var a = 10;
//An infinite loop.
while( true ){
println( “Value of a: ” + a );
}
}
}
34. What is the Syntax for function declaration in Scala?
The Syntax for function declaration is as follows:
def functionName ([list of parameters]) : [return type] = {
function body
return [expression]
}
Here, the return type is any valid Scala data type and we separate the list of parameters by comma and list of parameters and return type are optional. Very similar to Java, we use a return statement along with an expression in case function returns a value.
35. How do I Concatenate two Strings?
There are three methods to perform string concatenation in Scala
string1.concat(string2);
“My name is “.concat(“Zara”);
“Hello,” + ” world” + “!”
36. Explain any five string methods.
Following are few String Methods in Scala.
String trim(): Returns a copy of the string, with leading and trailing whitespace omitted.
String toUpperCase: Converts all of the characters in this String to upper case using the rules of the given Locale.
Char[] to CharArray(): Converts this string to a new character array.
String[] split(String regex): Splits this string around matches of the given regular expression.
Int length(): returns the length of this string.
37. Explain how to create Arrays
We use the following methods to create arrays in Scala:
We use ofDim to declare multidimensional arrays.
var myMatrix = ofDim[Int](3,3)
We use Range() method to generate an array containing a sequence of increasing integers in a given range.
def range( start: Int, end: Int, step: Int ): Array[Int]
range (10, 20, 2)
38. What is Map in Scala?
Map is a collection of key/value pairs. Scala retrieves a Value based on its Key.
val colors = Map(“red” -> “#FF0000”, “azure” -> “#F0FFFF”)
39. Explain Exception Handling in Scala
Throw Exception: Throwing an exception looks the same as in Java. You create an exception object and then you throw it with the throw keyword as follows.
- Throw new IllegalArgumentException
- Catching an Exception:
- Scala allows you to try/catch any exception in a single block and then perform pattern matching against it using case blocks. Try the following example program to handle the exception.
Example:
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Demo {
def main(args: Array[String]) {
try {
val f = new FileReader(“input.txt”)
} catch {
case ex: FileNotFoundException ={
println(“Missing file exception”)
}
case ex: IOException = {
println(“IO Exception”)
}
}
}
}
So, with this, we finished some questions on the Intermediate Level.
Now, Let us move to the next level of interview questions which happen to be the Advanced Level Interview Questions.
40. Explain Pattern Matching in Scala through an example
A Pattern match includes a sequence of alternatives, each starting with the Keyword case. Each alternative includes a Pattern and one or more Expressions, Scala evaluates whenever a pattern matches. An arrow symbol => separates the pattern from the expressions.
Try the following example program, which shows how to match against an integer value.
object Demo {
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 = “one”
case 2 = “two”
case _ = “other”
}
}
41. Explain Extractors in Scala
- Course Curriculum
- Apache Spark and Scala Certification Training
- Weekday / Weekend Batches
- An Extractor in Scala is an object that has a method called unapply as one of its members. The purpose of that unapply method is to match the value and take it apart.
42. What is the result of x+y*z and why?
Similar to any other programming language, Scala also follows Presidency and Priority tables. According to the tables, Scala Performs the operations as follows.
Scala evaluates y*z first.
Then adds (y*z) with x
43. What is an Auxiliary constructor
We use Auxiliary constructor in Scala for Constructor Overloading. The Auxiliary Constructor must call either previously defined auxiliary constructors or primary constructor in the first line of its body.
44. Explain recursion through a program
def factorial_loop(i: BigInt): BigInt = {
var result = BigInt(1)
for (j- 2 to i.intValue)
result *= j
result
}
for (i – 1 to 10)
format(“%s: %sn”, i, factorial_loop(i))
45. Explain Que with example
Queue is a Data Structure similar to Stack except, it follows First In First Out procedure for data processing. In Scala, to work with Queues, you need to import a library called,
import scala.collection.mutable.Queue
val empty = new Queue[Int]