Scala in a Java 8 World

All logos owned by respective companies.

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

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

PURE FUNCTIONS
def add1(x: Int) : Int = {
x + 1
}
val result = add1(1) + add1(2) // 5
val result = 2 + 3 // 5

FIRST CLASS FUNCTIONS
val hello = (name: String) => println(s"Hello $name”)
hello("Joe”)
Hello Joe

HIGH ORDER FUNCTIONS
def greetings(name: String, f: String => String) = {
println(f(name))
}
val hello = (name: String) => s"Hello $name”
val hola = (name: String) => s"Hola $name”
greetings("Joe", hello)
Hello Joe
greetings("Joe", hola)
Hola Joe

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

IMMUTABLE DATA STRUCTURES
Scala
List(1, 2)
Set(1, 2)
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

TRAITS
trait WheelBarrow {
val capacity: Int = 20
def lift() = println("I need to go to the gym")
def roll() = println("Are we there yet")
def dump() = println("Go back for more")
}
trait Bench {
val occupancy: Int = 3
val color: String = "Red”
def sit() = println("Time to rest")
}
class BenchBarrow extends WheelBarrow with Bench

NAMED PARAMETERS
public class Person {
private String lastName = "Unknown";
private String firstName = "Unknown";
private String middleName = "Unknown";
private String salutation = "Unknown";
private String suffix = "Unknown";
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;
}
}

NAMED PARAMETERS
public class Person {
private final String lastName;
private final String firstName;
private final String middleName;
private final String salutation;
private final String suffix;
private 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 static class PersonBuilder {
private String lastName = "Unknown";
private String firstName = "Unknown";
private String middleName = "Unknown";
private String salutation = "Unknown";
private String suffix = "Unknown";
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(lastName, firstName, middleName, salutation, suffix); }
}
}

NAMED 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, value: String)

PATTERN MATCHING
def parseArgument(arg: String, value: String) = (arg, value) match {
}

PATTERN MATCHING
case ("-h" | "--help", nil) => displayHelp()
}

PATTERN MATCHING
case ("-l" | "--log-level", level) => setLogLevel(level)
}

PATTERN MATCHING
case ("-l" | "--log-level", level) => setLogLevel(level)
case (bad, _) => badArgument(bad)
}

PATTERNS
// Constant patterns
case 0 => "zero”
case true => "true"
case "hello" => "you said hello”
// Data structure 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”
// Constructor patterns
case Person(_,_,_,"Smith",_) => "found a Smith”
case Person(_,first,middle,"Smith",_) => s"found $first $middle Smith”

GETTING STARTED
• Functional Programming Principles in Scala
– coursera.com
• Introduction to Scala
– bigdatauniversity.com
• Scala Cookbook by Alvin Alexander
• Programming Scala by Dean Wampler & Alex Payne

Scala in a Java 8 World

More Related Content

What's hot

Viewers also liked

Similar to Scala in a Java 8 World

Recently uploaded

Scala in a Java 8 World

Editor's Notes