Java 8의 람다식(Lambda Expression)의 사용 방법과 람다가 도입된 이유, 람다와 함께 추가된 API, 언어적인 변화를 간단히 정리

1. 자바 8 람다의 이해와 의미
Java 8 Lambda
자바 8의 핵심 개선 사항인 람
다의 정확한 성격을 고찰하고
람다가 자바 개발에 미칠 영향
을 얘기합니다.
박성철

2. 속성 주입식 람다 설명

3. 인터페이스
(Interface)

4. 함수형 인터페이스
(Functional Interface)

5. 함수형 인터페이스
(Functional Interface)
추상 메서드가 하나 뿐인 모든 인터페이스

6. package

7. java.lang;

8.
!
public

9.
interface

10. Runnable

11. {

16. public

17. abstract

18. void

19. run();

20.
}
인터페이스
메서드 하나
함수형 인터페이스 인정!
Runnable

21. public

22. class

23. AsyncHelloWorld

24. {

25.
!

29. public

30. static

31. class

32. HelloWorld

33. implements

34. Runnable

35. {

36.
!

44. @Override

53. public

54. void

55. run()

56. {

69. System.out.println(Hello

70. World!);

79. }

84. }

85.
!

89. public

90. static

91. void

92. main(String[]

93. args)

94. {

103. new

104. Thread(new

105. HelloWorld()).start();

110. }

111.
}
자바 ~7 쓰레드 생성
클래스 정의
객체 생성

112. public class AsyncHelloWorld {
public static void main(String[] args) {
new Thread(() - {
System.out.println(Hello World!);
}).start();
}
}
자바 8 쓰레드 생성
람다식

113. 자바 7 vs. 자바 8
public

114. class

115. AsyncHelloWorld

116. {

117.
!

121. public

122. static

123. class

124. HelloWorld

125. implements

126. Runnable

127. {

128.
!

136. @Override

145. public

146. void

147. run()

148. {

161. System.out.println(Hello

162. World!);

171. }

176. }

177.
!

181. public

182. static

183. void

184. main(String[]

185. args)

186. {

195. new

196. Thread(new

197. HelloWorld()).start();

202. }

203.
}
public

204. class

205. AsyncHelloWorld

206. {

211. public

212. static

213. void

214. main(String[]

215. args)

216. {

225. new

226. Thread(()

227. -

228. {

241. System.out.println(Hello

242. World!);

251. }).start();

256. }

257.
}

258. 람다식 문법
(인자 목록) - { 구문 }
람다식 = 익명 메서드
public

259. void

260. sayHello(PrintStream

261. out)

262. {

267. out.println(Hello

268. World!);

269.
}
(PrintStream

270. out)

271. -

272. {

273. out.println(Hello

274. World!);}

275. 대상 타입 추론
new

276. Thread(()

277. -

278. {

283. System.out.println(Hello

284. World!);

285.
}).start();
public

286. Thread(Runnable

287. target)
new

288. Thread(

289. new

290. Runnable()

291. {

296. public

297. void

298. run()

299. {

308. System.out.println(Hello

309. World!);

314. }

315.
}).start();
대상 타입(Target Type)
함수형 인터페이스
public

316. interface

317. Runnable

318. {

323. public

324. abstract

325. void

326. run();

327.
}
≃

328. 매개변수 타입 추론
b.addActionListener((ActionEvent e) - {!
counter.inc();!
text.setText(“버튼 클릭: + counter.count() + 회);!
});
public

329. void

330. addActionListener(ActionListener

331. l)
b.addActionListener((e) - {!
counter.inc();!
text.setText(“버튼 클릭: + counter.count() + 회);!
});
public

332. interface

333. ActionListener

334. {

339. void

340. actionPerformed(ActionEvent

341. e);

342.
}

344. (n,

345. str)

346. -

347. str

348. +

349. n
람다식 예
(int

350. n,

351. String

352. str)

353. -

354. str

355. +

356. n
str

357. -

358. str

359. +

360. 1
()

361. -

362. “Hello,

363. World!”
(int

364. n,

365. String

366. str)

367. -

368. {

369. return

370. str

371. +

372. n;}
()

373. -

374. {}

375. 요약
• 함수형 인터페이스
• 람다식 (인자 목록) - { 구문 블럭 } 또는 (인자 목록) - 식
• 람다식 = 익명 메서드
• 대상 타입
• 매개변수 타입 추론
• 다양한 축약형 람다식

376. 람다식은 뭐에 써 먹는 놈이냐?
https://www.flickr.com/photos/rofi/2097239111/

