자바 8 치트 시트

색인

Lambda Expression

Collections

Method Expressions

Streams

Optional

람다 표현식

(int a) -> a * 2; // Calculate the double of a
a -> a * 2; // or simply without type

(a, b) -> a + b; // Sum of 2 parameters

람다가 둘 이상의 표현식인 경우 { } 및 return를 사용할 수 있습니다.

(x, y) -> {
    int sum = x + y;
    int avg = sum / 2;
    return avg;
}

람다 식은 Java에서 단독으로 사용할 수 없으며 기능 인터페이스와 연결되어야 합니다.

interface MyMath {
    int getDoubleOf(int a);
}

MyMath d = a -> a * 2; // associated to the interface
d.getDoubleOf(4); // is 8

인터페이스 제한 사항에 대한 참고 사항

interface Pair<A, B> {
    A first();
    B second();
}

증기 유형Stream<Pair<String, Long>>:

stream.sorted(Comparator.comparing(Pair::first)) // ok

stream.sorted(Comparator.comparing(Pair::first).thenComparing(Pair::second)) // dont work

Java는 .comparing(Pair::first) 부분에 대한 유형을 유추할 수 없으며 Pair::first를 적용할 수 없는 Object로 대체합니다.

전체 표현식에 필요한 유형은 메소드 호출( .thenComparing )을 통해 전파될 수 없으며 첫 번째 부분의 유형을 유추하는 데 사용됩니다.

유형을 명시적으로 지정해야 합니다.

stream.sorted(
    Comparator.<Pair<String, Long>, String>comparing(Pair::first)
    .thenComparing(Pair::second)
) // ok

"list"가 있는 모든 예는 다음을 사용합니다.

List<String> list = [Bohr, Darwin, Galilei, Tesla, Einstein, Newton]

컬렉션

정렬sort(list, comparator)

list.sort((a, b) -> a.length() - b.length())
list.sort(Comparator.comparing(n -> n.length())); // same
list.sort(Comparator.comparing(String::length)); // same
//> [Bohr, Tesla, Darwin, Newton, Galilei, Einstein]

제거하다

list.removeIf(w -> w.length() < 6);
//> [Darwin, Galilei, Einstein, Newton]

병합merge(key, value, remappingFunction)

Map<String, String> names = new HashMap<>();
names.put("Albert", "Ein?");
names.put("Marie", "Curie");
names.put("Max", "Plank");

// Value "Albert" exists
// {Marie=Curie, Max=Plank, Albert=Einstein}
names.merge("Albert", "stein", (old, val) -> old.substring(0, 3) + val);

// Value "Newname" don't exists
// {Marie=Curie, Newname=stein, Max=Plank, Albert=Einstein}
names.merge("Newname", "stein", (old, val) -> old.substring(0, 3) + val);

메소드 표현식

메서드(및 생성자)를 실행하지 않고 참조할 수 있습니다.

// Lambda Form:
getPrimes(numbers, a -> StaticMethod.isPrime(a));

// Method Reference:
getPrimes(numbers, StaticMethod::isPrime);

방법 참조
람다 양식

StaticMethod::isPrimen -> StaticMethod.isPrime(n)String::toUpperCase(String w) -> w.toUpperCase()String::compareTo(String s, String t) -> s.compareTo(t)System.out::printlnx -> System.out.println(x)Double::newn -> new Double(n)String[]::new(int n) -> new String[n]

스트림

컬렉션과 비슷하지만

그들은 자신의 데이터를 저장하지 않습니다

데이터가 다른 곳에서 옵니다(컬렉션, 파일, db, 웹, ...).

불변(새 스트림 생성)

게으른 (필요한 것만 계산합니다!)

// Will compute just 3 "filter"
Stream<String> longNames = list
   .filter(n -> n.length() > 8)
   .limit(3);

새 스트림 만들기

Stream<Integer> stream = Stream.of(1, 2, 3, 5, 7, 11);
Stream<String> stream = Stream.of("Jazz", "Blues", "Rock");
Stream<String> stream = Stream.of(myArray); // or from an array
list.stream(); // or from a list

// Infinit stream [0; inf[
Stream<Integer> integers = Stream.iterate(0, n -> n + 1);

결과 수집

// Collect into an array (::new is the constructor reference)
String[] myArray = stream.toArray(String[]::new);

// Collect into a List or Set
List<String> myList = stream.collect(Collectors.toList());
Set<String> mySet = stream.collect(Collectors.toSet());

