scala Archives - CodeBind.com

Scala – Reduce, fold or scan (Left/Right)

August 16, 2018 admin 0

// Scala - Reduce, fold or scan (Left/Right)
//reduceLeft, reduceRight, foldLeft, foldRight, scanLeft, scanRight
object Demo {
  val lst = List(1, 2, 3, 5, 7, 10, 13);
  val lst2 = List("A", "B", "C");
	def main(args: Array[String]) {
	  println(lst.reduceLeft(_ + _));
	  println(lst2.reduceLeft(_ + _));
	  println(lst.reduceLeft((x,y) => {println(x + " , "+ y); x+y;}));
	  
	  println(lst.reduceLeft(_ - _));
	  println(lst.reduceRight(_ - _));
	  println(lst.reduceRight((x,y) => {println(x + " , "+ y); x-y;}));
	  
	  
	  println(lst.foldLeft(100)(_ + _));
	  println(lst2.foldLeft("z")(_ + _));
	  
	  
	  println(lst.scanLeft(100)(_ + _));
	  println(lst2.scanLeft("z")(_ + _));

	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

// Scala - Reduce, fold or scan (Left/Right)

//reduceLeft, reduceRight, foldLeft, foldRight, scanLeft, scanRight

object Demo {

val lst = List(1, 2, 3, 5, 7, 10, 13);

val lst2 = List("A", "B", "C");

def main(args: Array[String]) {

println(lst.reduceLeft(_ + _));

println(lst2.reduceLeft(_ + _));

println(lst.reduceLeft((x,y) => {println(x + " , "+ y); x+y;}));

println(lst.reduceLeft(_ - _));

println(lst.reduceRight(_ - _));

println(lst.reduceRight((x,y) => {println(x + " , "+ y); x-y;}));

println(lst.foldLeft(100)(_ + _));

println(lst2.foldLeft("z")(_ + _));

println(lst.scanLeft(100)(_ + _));

println(lst2.scanLeft("z")(_ + _));

}

How to Install Scala, SBT and Java on Ubuntu 18.04 LTS Linux

May 6, 2018 admin 2

In this Post we will see How to Install Scala, SBT and Java on Ubuntu 18.04 LTS (Linux) Install Java Step 1 […]

Scala Tutorial – map, flatMap, flatten and filter (Higher-order Methods)

April 7, 2018 admin 1

// Scala - map and filter
object Demo {
  val lst = List(1, 2, 3, 5, 7, 10, 13);
  val mymap = Map(1 -> "Tom", 2 -> "Max", 3 -> "John");
	def main(args: Array[String]) {
	  println(lst.map(x => x / 0.2));
	  println(lst.map(x => "hi" * x));
	  println(mymap.mapValues(x => "hi " + x));
	  println("hello".map(_.toUpper));
	  println(List(List(1,2,3), List(3,4,5)).flatten);
	  println(lst.flatMap(x => List(x, x+1)));
	  
	  println(lst.filter(x => x%2!=0))

	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

// Scala - map and filter

object Demo {

val lst = List(1, 2, 3, 5, 7, 10, 13);

val mymap = Map(1 -> "Tom", 2 -> "Max", 3 -> "John");

def main(args: Array[String]) {

println(lst.map(x => x / 0.2));

println(lst.map(x => "hi" * x));

println(mymap.mapValues(x => "hi " + x));

println("hello".map(_.toUpper));

println(List(List(1,2,3), List(3,4,5)).flatten);

println(lst.flatMap(x => List(x, x+1)));

println(lst.filter(x => x%2!=0))

}

Scala – Options (Some or None)

March 28, 2018 admin 0

// Scala - Options (Some or None)
object Demo {
  val lst = List(1, 2, 3);
  val map = Map(1 -> "Tom", 2 -> "Max", 3 -> "John");
  val opt : Option[Int] = Some(55);
	def main(args: Array[String]) {
	  println(lst.find(_ > 2).getOrElse(0));
	  println(map.get(5).getOrElse("No_name_found"));
	  
	  println(opt.isEmpty)
	  println(opt.get)

	}
}


/*
3
No_name_found
false
55

*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

// Scala - Options (Some or None)

object Demo {

val lst = List(1, 2, 3);

val map = Map(1 -> "Tom", 2 -> "Max", 3 -> "John");

val opt : Option[Int] = Some(55);

def main(args: Array[String]) {

println(lst.find(_ > 2).getOrElse(0));

println(map.get(5).getOrElse("No_name_found"));

println(opt.isEmpty)

println(opt.get)

}

/*

3

No_name_found

false

55

*/

Scala – Tuples

March 26, 2018 admin 1

// Scala - Tuples 
object Demo {
  val mytuple = (1, 2, "hello", true);
  val mytuple2 = new Tuple3(1, 2, "hello");
  val mytuple3 = new Tuple3(1, "hello",  (2,3));
	def main(args: Array[String]) {
		println(mytuple._1);
		println(mytuple._2);
		println(mytuple._3);
		println(mytuple._4);
		println(mytuple2._3);
		
		mytuple.productIterator.foreach{
		  i => println(i);
		}
		
		
		println(1 -> "Tom" -> true);
		println(mytuple3._3._2);
	}
}

/*
OUTPUT:
1
2
hello
true
hello
1
2
hello
true
((1,Tom),true)
3

*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

// Scala - Tuples

object Demo {

val mytuple = (1, 2, "hello", true);

val mytuple2 = new Tuple3(1, 2, "hello");

val mytuple3 = new Tuple3(1, "hello", (2,3));

def main(args: Array[String]) {

println(mytuple._1);

println(mytuple._2);

println(mytuple._3);

println(mytuple._4);

println(mytuple2._3);

mytuple.productIterator.foreach{

i => println(i);

}

println(1 -> "Tom" -> true);

println(mytuple3._3._2);

}

/*

OUTPUT:

1

2

hello

true

hello

1

2

hello

true

((1,Tom),true)

3

*/

Scala – Maps

March 14, 2018 admin 0

// Scala - Maps 
object Demo {
  val mymap : Map[Int, String] =
    Map(801 -> "max", 802 -> "Tom", 804 -> "July");
  val mymap2 : Map[Int, String] =
    Map(805 -> "lua");
	def main(args: Array[String]) {
		println(mymap);
		println(mymap(801));
		println(mymap.keys);
		println(mymap.values);
		println(mymap.isEmpty);
		
		mymap.keys.foreach { key =>
		  println("key " + key);
		  println("Value "+ mymap(key));
		  
		}
		
		println(mymap.contains(801000));
		println(mymap ++ mymap2);
		println(mymap.size);
	}
}

/*
output:
Map(801 -> max, 802 -> Tom, 804 -> July)
max
Set(801, 802, 804)
MapLike.DefaultValuesIterable(max, Tom, July)
false
key 801
Value max
key 802
Value Tom
key 804
Value July
false
Map(801 -> max, 802 -> Tom, 804 -> July, 805 -> lua)
3


*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

// Scala - Maps

object Demo {

val mymap : Map[Int, String] =

Map(801 -> "max", 802 -> "Tom", 804 -> "July");

val mymap2 : Map[Int, String] =

Map(805 -> "lua");

def main(args: Array[String]) {

println(mymap);

println(mymap(801));

println(mymap.keys);

println(mymap.values);

println(mymap.isEmpty);

mymap.keys.foreach { key =>

println("key " + key);

println("Value "+ mymap(key));

}

println(mymap.contains(801000));

println(mymap ++ mymap2);

println(mymap.size);

}

/*

output:

Map(801 -> max, 802 -> Tom, 804 -> July)

max

Set(801, 802, 804)

MapLike.DefaultValuesIterable(max, Tom, July)

false

key 801

Value max

key 802

Value Tom

key 804

Value July

false

Map(801 -> max, 802 -> Tom, 804 -> July, 805 -> lua)

3

*/

Scala – Sets

March 3, 2018 admin 0

// Scala - Sets 
object Demo {
  val myset: Set[Int] = Set(1,2,5,8,9,6,4);
  val myset2: Set[Int] = Set(4,2,9,18,19,16,14);
  val names: Set[String] = Set("Max", "Tom", "John");
	def main(args: Array[String]) {
		println(myset + 10);
		println(names("Maxxxx"));
		println(myset.head);
		println(myset.tail);
		println(myset.isEmpty);

		println(myset ++ myset2);
		println(myset.++(myset2))
		
		println(myset.&(myset2));
		println(myset.intersect(myset2));
    println(myset.max);
    
    println(myset.min);
    myset.foreach(println);
    
    for (name <- names) {
      println(name);
    }
	}
}

/*
OUTPUT:
Set(5, 10, 1, 6, 9, 2, 8, 4)
false
5
Set(1, 6, 9, 2, 8, 4)
false
Set(5, 14, 1, 6, 9, 2, 18, 16, 8, 19, 4)
Set(5, 14, 1, 6, 9, 2, 18, 16, 8, 19, 4)
Set(9, 2, 4)
Set(9, 2, 4)
9
1
5
1
6
9
2
8
4
Max
Tom
John


*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

// Scala - Sets

object Demo {

val myset: Set[Int] = Set(1,2,5,8,9,6,4);

val myset2: Set[Int] = Set(4,2,9,18,19,16,14);

val names: Set[String] = Set("Max", "Tom", "John");

def main(args: Array[String]) {

println(myset + 10);

println(names("Maxxxx"));

println(myset.head);

println(myset.tail);

println(myset.isEmpty);

println(myset ++ myset2);

println(myset.++(myset2))

println(myset.&(myset2));

println(myset.intersect(myset2));

println(myset.max);

println(myset.min);

myset.foreach(println);

for (name <- names) {

println(name);

}

/*

OUTPUT:

Set(5, 10, 1, 6, 9, 2, 8, 4)

false

5

Set(1, 6, 9, 2, 8, 4)

false

Set(5, 14, 1, 6, 9, 2, 18, 16, 8, 19, 4)

Set(9, 2, 4)

9

1

5

1

6

9

2

8

4

Max

Tom

John

*/

Scala – Lists

March 3, 2018 admin 0

// Scala - Lists 
object Demo {
  val mylist: List[Int] = List(1,2,5,8,9,6,4);
  val names: List[String] = List("Max", "Tom", "John");
	def main(args: Array[String]) {
		println(0 :: mylist);  
		println(mylist);  
		println(names);  
		println(1 :: 5:: 9 :: Nil); 
		println(mylist.head);  
		println(names.tail);   
		println(mylist.tail);   
		println(names.isEmpty);   
		println(mylist.reverse);  
		println(List.fill(5)(2)); 		
		println(mylist.max);  
		
		mylist.foreach( println )
		var sum : Int = 0;
		mylist.foreach(sum += _);
		println(sum);
		
		for (name <- names) {
		  println(name);
		}
		 
		println(names(0));
   
	}
}

/*
OUTPUT:
List(0, 1, 2, 5, 8, 9, 6, 4)
List(1, 2, 5, 8, 9, 6, 4)
List(Max, Tom, John)
List(1, 5, 9)
1
List(Tom, John)
List(2, 5, 8, 9, 6, 4)
false
List(4, 6, 9, 8, 5, 2, 1)
List(2, 2, 2, 2, 2)
9
1
2
5
8
9
6
4
35
Max
Tom
John
Max


*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

// Scala - Lists

object Demo {

val mylist: List[Int] = List(1,2,5,8,9,6,4);

val names: List[String] = List("Max", "Tom", "John");

def main(args: Array[String]) {

println(0 :: mylist);

println(mylist);

println(names);

println(1 :: 5:: 9 :: Nil);

println(mylist.head);

println(names.tail);

println(mylist.tail);

println(names.isEmpty);

println(mylist.reverse);

println(List.fill(5)(2));

println(mylist.max);

mylist.foreach( println )

var sum : Int = 0;

mylist.foreach(sum += _);

println(sum);

for (name <- names) {

println(name);

}

println(names(0));

}

/*

OUTPUT:

List(0, 1, 2, 5, 8, 9, 6, 4)

List(1, 2, 5, 8, 9, 6, 4)

List(Max, Tom, John)

List(1, 5, 9)

1

List(Tom, John)

List(2, 5, 8, 9, 6, 4)

false

List(4, 6, 9, 8, 5, 2, 1)

List(2, 2, 2, 2, 2)

9

1

2

5

8

9

6

4

35

Max

Tom

John

Max

*/

Scala – Arrays

February 19, 2018 admin 0

// Scala - Arrays 
import Array._

object Demo {
	val myarray: Array[Int] = new Array[Int](4);
val myarray2 = new Array[Boolean](5);
val myarray3 = Array(1,2,3,4,5,6,8);
def main(args: Array[String]) {
	myarray(0) = 20;
	myarray(1) = 50;
	myarray(2) = 10;
	myarray(3) = 30;
	println(myarray3.length);  
	val result = concat(myarray, myarray3);
	
	for (x <- result) {
		println(x);
	}

	for (i <- 0 to (myarray.length - 1)) {
		println(myarray(i));    
	}
}
}

/*
OUTPUT:
7
20
50
10
30
1
2
3
4
5
6
8
20
50
10
30


*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

// Scala - Arrays

import Array._

object Demo {

val myarray: Array[Int] = new Array[Int](4);

val myarray2 = new Array[Boolean](5);

val myarray3 = Array(1,2,3,4,5,6,8);

def main(args: Array[String]) {

myarray(0) = 20;

myarray(1) = 50;

myarray(2) = 10;

myarray(3) = 30;

println(myarray3.length);

val result = concat(myarray, myarray3);

for (x <- result) {

println(x);

}

for (i <- 0 to (myarray.length - 1)) {

println(myarray(i));

}

/*

OUTPUT:

7

20

50

10

30

1

2

3

4

5

6

8

20

50

10

30

*/

Scala String Example

February 8, 2018 admin 0

// Scala - String 
object Demo {
  val num1 = 75;
  val num2 = 100.25;
  val str1 : String = "Hello World";
  val str2 : String = " Max";
  def main(args: Array[String]) {
    println(str1.length());  
    println(str1.concat(str2));
    println(str1 + str2);
    
    val result = printf("(%d -- %f -- %s)", num1, num2, str1);
    println(result);
    println("(%d -- %f -- %s)".format(num1, num2, str1));
    printf("(%d -- %f -- %s)", num1, num2, str1);
  }
}

/*
OUTPUT:
11
Hello World Max
Hello World Max
(75 -- 100.250000 -- Hello World)()
(75 -- 100.250000 -- Hello World)
(75 -- 100.250000 -- Hello World)
*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

// Scala - String

object Demo {

val num1 = 75;

val num2 = 100.25;

val str1 : String = "Hello World";

val str2 : String = " Max";

def main(args: Array[String]) {

println(str1.length());

println(str1.concat(str2));

println(str1 + str2);

val result = printf("(%d -- %f -- %s)", num1, num2, str1);

println(result);

println("(%d -- %f -- %s)".format(num1, num2, str1));

printf("(%d -- %f -- %s)", num1, num2, str1);

}

/*

OUTPUT:

11

Hello World Max

(75 -- 100.250000 -- Hello World)()

(75 -- 100.250000 -- Hello World)

*/

Function Currying in Scala

January 6, 2018 admin 0

Currying is the technique of transforming a function that takes multiple arguments into a function that takes a single argument. […]

Scala – Closures

January 6, 2018 admin 0

A closure is a function which uses one or more variables declared outside this function.

// Scala - Closures
/* codebind.com */
import java.util.Date
object Demo {
  val number = 10;
  val add = (x : Int) =>  {
    x + number;
  }
  
  def main(args: Array[String]) {
    println(add(20));
    println(number)
  }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

// Scala - Closures

/* codebind.com */

import java.util.Date

object Demo {

val number = 10;

val add = (x : Int) => {

x + number;

}

def main(args: Array[String]) {

println(add(20));

println(number)

}

Scala – Functions

November 14, 2017 admin 0

// Functions in Scala
object Demo {

  object Math {
    def add(x: Int, y: Int): Int = {
      return x + y;
    }
    def square(x: Int) = x*x;
  }
  def add(x: Int, y: Int): Int = {
    return x + y;
  }
  def subtract(x: Int, y: Int): Int = {
    x - y;
  }
  def multiply(x: Int, y: Int): Int = x * y;

  def divide(x: Int, y: Int) = x / y;

  def main(args: Array[String]) {
    println(Math.add(45,15));
    println(Math square 3); 
    println(add(45, 15));
    println(subtract(45, 15));
    println(multiply(45, 15));
    println(divide(45, 15));
  }
}


/*
output:
60
9
60
30
675
3

*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

// Functions in Scala

object Demo {

object Math {

def add(x: Int, y: Int): Int = {

return x + y;

}

def square(x: Int) = x*x;

}

def add(x: Int, y: Int): Int = {

return x + y;

}

def subtract(x: Int, y: Int): Int = {

x - y;

}

def multiply(x: Int, y: Int): Int = x * y;

def divide(x: Int, y: Int) = x / y;

def main(args: Array[String]) {

println(Math.add(45,15));

println(Math square 3);

println(add(45, 15));

println(subtract(45, 15));

println(multiply(45, 15));

println(divide(45, 15));

}

/*

output:

60

9

60

30

675

3

*/

// Functions in Scala
object Demo {

  object Math {
    def +(x: Int, y: Int): Int = {
      return x + y;
    }
    def **(x: Int) = x*x;
  }
  
  def print(x: Int, y : Int): Unit = {
    println(x+y);
  }

  def main(args: Array[String]) {
    
    var add = (x : Int, y : Int) => x + y;
    println(add(300, 500));
    val sum = 10 * 20;
    print(100, 200);
    println(Math.+(60, 15));
    println(Math ** 3);
  }
}


/*
OUTPUT:
800
300
75
9

*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

// Functions in Scala

object Demo {

object Math {

def +(x: Int, y: Int): Int = {

return x + y;

}

def **(x: Int) = x*x;

}

def print(x: Int, y : Int): Unit = {

println(x+y);

}

def main(args: Array[String]) {

var add = (x : Int, y : Int) => x + y;

println(add(300, 500));

val sum = 10 * 20;

print(100, 200);

println(Math.+(60, 15));

println(Math ** 3);

}

/*

OUTPUT:

800

300

75

9

*/

// Scala - Higher-Order Functions
object Demo {

   def math(x: Double, y:Double, z:Double, f: (Double, Double)=>Double): Double = f(f(x, y), z);
  
  def main(args: Array[String]) {
    val result = math(50, 20, 10, _ max _);
    println(result);
  }
}

1

2

3

4

5

6

7

8

9

10

// Scala - Higher-Order Functions

object Demo {

def math(x: Double, y:Double, z:Double, f: (Double, Double)=>Double): Double = f(f(x, y), z);

def main(args: Array[String]) {

val result = math(50, 20, 10, _ max _);

println(result);

}

// Scala - Partially Applied Functions
import java.util.Date
object Demo {

  def log(date : Date, message: String) = {
    println(date + "   " + message);
  }
  
  def main(args: Array[String]) {
    val sum = (a: Int, b: Int, c: Int) => a + b + c    
    val f = sum(10, _: Int, _ : Int)    
    println(f(100, 200));
    
    val date = new Date;
    val newLog = log(date, _ :String);
    newLog("The message 1");
    newLog("The message 2");
    newLog("The message 3");
    newLog("The message 4");
    
    
  }
}


/*
OUTPUT:
310
Fri Dec 15 18:28:45 CET 2017   The message 1
Fri Dec 15 18:28:45 CET 2017   The message 2
Fri Dec 15 18:28:45 CET 2017   The message 3
Fri Dec 15 18:28:45 CET 2017   The message 4


*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

// Scala - Partially Applied Functions

import java.util.Date

object Demo {

def log(date : Date, message: String) = {

println(date + " " + message);

}

def main(args: Array[String]) {

val sum = (a: Int, b: Int, c: Int) => a + b + c

val f = sum(10, _: Int, _ : Int)

println(f(100, 200));

val date = new Date;

val newLog = log(date, _ :String);

newLog("The message 1");

newLog("The message 2");

newLog("The message 3");

newLog("The message 4");

}

/*

OUTPUT:

310

Fri Dec 15 18:28:45 CET 2017 The message 1

Fri Dec 15 18:28:45 CET 2017 The message 2

Fri Dec 15 18:28:45 CET 2017 The message 3

Fri Dec 15 18:28:45 CET 2017 The message 4

*/

Scala – Match expressions

November 12, 2017 admin 0

In Scala match expressions are used to select between a list of alternatives same as multiple if-statements or select statement, […]

How to install Scala on Mac OS X

November 6, 2017 admin 0

In this Post we will see How to Install Scala on Mac OS X. There are Two ways using which we […]