377. 제어 흐름 중복
assert numbers.length 0;!
!
int max = numbers[0];!
for(int i=1;!
i numbers.length;!
i++)!
if(Math.abs(max) !
Math.abs(numbers[i])!
max = numbers[i];!
return max;!
assert numbers.length 0;!
!
int max = numbers[0];!
for(int i=1; !
i numbers.length; !
i++)!
if(max numbers[i])!
max = numbers[i];!
return max;

378. 템플릿 메소드 패턴
AbstractMaxFinder
public findMax(list)
abstract boolean isLesser(a, b)
NaturalMaxFinder
boolean isLesser(a, b)
AbsNumberMaxFinder
boolean isLesser(a, b)
안 변하는 것
변하는 것

379. 전략 패턴
interface
Camparator
abstract boolean isLesser(a, b)
NaturalNumberComparator
boolean isLesser(a, b)
AbsNumberCamparator
boolean isLesser(a, b)
MaxFinder
public findMax(list)
안 변하는 것
변하는 것

380. • 제어 흐름 재사용
• 코드 중복 제거
• 유연성 향상
• 코드 변경 주기 기준 분리
제어 흐름 추상화
OOP의 제어 흐름 추상화 기법
• 상속을 통한 제어 흐름 추상화: 템플릿 메서드 패턴
• 위임을 통한 제어 흐름 추상화: 전략 패턴

381. https://www.flickr.com/photos/m2w2/191545978/

382. https://www.flickr.com/photos/chazferret/2842411103/

383. •메서드 호출시 값을 인자로 전달하듯 행위를 전달
•런타임에 행위를 전달받아서 미리 정해진 제어 흐름에 따라 수행
•객체가 아닌 메서드(또는 함수) 수준의 제어 흐름 추상화
•객체를 사용하는 방법보다 경량
•함수형의 고차함수(Higher Order Function)
행위 매개변수
(Paramterized Behaviors)
function

384. forEach(array,

385. func)

386. {

389. for

390. (var

391. i

392. =

393. 0;

394. i

396. array.length;

397. i++)

402. func(array[i]);

403.
}

404.
!
sum

405. =

406. 0

407.
forEach([1,

408. 2,

409. 3,

410. 4,

411. 5],,

412. function(number)

413. {

414. sum

415. +=

416. number

417. })
자바스크립트의 고차함수

418. 자바의 행위 매개변수
java.util.Collections

419.
!
public

420. static

421. T

422. T

423. max(Collection?

424. extends

425. T

426. coll,

427. Comparator?

428. super

429. T

430. comp)

431.
public

432. static

433. T

434. T

435. min(Collection?

436. extends

437. T

438. coll,

439. Comparator?

440. super

441. T

442. comp)

443.
public

444. static

445. T

446. void

447. sort(ListT

448. list,

449. Comparator?

450. super

451. T

452. c)
•모든 코드는 Class 안에 정의되어야 함(함수만 인자로 사용 불가).
•모든 자바 소스 파일에 공개 클래스(public class)나 인터페이스 하나 - 자바 코드 관례
•클래스 이름 작명 필요
•각종 상용구(boilerplate code)
•캡슐화, 간접 접근
자바 객체 사용 비용

453. 익명 클래스
ListUser

454. users

455. =

456. new

457. ArrayListUser();

458.
Collections.sort(users,

459. new

460. ComparatorUser()

461. {

466. @Override

471. public

472. int

473. compare(User

474. user1,

475. User

476. user2)

477. {

486. return

487. user1.getAge()

488. -

489. user2.getAge();

493. }

494.
});
익명 클래스를 사용한 행위 인자
• 가장 비용이 적게 드는 클래스
• 클래스 정의와 인스턴스 생성이 동시
• 클래스 이름 작명 불필요런
• 클래스 생성자 작성 불필요
• 1 회용 클래스: 클래스 하나에 인스턴스 하나

495. 변수 포획
(Captured Variable)
Button b = new Button(누르시오”);
final TextField text = new TextField(20);
final Counter counter = new Counter();
!
b.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
counter.inc();
text.setText(“버튼 클릭: + counter.count() + 회);
}
});
• 내부 객체는 외부객체의 멤버와 외곽 범주(scope)의 변수 값에 접근 가능
• 내부 객체가 접근할 변수는 final 수정 기호로 고정되어야 함
익명 클래스( + 변수 포획) = 자바식 클로저(Closure)

496. https://www.flickr.com/photos/chazferret/2842411103/
템플릿-콜백 패턴

