Java 8 Tuturial (ko)

INDEX

Default Methods for Interfaces

interface Formula {
 double calculate(int a);
 
 default double sqrt(int a) {
 return Math.sqrt(a);
 }
}
Formula formula = new Formula() {
 @Override
 public double calculate(int a) {
 return sqrt(a * 100);
 }
};
 
formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0

Lambda Expressions

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
 
Collections.sort(names, new Comparator<String>() {
 @Override
 public int compare(String a, String b) {
 return b.compareTo(a);
 }
});

Collections.sort(names, (String a, String b) -> {
 return b.compareTo(a);
});

Collections.sort(names, (String a, String b) -> b.compareTo(a));

Collections.sort(names, (a, b) -> b.compareTo(a));

Functional Interfaces

@FunctionalInterface
interface Converter<F, T> {
 T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123

Method and Constructor References

Converter<String, Integer> converter = (from) -> Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123

class Something {
 String startsWith(String s) {
 return String.valueOf(s.charAt(0));
 }
}
Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted); // "J"

class Person {
 String firstName;
 String lastName;
 
 Person() {}
 
 Person(String firstName, String lastName) {
 this.firstName = firstName;
 this.lastName = lastName;
 }
}
interface PersonFactory<P extends Person> {
 P create(String firstName, String lastName);
}
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

Lambda Scopes

Accessing local variables

int num = 1; //final int num = 1;
Converter<Integer, String> stringConverter =
 (from) -> String.valueOf(from + num); //implicitly final
 
stringConverter.convert(2); // 3
num = 3 //COMPILE ERROR!!

Accessing fields and static variables

class Lambda4 {
 static int outerStaticNum; //static variable
 int outerNum; //instance field
 
 void testScopes() {
 Converter<Integer, String> stringConverter1 = (from) -> {
 outerNum = 23;
 return String.valueOf(from);
 };
 
 Converter<Integer, String> stringConverter2 = (from) -> {
 outerStaticNum = 72;
 return String.valueOf(from);
 };
 }
}

Accessing Default Interface Methods

Formula formula = (a) -> sqrt( a * 100); //COMPILE ERROR!!

Built-in Functional Interfaces

Predicates (매개변수 O, 반환값 O, 논리값 반환)

Predicate<String> predicate = (s) -> s.length() > 0;
 
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
 
Predicate<Boolean> nonNull = Objects::nonNull;
nonNull.test(null); //false

Functions (매개변수 O, 반환값 O, 매개변수 반환)

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
 
backToString.apply("123"); // "123"

Suppliers (매개변수 X, 반환값 O)

Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person

Consumers (매개변수 O, 반환값 X)

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker")); //Hello, Luke 출력

Comparators

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
 
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
 
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0

Optionals

Optional<String> optional = Optional.of("bam"); //of():null이 아닌 명시된 값을 가지는 Optional 객체 반환
 
optional.isPresent(); // true //Optional 객체에 저장된 값이 null인지 확인
optional.get(); // "bam" //Optional 객체에 저장된 값 접근
optional.orElse("fallback"); // "bam" //저장된 값이 존재-> 값반환, 없으면-> 인수 값 반환
 
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"

Streams

Filter (필터)

stringCollection
 .stream()
 .filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
 
// "aaa2", "aaa1"

Sorted (정렬)

stringCollection
 .stream()
 .sorted()
 .filter((s) -> s.startsWith("a"))
 .forEach(System.out::println);
 
// "aaa1", "aaa2"

Map (변환?)

stringCollection
 .stream()
 .map(String::toUpperCase)
 .sorted((a, b) -> b.compareTo(a))
 .forEach(System.out::println);
 
// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"

_____Match (일치 여부 확인)

boolean allStartsWithA =
 stringCollection
 .stream()
 .allMatch((s) -> s.startsWith("a"));
 
System.out.println(allStartsWithA); // false

Count (요소 개수 long형 반환)

long startsWithB =
 stringCollection
 .stream()
 .filter((s) -> s.startsWith("b"))
 .count();
 
System.out.println(startsWithB); // 3

Reduce (요소들을 줄이는 연산)

Optional<String> reduced =
 stringCollection
 .stream()
 .sorted()
 .reduce((s1, s2) -> s1 + "#" + s2);
 
reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"

Parallel Streams

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
 UUID uuid = UUID.randomUUID();
 values.add(uuid.toString());
}

long t0 = System.nanoTime();
 
long count = values.stream().sorted().count();
System.out.println(count);
 
long t1 = System.nanoTime();
 
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));
 
// sequential sort took: 899 ms

long t0 = System.nanoTime();
 
long count = values.parallelStream().sorted().count(); //stream을 parallelStream으로 바꿈
System.out.println(count);
 
long t1 = System.nanoTime();
 
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));
 
// parallel sort took: 472 ms

추가로 보기 좋은 글