In this Tutorial article, we will see how to work with Scala Programming language, which is similar to Java but has got lot more advancements, as it was designed to overcome the pitfalls\/shortcomings of Java programming language.<\/p>\n
According to Wikipedia<\/a>, the definition of Scala Programming language goes as follows.<\/p>\n Scala (SKAH-lah) is a general purpose programming language. Scala has full support for functional programming and a very strong static type system. Designed to be concise, many of Scala’s design decisions were inspired by criticism of the shortcomings of Java.<\/p>\n Scala source code is intended to be compiled to Java bytecode, so that the resulting executable code runs on a Java virtual machine. Java libraries may be used directly in Scala code and vice versa (language interoperability). Like Java, Scala is object-oriented, and uses a curly-brace syntax reminiscent of the C programming language. Unlike Java, Scala has many features of functional programming languages like Scheme, Standard ML and Haskell, including currying, type inference, immutability, lazy evaluation, and pattern matching.<\/p>\n<\/blockquote>\n Pre-requisite: <\/b>The readers are expected to know the basics of Java Programming.<\/p>\n The following table shows an overview of the entire article:\n<\/p>\n The examples in this article are executed in the Command Prompt \/ Shell<\/i> with the Scala Interpreter. But they are guaranteed to work with any of the IDEs (like Eclipse – Scala IDE, IntelliJ IDEA etc.,<\/i>) through the respective plugins. The examples are executed with the Scala Version: 2.11.7 in Windows 7<\/strong>.<\/p>\n Let us first download and install Scala in our desktop. To download the latest version of Scala for your Operating System, please refer this link<\/a>. It is a straight forward installation like any other executable. You may please follow the instructions if any for your Operating System. This will set the Let us write some Scala code to see the typical, popular Scala Interpreter is a REPL (Read-Evaluate-Print-Loop) Interpreter, in which you can execute the quick one liners and scripts without any underlying class structure as an accompanying barebone skeleton as in few of the programming languages like C, C++ and Java. This is an advantage for evaluating the programming language and its constructs thereby you can save time. You use this REPL interpterter for your instant results.<\/p>\n To be doubly sure, let us verify whether Scala installed in our machine correctly, by seeing the As you see, Scala has been installed in the For using this REPL interpreter, you need to open the After we executed the command Please remember that Scala code is executed on JVM (JRE) only. The actual code\/script in Scala, will finally be executed on top of JVM , like a Java program. Hence, we could typically use the Java libraries directly in our Scala code. This is called language interoperability<\/strong><\/p>\n<\/blockquote>\n Now, let us actually type the It was a very simple command we passed to the REPL Shell\/Interpreter. We tried in two ways. The first one was the literal string “Hello, World” passed as double quotes surrounded String. The second command invocation to print the same Hello, World but with the It was considered as an expression being evaluated. Hence the interpreter printed the result with an identifier along with a prefix The interesting part is the you can directly use the result names as a variable for the subsequent operations, as Scala Interpreter stores the result entries in the memory as long as the REPL Interpreter is running<\/i>. You can see this in action in the last 2 invocations where in Once we are done with our work, it is always good to exit the interpreter in a normal way. To do so, you may please enter As we saw earlier, the commands and expressions entered in the REPL interpreter were shortlived and once you exit from the Interpreter, you can’t get them back. If we need to work with our scripts\/code any number of times in future, it is better to get the Source code saved in a file much like a Java program.<\/p>\n Typical to how a Java program will be saved as We save the source file name as HelloWorld.scala<\/em><\/span><\/p>\n The structure is more like a Java program, where we define a A method in Scala is defined using the keyword The only executable statement in the main method was printing the literal String “Hello, World” to console by invoking the Please note that the semicolon is optional<\/u><\/i><\/strong> for each executable statement in Scala, unlike in a Java program.<\/p>\n<\/blockquote>\n Let us now compile and execute the above scala program. It is fairly straight forward as given below. The first command was to invoke Let us understand the very significant and important keywords in Scala. They are var<\/strong> indicates an mutable nature of the varaible’s value. That is a varaible’s value can be changed later after the inital declaration whereas val<\/strong> indicates an immutable nature of the variable’s value, which is like a var<\/strong> is like varying value for a variable, whereas val<\/strong> is like Let us see them in action in REPL interpreter<\/p>\n As you see, in the above executions, at first we declared a variable However, the 3rd, 4th and 5th invocations show us a different set of results. The 3rd statement attempts to declare a variable 5th expression was to indicate that it was not just a different\/new value but even the same value being assigned again will throw the same error of reassignment to a val. This was because of the fact that the variable of type Scala treats a String as an array of characters. It has got several methods on its own and it allows us to use the methods from the Java API classes like String, StringBuilder etc.,<\/p>\n Let us play around with the Scala REPL interpreter on Strings and its methods. The following expressions (or code snippets) are self explanatory.<\/p>\n As you see, we have got several method on String related classes like We could also use the String class methods from Java API – like The methods can be chained – meaning the methods can be invoked one after another in a way that result of executing one method will give the return value as an input to the next method – ie., the method on the right. The last two examples show the same. The drop method leaves the 2 characters from the left (0th index) and the remaining characters are passed on to the next method on the right capitalize which converts the first character (char at 0th index) to be in upper case, which in our case is “A” (“SC” dropped from the initial input string “scala”). The same way, the You can see the API methods in StringLike class methods<\/a> in Scala API. The Web page has a good set of options for filtering, searching a specific package, class, method etc.,<\/p>\n<\/blockquote>\n Let us see some String examples like String Concatenation, String Comparison, Null check etc.,<\/p>\n As you see, the first 2 expressions declare two different variables of type The An interesting thing to note that when you check for the String content equality with one of the Strings being null, Scala does NOT throw a NPE (NullPointerException) like Java. However it checks those constraints at the beginning as a safety measure and prints the result as false<\/i>. However, please be careful that whenever any other attempt is made on the String contents like Scala has the same set of numeric data types as that of Java. They are We have several methods available in the respective classes bearing the name as Data type listed above. The below code snippets \/ expressions are self explanatory.<\/p>\n As you see above, the respective data type classes had the methods minValue and maxValue for getting the lower and higher boundaries for each. The expressions in the scala REPL intepreter were evaluated and printed the results for our information.<\/p>\n Let us have some mathematical operations on numbers in the Scala REPL interpreter.<\/p>\n As you see above, the first expression was directly evaluated and the result was printed on the console. It was the sum of two numbers 1 and 1 equalling 2. However the 2nd invocation was different – where the numbers were given as String literals and hence the String Concatenation occurred producing a result of 11. If we need to parse and convert the numbers represented as a String, we can use the Let us see some negative scenarios where you may get an error while attempting to convert the String literal to a numeric form.<\/p>\n The first expression was attempting to convert the String Literal 129 to a Byte. However it failed because the Byte value range was only from -128 to 127. Hence you got an error with a meaningful description (see the very first line in the stack trace), which helps us to understand the mistake and take a corrective action. The second expression was obvious where a non-numeric value (actual String value) was attempted to be converted an Integer, which will definitely throw a You can see that the methods Let us see some arithmetic operations with REPL interpreter.<\/p>\n As you see, the first expression declared a variable of type Please note that the symbols Because there is no method named Let us see how easy to work with a range of numbers in Scala.<\/p>\n The first expression above used the construct The 2nd expression shows that we can create a range of numbers from 1 to 10 with an incremental value of 2. That is why the resultant Range has the numbers The 3rd expression uses a for loop with a range within the paranthesis indicating that 1 to 5 to be used, with a closure that prints each of the value in the range in a separate line.<\/p>\n The 4th expression uses a for loop but with the Like many other high level Programming languages, Scala offers If<\/strong> statement has an expression and if that expression evalutes to true, the statement will be executed.<\/p>\n\n
Table of Contents<\/h3>\n
\n
\n
\n
<\/a>1. Environment<\/h2>\n
%SCALA_HOME%\/bin<\/code> directory of Scala to the PATH<\/code> environment variable, for us to start working with the Scala programs.<\/p>\n<\/a>2. Hello World in Scala<\/h2>\n
Hello, World<\/code> in Scala. We have two ways to do that. First is the Scala Interpreter which is a REPL, and another is the usual way of saving the code in a file and compiling and executing it afterwards. We will see both of them here.<\/p>\n<\/a>2.1 Hello World in REPL Interpreter<\/h3>\n
%SCALA_HOME%<\/code> environment variable.<\/p>\nC:\\Users\\Raghs> echo %SCALA_HOME%\nC:\\Program Files (x86)\\scala\n<\/pre>\n
C:\\Program Files (x86)\\scala<\/code> directory successfully. This could vary in your machine depending on the type of Operating System you have.<\/p>\n<\/a>2.1.1 Starting the Interpreter<\/h4>\n
Command Prompt\/Terminal<\/code> and execute the command scala<\/code>. If your installation was successul and your PATH<\/code> environment variable has an entry to the %SCALA_HOME%\/bin<\/code> directory, the command prompt \/ terminal will now prepare the Scala Interpreter ready for you to listen to your commands as follows.<\/p>\nC:\\Users\\Raghs>scala\nWelcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_80).\nType in expressions to have them evaluated.\nType :help for more information.\n\n<\/pre>\n
scala<\/code>, the Scala interpreter was invoked and has printed a Welcome message by displaying the version of Java and the Virtual Machine details.<\/p>\n\n
<\/a>2.1.2 Working with the Interpreter<\/h4>\n
Hello, World<\/code> in the Scala Interpreter to see in action.<\/p>\nscala> \"Hello, World\"\nres0: String = Hello, World\n\nscala> println(\"Hello, World\")\nHello, World\n\nscala> \"Hello, World\"\nres1: String = Hello, World\n\nscala> \"Hello, World\".getClass().getName()\nres2: String = java.lang.String\n\nscala> res1\nres3: String = Hello, World\n\nscala> res2\nres4: String = java.lang.String\n<\/pre>\n
println()<\/code> method.<\/p>\nres0:<\/code> meaning result 0<\/code> \u2192 the 0th index of result entries. You can see the subsequent invocations (starting from 3rd and 4th commands) have the result printed with res1:<\/code> and res2:<\/code>. The 3rd command was the same command repeated but to show that the REPL Interpreter treats every command as a separate command and prints with the next result quotient – res1:<\/code>. The 4th command is to invoke some methods on the command line. The command printed the result with res2:<\/code>. Likewise any subsequent expressions will be printed with the results alongwith the incremented index of res<\/code>.<\/p>\nres1<\/code> and res2<\/code> were directly used like a variables and the interpreter printed the corresponding values then and there.<\/p>\n<\/a>2.1.3 Exiting from the Interpreter<\/h4>\n
:q<\/strong><\/code> to quit and exit from the Interpreter and come back to the normal Command Prompt \/ Terminal.<\/p>\nscala> :q\n\nC:\\Users\\Raghs\\\n\n<\/pre>\n
<\/a>2.2 Hello World in Scala file<\/h3>\n
<fileName>.java<\/code> and we use javac <fileName>.java<\/code> to compile the source code to get a class file named <fileName>.class<\/code> and we use the Java interpreter to execute the binary file as java <fileName><\/code>, we have the counter parts for Scala file as well.<\/p>\n<fileName>.scala<\/code> and use scalac <fileName>.scala<\/code> to compile the source code and scala <fileName><\/code> to execute the binary class file. We will see them in action for the same Hello World scala program below.<\/p>\nobject HelloWorld {\n def main(args: Array[String]):Unit = {\n println(\"Hello, World\");\n }\n}\n<\/pre>\nmain()<\/code> method that takes an array of String as an argument (which will be accepted from Command Line) and it is encapsulated inside the skeleton namedHelloWorld<\/code>. Please note that object<\/code> is a keyword in Scala that helps us to easily create a Singleton instance – meaning only one instance of a class inside a JVM.<\/p>\ndef<\/code> and the parameter is declared with its type with the colon after the parameter name accompanied with the Data type. Here you see, the parameter named args<\/code> is of type Array of Strings<\/code>. The return type is specified at the end of the method declaration, which is here Unit<\/code> – one of Scala’s data types. The method definition is separated here with a =<\/code> sign with a set of curly braces {<\/code> and }<\/code>.<\/p>\nprintln()<\/code> method.<\/p>\n\n
C:\\Users\\Raghs> scalac HelloWorld.scala\n\nC:\\Users\\Raghs> scala HelloWorld\nHello, World\n<\/pre>\n
scalac<\/code>, the Scala compiler to get our source code compiled into a .class<\/code> file. If the compilation was successful, it simply returns to the command prompt without any text being displayed on the console. The second command was to invoke scala<\/code>, the Scala Interpreter to execute the compiled class file. As per the program, it displayed Hello, World<\/code> on the console.<\/p>\n<\/a>3. val Vs var in Scala<\/h2>\n
val<\/code> and var<\/code>. As you might have guessed, they are the identifiers for denoting the ability to change the value of variables at a later point time in the source code\/ script.<\/p>\nfinal<\/code> keyword in Java.<\/p>\n\n
variable + final<\/code> to restrict the subsequent changes if any to a variable in the Program.<\/p>\n<\/blockquote>\nC:\\Users\\Raghs> scala\n\nscala> var s = \"Hello World\"\ns: String = Hello World\n\nscala> s = \"Hello Scala\"\ns: String = Hello Scala\n\nscala> val c = \"Hello, World\"\nc: String = Hello, World\n\nscala> c = \"Hello Scala\"\n:11: error: reassignment to val\n c = \"Hello Scala\"\n \n ^\n\nscala> c = \"Hello, World\"\n:11: error: reassignment to val\n c = \"Hello, World\"\n ^\n\n<\/pre>\n
s<\/code> of type var<\/code>. We initialized the variable s<\/code> with a String literal “Hello, World” and the REPL interpreter printed the result of the expression, which in this case is the same string literal. Later, at step 2, we reassigned the varaible s<\/code> with a different value “Hello Scala”<\/strong>, which was perfectly valid and legal because it was a var<\/strong>. Hence the second expression was allowed and printed the result, which was the latest value of s<\/code>.<\/p>\nc<\/code> of type val<\/code>, with an initial value “Hello, World”. The scala REPL interpreter printed the result of the expression, as like any other String literal in the console. However, at the 4th invocation, we attempt to reassign another value which is not allowed being the variable of type val. Hence, the REPL interpreter showed an error indicating that reassignment to val<\/code> is not permitted. It is also helpful by indicating which line and position the error had occurred with an upward arrow key in the next line indicating the position.<\/p>\nval<\/code> is not allowed to have an assignment further once it is assigned with a value during its declaration<\/u><\/i><\/strong>.<\/p>\n<\/a>4. Working with Strings<\/h2>\n
scala> \"Hello, World\".getClass.getName\nres0: String = java.lang.String\n\nscala> val s = \"Hello, World\"\ns: String = Hello, World\n\nscala> s.length\nres1: Int = 12\n\nscala> \"scala\".foreach(println)\ns\nc\na\nl\na\n\nscala> \"scala\".drop(2)\nres0: String = ala\n\nscala> \"scala\".take(2)\nres1: String = sc\n\nscala> \"scala\".drop(2).capitalize\nres2: String = Ala\n\nscala> \"scala\".take(2).toUpperCase\nres3: String = SC\n<\/pre>\n
StringLike<\/code>, StringOps<\/code> etc., in Scala Library like drop<\/code> and take<\/code>, which are useful to delete or get the characters upto the index passed. We also have methods named foreach<\/code> to ietrate each character at a time in a String, capitalize<\/code> which will make the first character of the String to be in upper case.<\/p>\nlength()<\/code> and toUpperCase<\/code>. Please note that the parantheses are optional in the REPL interpreter.<\/p>\ntoUpperCase<\/code> method was invoked on the result of invoking take(2)<\/code> on the initial input string “scala”.<\/p>\n\n
scala> val s1 = \"Hello\"\ns1: String = Hello\n\nscala> val s2 = \"Hello\"\ns2: String = Hello\n\nscala> val s3 = \"H\" + \"ello\"\ns3: String = Hello\n\nscala> s1 == s2\nres6: Boolean = true\n\nscala> s1 == s3\nres7: Boolean = true\n\nscala> val s4: String = null\ns4: String = null\n\nscala> s3 == s4\nres8: Boolean = false\n\nscala> s1 == s4\nres9: Boolean = false\n\nscala> s1.toUpperCase == s2.toUpperCase\nres13: Boolean = true\n\nscala> val s1: String = null\ns1: String = null\n\nscala> s1.toUpperCase == s2.toUpperCase\njava.lang.NullPointerException\n ... 33 elided\n<\/pre>\n
String<\/code> with an initial value “Hello”. The 3rd expression shows a declaration of a String variable with a String concatenation for its initial value “H” + “ello”. The 4th and 5th expressions show the String comparison where both of them are evaluated to true.<\/p>\n\n
==<\/code> operator in Scala checks for String content equality, like the equals()<\/code> method in Java, whereas Java uses ==<\/code> to check the object reference (address in memory).<\/p>\n<\/blockquote>\ntoUpperCase, length etc.,<\/code>, Scala obviously throws a NullPointerException<\/code>, which is what is shown in the last few code snippets above, where the toUpperCase method was invoked on a null reference S1.<\/p>\n<\/a>5. Working with Numbers<\/h2>\n
Char, Byte, Short, Int, Long, Float, Double, Boolean<\/code> with the same data range\/limit for each of the data types. In addition, it has got its own data types like AnyRef, AnyVal, Any etc.,<\/code>. You can see the list of data types available in Scala website<\/a>.<\/p>\nscala> Int.MinValue\nres4: Int = -2147483648\n\nscala> Int.MaxValue\nres5: Int = 2147483647\n\nscala> Byte.MinValue\nres6: Byte = -128\n\nscala> Short.MinValue\nres7: Short = -32768\n\nscala> Short.MaxValue\nres8: Short = 32767\n<\/pre>\n
scala> 1 + 1\nres13: Int = 2\n\nscala> \"1\" + \"1\"\nres14: String = 11\n\nscala> \"1\".toInt + \"2\".toInt\nres15: Int = 3\n\nscala> \"1\".toShort + \"1\".toShort\nres16: Int = 2\n\nscala> \"1\".toByte + \"1\".toByte\nres17: Int = 2\n\nscala> \"1\".toLong + \"1\".toLong\nres18: Long = 2\n<\/pre>\n
toInt<\/code> method for the same. We have similar methods to convert to the different other data types like toByte, toLong, toShort<\/code> etc., which you see in the last few expressions. These toInt() etc., methods convert the string literal into the corresponding numeric form and apply the mathematical operation to produce the result.<\/p>\nscala> \"129\".toByte\njava.lang.NumberFormatException: Value out of range. Value:\"129\" Radix:10\n at java.lang.Byte.parseByte(Byte.java:150)\n at java.lang.Byte.parseByte(Byte.java:174)\n at scala.collection.immutable.StringLike$class.toByte(StringLike.scala:264)\n at scala.collection.immutable.StringOps.toByte(StringOps.scala:30)\n ... 33 elided\n\nscala> \"foo\".toInt\njava.lang.NumberFormatException: For input string: \"foo\"\n at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)\n at java.lang.Integer.parseInt(Integer.java:492)\n at java.lang.Integer.parseInt(Integer.java:527)\n at scala.collection.immutable.StringLike$class.toInt(StringLike.scala:272)\n at scala.collection.immutable.StringOps.toInt(StringOps.scala:30)\n ... 33 elided\n\n<\/pre>\n
NumberFormatException<\/strong><\/code>.[ulp id=’r5HxHBP7fqxvOHkw’]<\/p>\ntoInt, toByte<\/code> are present in the StringOps<\/code> class which then further delegated to the toInt()<\/code> method of the class StringLike<\/code>. These calls are further stacked up with the Java API method parseInt(), parseByte()<\/code> of the respective Wrapper classes Integer, Byte<\/code>.<\/p>\nscala> var count = 1\ncount: Int = 1\n\nscala> count ++\n:12: error: value ++ is not a member of Int\n count ++\n ^\n\nscala> count += 1\n\nscala> count\nres27: Int = 2\n\nscala> count = count + 1\ncount: Int = 3\n<\/pre>\n
var<\/code> count with an initial value of 1. To increment the value with 1, we use the ++<\/code> in Java. However in Scala, it is slightly different as it uses +=<\/code> in place. The 2nd expression fails due to the usage of ++<\/code> whereas the 3rd expression gets it right. However the evaluation of expression did not yield any result in the console. The 4th expression printed the value of count<\/code> which is now 2 after the increment operation. The 5th expression shows the usual way to add 1 to the value of a variable. Here the value is explicitly assigned back to the variable, and hence the result (3) is printed on the console.<\/p>\n\n
+, -, *, \/<\/code> etc., are the methods<\/strong> in Scala and NOT<\/u><\/i> the operators like in Java.<\/p>\n<\/blockquote>\n+=<\/code> in Int class, we got an error on 2nd expression above.<\/p>\nscala> val r = 1 to 10\nr: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n\nscala> var r = 1 to 10 by 2\nr: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)\n\nscala> for(i <- 1 to 5) println(i)\n1\n2\n3\n4\n5\n\nscala> for(i for(i <- 1 until 5) println(i)\n1\n2\n3\n4\n<\/pre>\n
1 to 10<\/code> to have a range of numbers from 1 to 10. The result shows that the a Range<\/code> of type scala.collection.immutable.Range.Inclusive<\/code> was created and assigned to the variable r<\/code>.<\/p>\n1, 3, 5, 7 and 9.<\/code>.<\/p>\nuntil<\/strong><\/code> which is upto the max value, meaning one lesser than the max boundary. The result printed on the console ranges from 1 to 4 and NOT upto 5.<\/p>\n<\/a>6. Control Structures in Scala<\/h2>\n
if, if-else, switch, while, for<\/code> control structures as a control statements and looping statements. We will see the examples for few of them below.<\/p>\n