497. 행위 매개변수의 보급
• 다양한 언어에서 고차함수 지원
• 함수형 프로그래밍 대중화
• 스프링 xxxTemplate
• C# 3.0 람다식 지원 .Net 프레임워크(LINQ) (2007)
• 자바의 수다스러운 구문에 대한 반발: Guava, LambdaJ, Op4j
ListActor

498. actors

499. =

500. this.jdbcTemplate.query(

509. select

510. first_name,

511. last_name

512. from

513. t_actor,

522. new

523. RowMapperActor()

524. {

537. public

538. Actor

539. mapRow(ResultSet

540. rs,

541. int

542. rowNum)

543. throws

544. SQLException

545. {

562. Actor

563. actor

564. =

565. new

566. Actor();

583. actor.setFirstName(rs.getString(first_name));

600. actor.setLastName(rs.getString(last_name));

617. return

618. actor;

631. }

640. });
스프링 프레임워크의 JdbcTemplate 사용 예
람다식
지원
필요
급증

641. 결국…
ListUser

642. users

643. =

644. …⋯

645.
Collections.sort(users,

646. new

647. ComparatorUser()

648. {

653. @Override

658. public

659. int

660. compare(User

661. u1,

662. User

663. u2)

664. {

673. return

674. u1.getAge()

675. -

676. u2.getAge();

680. }

681.
});
ListUser

682. users

683. =

684. …⋯

685.
Collections.sort(users,

686. (u1,

687. u2)

688. -

689. u1.getAge()

690. -

691. u2.getAge());

692. 요약
• 제어 흐름의 중복과 추상화
• OOP 방식: OOP is not a one-size-fits-all solution.
• 행위 매개변수를 사용한 제어 흐름 추상화
• 가장 비용이 적게 드는 익명 클래스
• 변수 포획
• 행위 매개변수의 대중화
• 자바, 람다식 지원

693. 스트림(Streams) API
https://www.flickr.com/photos/23209605@N00/2786126623/

694. 반복의 내재화
for(int

695. n:

696. numbers)

697. {

702. …⋯

703.
}
numbers.forEach(n

704. -

705. …⋯)
Collection Stream
외부 반복
External Iteration
내부 반복
Internal Iteration
• 명시적 외부 반복
• 제어 흐름 중복 발생
• 효율적이고 직접적인 요소 처리
• 지저분한 코드
• 유한 데이터 구조 API
• 반복 구조 캡슐화
• 제어 흐름 추상화
• 파이프-필터 기반 API
• 최적화와 알고리듬 분리
• 함축적인 표현
• 무한 연속 데이터 흐름 API
• 데이터 외 I/O, 값 생성 등 적용

706. 스트림 유형
DoubleStream
java.util.stream
IntStream
LongStream
StreamT 객체를

707. 요소로

708. 하는

709. 가장

710. 일반적인

711. 스트림
요소가

712. double인

713. 스트림
요소가

714. int인

715. 스트림
요소가

716. long인

717. 스트림
java.lang
OptionalT 값이

718. 있을

719. 수도

720. 없을

721. 수도

722. 있을

723. 때

724. 사용

725. 스트림 생성
stream(),

726. parallelStream()Collection
BufferedReader lines()
Random doubles(*),

727. ints(*),

728. longs(*)
BitSet IntStream()
Arrays stream(*)
of(*),

729. range(…⋯)Stream 유형
xxxStream.Builder build()

730. 스트림 중개 연산자
StreamR

731. map(Function?

732. super

733. T,?

734. extends

735. R

736. mapper)

737.
T 타입의 요소를 1:1로 R 타입의 요소로 변환 후 스트림 생성
StreamT

738. filter(Predicate?

739. super

740. T

741. predicate)

742.
T 타입의 요소를 확인해서 기준에 통과한 요소만으로 새 스트림 생성
StreamR

743. flatMap(FunctionT,Stream?

744. extends

745. R

746. mapper)

747.
T 타입의 요소를 1:n으로 R 타입의 요소로 변환 후 스트림 생성, Monad bind()
StreamT

748. skip(long

749. n) 처음 n개의 요소를 제외한 나머지 요소로 새 스트림 생성
StreamT

750. limit(long

751. n)

752. 처음 n개의 요소로 새 스트림 생성
IntStream.range(1,

753. 100).filter(n

754. -

755. n

756. %

757. 2

758. ==

759. 0).map(n

760. -

761. n*n).skip(10).limit(10)
무상태 연산

