Scala vs Java 8 in a Java 8 World

Takeaways
•  Why Scala?
•  Scala still relevant in Java 8 world?

What do we need in a
language?

Developers should start thinking
about tens, hundreds, and
thousands of cores now
“
”- Intel

Mutable State
public void setX(int x) {
this.x = x;
}
setX(0)
async { setX(getX()) + 1) }
async { setX(getX()) * 2) }

All logos owned by respective companies.

It’s all about
developer
productivity

class
Point
{

private
int
x;

private
int
y;

public
Point(int
x,
int
y)
{

setX(x);

setY(y);

}

public
int
getX()
{
return
x;
}

public
void
setX(int
x)
{
this.x
=
x;}

public
int
getY()
{
return
y;
}

public
void
setY(int
y)
{
this.y
=
y;}

public
boolean
equals(Object
other)
{

if
(other
instanceof
Point)
{

Point
otherPoint
=
(Point)
other;

return
otherPoint.getX()
==
getX()
&&
otherPoint.getY()
==
getY();

}
else
{

return
false;

}

}

public
int
hashCode()
{

return
(new
Integer[]
{getX(),
getY()}).hashCode();

}

}

case class Point(var x: Int, var y: Int)

Traits
abstract class Animal {
def speak
}
trait FourLeggedAnimal {
def walk
def run
}
trait WaggingTail {
val tailLength: Int
def startTail { println("tail started") }
def stopTail { println("tail stopped") }
}
class Dog extends Animal with WaggingTail with FourLeggedAnimal {
def speak { println("Dog says 'woof'") }
def walk { println("Dog is walking") }
def run { println("Dog is running") }
}

Immutable Classes
public final class Point {
private final int x;
private final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() { return x; }
public int getY() { return y; }
}
Java
Scala case class Point(x: Int, y: Int)

Immutable Data Structures
Scala
List(1, 2, 3)
Set(1, 2, 3)
Map(("foo", 1), ("bar", 2))

List<Integer> uList = Arrays.asList(1, 2, 3);
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
Set<Integer> uSet = Collections.unmodifiableSet(set);
Map<String, Integer> map = new HashMap<>();
map.put("foo", 1);
map.put("bar", 2);
Map<String, Integer> uMap = Collections.unmodifiableMap(map);
Java

Lambdas
Scala
peoples.filter(person => person.firstName == “Jon”)!
!
peoples.stream().filter( person -> !
person.firstName.equals(”Jon”)).collect(Collectors.toList())
Java
peoples.map(person => person.firstName)
List(1, 2, 3).reduce(_+_) // 6
List(1, 2, 3).foreach(println)

public class Person {
private String lastName;
private String firstName;
private String middleName;
private String salutation;
private String suffix;
public Person(String lastName, String firstName, String middleName,
String salutation, String suffix) {
this.lastName = lastName;
this.firstName = firstName;
this.middleName = middleName;
this.salutation = salutation;
this.suffix = suffix;
}
}

public class Person {
public static class PersonBuilder {
public PersonBuilder lastName(String newLastName) {
this.lastName = newLastName;
return this;
}
public PersonBuilder firstName(String newFirstName) {
this.firstName = newFirstName;
return this;
}
public PersonBuilder middleName(String newMiddleName) {
this.middleName = newMiddleName;
return this;
}
public PersonBuilder salutation(String newSalutation) {
this.salutation = newSalutation;
return this;
}
public PersonBuilder suffix(String newSuffix) {
this.suffix = newSuffix;
return this;
}
public Person build() { return new Person(this); }
}
}

Named and Default Parameters
case class Person(salutation: String = "Unknown", firstName: String = "Unknown”,
middleName: String = "Unknown", lastName: String = "Unknown",
suffix: String = "Unknown")
Person("Mr", "John", "M”, "Doe”, ”Sr")
Person(salutation = "Mr", firstName = "John", lastName = "Doe")
Person(firstName = "John", middleName = "M", lastName = "Doe")
Person(firstName = "John")
Person(lastName = "Doe")
Person(firstName = "John", lastName = "Doe")

Pattern Matching
def
parseArgument(arg
:
String)

Pattern Matching
def
parseArgument(arg
:
String)
=
arg
match
{

}

Pattern Matching
def
parseArgument(arg
:
String)
=
arg
match
{

case
("-‐h"
|
"-‐-‐help”)
=>
displayHelp()

}

Pattern Matching
def
parseArgument(arg
:
String)
=
arg
match
{

case
("-‐h"
|
"-‐-‐help”)
=>
displayHelp()

case
bad
=>
badArgument(bad)

}

Pattern Matching
def
parseArgument(arg
:
String,
value:
Any)

Pattern Matching
def
parseArgument(arg
:
String,
value:
Any)
=
(arg,
value)
match
{

}

Pattern Matching
def
parseArgument(arg
:
String,
value:
Any)
=
(arg,
value)
match
{

case
("-‐h"
|
"-‐-‐help",
null)
=>
displayHelp()

case
("-‐l",
lang)
=>
setLanguageTo(lang)

case
bad
=>
badArgument(bad)

}

Pattern Matching
def
parseArgument(arg
:
String,
value:
Any)
=
(arg,
value)
match
{

case
("-‐h"
|
"-‐-‐help",
null)
=>
displayHelp()

case
("-‐l",
lang)
=>
setLanguageTo(lang)

case
("-‐o"
|
"-‐-‐optim",
n
:
Int)
if
((0
<
n)
&&
(n
<=
5))
=>
setOptimizationLevelTo(n)

case
("-‐o"
|
"-‐-‐optim",
badLevel)
=>
badOptimizationLevel(badLevel)

case
bad
=>
badArgument(bad)

}

Patterns
// constant patterns
case 0 => "zero”
case true => "true”
case "hello" => "you said 'hello'”
case Nil => "an empty List"
// sequence patterns
case List(0, _, _) => "a three-element list with 0 as the first element”
case List(1, _*) => "a list beginning with 1, having any number of elements”
case Vector(1, _*) => "a vector starting with 1, having any number of elements”
// constructor patterns
case Person(first, "Alexander") => s"found an Alexander, first name = $first”
case Dog("Suka") => "found a dog named Suka”

I call it my billion-dollar mistake. It
was the invention of the null
reference in 1965.
“
”- Tony Hoare

Option
def toInt(in: String): Option[Int] = {
    try {
        Some(Integer.parseInt(in.trim))
    } catch {
        case ex: NumberFormatException => None
    }
}
toInt(someString) match {
    case Some(i) => println(i)
    case None => println("That didn't work.")
}

Collections with Option
val bag = List("1", "2", "foo", "3", "bar")
bag.map(toInt) // List[Option[Int]] = List(Some(1), Some(2), None, Some(3), None)
bag.flatMap(toInt) // List(1, 2, 3)

Summary
•  Parallel Processing made easier
•  Developer Productivity
•  Java interoperable
•  Still relevant in a Java 8 world

Scala vs Java 8 in a Java 8 World

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Scala vs Java 8 in a Java 8 World (20)

Recently uploaded (20)

Scala vs Java 8 in a Java 8 World