// Collect into a String
String str = list.collect(Collectors.joining(", "));

지도map(mapper)각 요소에 기능 적용

// Apply "toLowerCase" for each element
res = stream.map(w -> w.toLowerCase());
res = stream.map(String::toLowerCase);
//> bohr darwin galilei tesla einstein newton

res = Stream.of(1,2,3,4,5).map(x -> x + 1);
//> 2 3 4 5 6

필터filter(predicate)술어와 일치하는 요소를 유지합니다.

// Filter elements that begin with "E"
res = stream.filter(n -> n.substring(0, 1).equals("E"));
//> Einstein

res = Stream.of(1,2,3,4,5).filter(x -> x < 3);
//> 1 2

줄이다
요소를 단일 값으로 축소

String reduced = stream
    .reduce("", (acc, el) -> acc + "|" + el);
//> |Bohr|Darwin|Galilei|Tesla|Einstein|Newton

한계limit(maxSize)n개의 첫 번째 요소

res = stream.limit(3);
//> Bohr Darwin Galilei

건너 뛰기
처음 n개 요소 버리기

res = strem.skip(2); // skip Bohr and Darwin
//> Galilei Tesla Einstein Newton

별개의
중복 요소 제거

res = Stream.of(1,0,0,1,0,1).distinct();
//> 1 0

정렬
요소 정렬(비교 가능해야 함)

res = stream.sorted();
//> Bohr Darwin Einstein Galilei Newton Tesla 

모두 일치

// Check if there is a "e" in each elements
boolean res = words.allMatch(n -> n.contains("e"));

anyMatch: 요소에 "e"가 있는지 확인
noneMatch: 요소에 "e"가 없는지 확인

평행한
병렬인 동등한 스트림을 반환합니다.

찾기
병렬 스트림에서 findFirst보다 빠름

원시 유형 스트림

Stream과 같은 래퍼는 비효율적입니다. 각 요소에 대해 많은 unboxing과 boxing이 필요합니다. IntStream , DoubleStream 등을 사용하는 것이 좋습니다.

창조

IntStream stream = IntStream.of(1, 2, 3, 5, 7);
stream = IntStream.of(myArray); // from an array
stream = IntStream.range(5, 80); // range from 5 to 80

Random gen = new Random();
IntStream rand = gen(1, 9); // stream of randoms

함수가 Object, double 등의 값을 생성하는 경우 mapToX(mapToObj, mapToDouble 등)를 사용합니다.

결과 그룹화

Collectors.groupingBy

// Groupe by length
Map<Integer, List<String>> groups = stream
    .collect(Collectors.groupingBy(w -> w.length()));
//> 4=[Bohr], 5=[Tesla], 6=[Darwin, Newton], ...

Collectors.toSet

// Same as before but with Set
... Collectors.groupingBy(
    w -> w.substring(0, 1), Collectors.toSet()) ...

수집가.카운팅
그룹의 값 수 계산

수집가.summing__summingInt , summingLong , summingDouble 그룹 값 합계

수집가.평균__averagingInt , averagingLong , ...

// Average length of each element of a group
Collectors.averagingInt(String::length)

추신: 일부 Collection 메소드(예: Map<T, Optional<T>> )와 함께 선택적(예: Collectors.maxBy )을 잊지 마세요.

병렬 스트림

창조

Stream<String> parStream = list.parallelStream();
Stream<String> parStream = Stream.of(myArray).parallel();

순서 없는limit 또는 distinct 속도를 높일 수 있습니다.

stream.parallelStream().unordered().distinct();

추신: 스트림 라이브러리로 작업하십시오. 예. filter(x -> x.length() < 9) 대신 forEach를 if와 함께 사용하십시오.

선택 과목

Java에서는 결과가 없음을 나타내기 위해 null을 사용하는 것이 일반적입니다.
수표가 없을 때의 문제: NullPointerException .

// Optional<String> contains a string or nothing
Optional<String> res = stream
   .filter(w -> w.length() > 10)
   .findFirst();

// length of the value or "" if nothing
int length = res.orElse("").length();

// run the lambda if there is a value
res.ifPresent(v -> results.add(v));

선택 사항 반환

Optional<Double> squareRoot(double x) {
   if (x >= 0) { return Optional.of(Math.sqrt(x)); }
   else { return Optional.empty(); }
}

읽어 주셔서 감사합니다

읽으신 내용이 마음에 드시고 더 보고 싶으시다면 커피나 책으로 응원해주세요 ;)