762. 중개 연산자 관련 함수형 인터페이스
java.util.function.*
!•!PredicateT T 타입의 인자를 검증해서 boolean 값 반환
boolean test(T t)
!•!ConsumerT T 타입의 인자를 처리
void accept(T t)
!•!FunctionT,R T 타입의 인자를 받아 R 타입의 값으로 변환
R apply(T t)
!•!SupplierT T 타입의 값을 생성해서 반환
T get()
!•!UnaryOperatorT T 타입의 값을 받아 T 타입의 값을 반환
T apply(T t)
!•!BinaryOperatorT T 타입의 두 값을 받아 T타입의 값을 반환
T apply(T t, T u)

763. 스트림 중개 연산자
StreamT

764. sorted() 정렬된 스트림 생성, T 타입은 Comparable을 구현한 타입
StreamT

765. sorted(Comparator?

766. super

767. T

768. comparator)

769. 정렬된 스트림 생성
StreamT

770. distinct()

771. 중복된 요소를 제거한 스트림 생성
내부 상태 유지 연산

772. 스트림 종단 연산자
void

773. forEach(Consumer?

774. super

775. T

776. consumer)

777.
T 타입의 요소를 하나씩 처리
R

778. collect(Collector?

779. super

780. T,R

781. collector)

782.
T 타입의 요소를 모두 모아 하나의 자료구조나 값으로 변환
OptionalT

783. reduce(BinaryOperatorT

784. reducer)*

785.
T 타입의 요소 둘 씩 reducer로 계산해 최종적으로 하나의 값을 계산
IteratorT

786. iterator() Iterator 객체 반환
IntStream.range(1,

787. 100).filter(n

788. -

789. n

790. %

791. 2

792. ==

793. 0).map(n

794. -

795. n*n)

804. .skip(10)

813. .limit(10)

822. .reduce(0,

823. Integer::sum)

824. 지연 연산과 병렬 처리
• 스트림을 반환하는 필터와 맵 연산은 기본적으로 지연(lazy) 연산
• 지연 연산을 통한 성능 최적화 (무상태 중개 연산)
• 종단 연산 시 모든 연산 수행 (반복 작업 최소화)
지연 연산
• 동일한 코드로 순차 연산과 병렬 연산 모두 지원, 선택 가능
• 순차 연산에서 parallel() 메서도로 병렬 연산으로 전환 가능
• Collection.parallelStream()으로 병렬 처리 스트림 생성 가능
• 경고: 스트림 처리 중에는 스트림 요소를 변경하지 마시오!
• 쓰레드 안전하지 않은 컬렉션에서도 병렬처리 수행
병렬 처리
Stream

825. usersStream

826. =

827. users.parallelStream();

828.
int

829. sum

830. =

831. usersStream.filter(u

832. -

833. u.getSex()

834. ==

835. MALE)

852. .mapToInt(u

853. -

854. u.getWeight())

871. .sum();

872. 요약
• 스트림: 컬랙션(Collection) 프레임워크보다 한 단계 더 높은 추상화 제공
• 내부 반복
• 중개 연산: 파이프와 필터, 맵(Map)
• 종단 연산: 결과 생산(Reduce)
• 지연 연산을 통한 최적화
• 병렬 처리 추상화
• 컬랙션 외 다양한 연속적 데이터에 적용

873. 함수의 재발견?
https://www.flickr.com/photos/vestman/4908148942/

874. 인터페이스 하위 호환성 문제
• 경직된 자바 인터페이스, 메서드 추가 후 하위 호환성 상실
• 인터페이스에 메서드 추가 후 모든 클래스를 다시 컴파일 해야 함
• 공개된 API는 불가능
• 다양한 우회 기법 활용
• 애플리케이션: 하위 호환성 포기(1)
• 자바 SDK: 무수정, 도움 객체 사용(Collections)
• Eclipse: 확장 인터페이스 추가(ISomeRole - ISomeRoleExtension)
• 중도: 기본 추상 클래스를 통한 확장(ISomeRole - AbstractSomeRole)
• 람다식과 함께 대규모로 자바 SDK를 수정하려고 하면서 문제 발생
(1)

875. http://blog.jooq.org/2013/02/01/defensive-api-evolution-with-java-interfaces/

876. 기본 메서드(Default Method)
• 인터페이스에 기본 구현 포함 가능, 추가된 인터페이스의 하위 호환성 보장
• default 키워드 사용
• 함수형 인터페이스 조건에서 제외
• 인터페이스 확장시 재구현 또는 추상(abstract)으로 재지정 가능
• 가상 확장 메서드(virtual extension methods) 또는 방어 메서드(defender
methods)라는 이름도 사용
public

877. interface

878. IteratorE

879. {

880.
!

884. …⋯…⋯

885.
!

889. default

890. void

891. remove()

892. {

901. throw

902. new

903. UnsupportedOperationException(remove);

908. }

909.
!

913. default

914. void

915. forEachRemaining(Consumer?

916. super

917. E

918. action)

919. {

928. Objects.requireNonNull(action);

937. while

938. (hasNext())

951. action.accept(next());

956. }

957. 기본 메서드와 상속
• 클래스의 구현이 인터페이스의 기본 구현보다 우선
• 가장 구체적인 구현(most specific implementation)에 우선권 부여
• 다이아몬드 문제 발생 가능
• 컴파일 오류 발생(T inherits unrelated defaults for x())
• 명시적인 오버라이드 필요
• 충돌하는 둘 이상의 수퍼타입 중 선호하는 수퍼타입을 선택할 수 있음
• 타입 다중 상속, 행위 다중 상속은 지원하지만 상태 다중 상속은 미지원
interface

958. Robot

959. implements

960. Artist,

961. Gun

962. {

967. default

968. void

969. draw()

970. {

971. Artist.super.draw();

972. }

973.
}

974. 인터페이스 정적 메서드
• 인터페이스에 정적 메서드 포함 가능
• 인터페이스에 필요한 정적 메서드를 별도 유틸리티 클래스로 분리할 필요 없음
public

975. interface

976. FunctionT,

977. R

978. {

979.
!

983. R

984. apply(T

985. t);

992. static

993. Function?,

994. String

995. toStringFunction()

996. {

1005. return

1006. value

1007. -

1008. value.toString();

1013. }

1020. static

1021. E

1022. FunctionE,

1023. E

1024. identity()

1025. {

1034. return

1035. value

1036. -

1037. value;

1042. }

1049. static

1050. R

1051. Function?,

1052. R

1053. constant(R

1054. constantValue)

1055. {

1064. return

1065. value

1066. -

1067. constantValue;

1072. }

1073.
}

1074. 자바 5의 정적 임포트
• 자바 5에서 클래스 맴버(또는 정적 맴버) 임포트 기능 추가
import

1075. static

1076. java.lang.Math.*;

1077.
• 상속 없이 특정 클래스나 인터페이스의 정적 멤버에 직접 접근
상수 인터페이스 안티패턴 예방
double

1078. r

1079. =

1080. cos(PI

1081. *

1082. theta);

1083.
• 클래스 메서드를 전역 함수로 사용하는 효과
• 클래스 메서드(정적 메서드) 사용 빈도 확대, 서술적인 API
import

1084. static

1085. org.junit.Assert.*;
import

1086. static

1087. org.mockito.Mockito.*;

1088.
• 람다와 인터페이스 정적 메서드와 시너지 기대
import

1089. static

1090. com.mysema.query.alias.Alias.*;

1091.
!
Cat

1092. c

1093. =

1094. alias(Cat.class,

1095. cat);

1096.
for

1097. (String

1098. name

1099. :

1109. from($(c),cats).where($(c.getKittens()).size().gt(0)).list($(c.getName()))){

1114. System.out.println(name);

1115.
}

1116. 요약
• 인터페이스에 메서드 구현 허용: 기본 메서드, 정적 메서드
• 기본 메서드: 인터페이스 메서드 추가로 인한 하위 호환성 문제 해결
• 정적 메서드: 별도 헬퍼 클래스 불필요
• 자바 5의 정적 메서드 임포트, 정적 메서드, 람다식의 혼용으로 전역 함수
활용 활성화 예상

1117. 기타 등등…
https://www.flickr.com/photos/ilmungo/115943573/

1118. 익명 클래스 생성
public

1119. class

1120. SimpleApp

1121. {

1126. public

1127. static

1128. void

1129. main(String[]

1130. args)

1131. {

1140. Runnable

1141. runnable

1142. =

1143. new

1144. Runnable()

1145. {

1158. @Override

1171. public

1172. void

1173. run()

1174. {

1176. }

1185. };

1190. }

1191.
}

1193. public

1194. static

1195. void

1196. main(java.lang.String[]);

1201. Code:

1209. 0:

1210. new

1221. #2

1235. //

1236. class

1237. org/fupfin/java8/lambda/SimpleApp$1

1245. 3:

1246. dup

1254. 4:

1255. invokespecial

1256. #3