์ž๋ฐ”์˜ ์ •์„ - ๋žŒ๋‹ค์‹(Lambda Expression)

๋ธ”๋กœ๊ทธ ์˜ฎ๊ฒผ์Šต๋‹ˆ๋‹ค! ๐Ÿก’ integer.blog



์ž๋ฐ”์˜ ์ •์„(๋‚จ๊ถ์„ฑ ์ €) 2๊ถŒ ํ•™์Šต๋‚ด์šฉ ์ •๋ฆฌ

1. ๋žŒ๋‹ค์‹

๋ฉ”์„œ๋“œ๋ฅผ ํ•˜๋‚˜์˜ ์‹(expression)์œผ๋กœ ํ‘œํ˜„ํ•œ ๊ฒƒ.
๋ฉ”์„œ๋“œ๋ฅผ ๋žŒ๋‹ค์‹์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด ๋ฉ”์„œ๋“œ์˜ ์ด๋ฆ„๊ณผ ๋ฐ˜ํ™˜๊ฐ’์ด ์—†์–ด์ง€๋ฏ€๋กœ ๋žŒ๋‹ค์‹์„ ์ต๋ช…ํ•จ์ˆ˜(anonymous function)๋ผ๊ณ ๋„ ํ•œ๋‹ค.

๋žŒ๋‹ค์‹์€ ๋ฉ”์„œ๋“œ์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ „๋‹ฌ๋  ์ˆ˜ ์žˆ๊ณ ,
๋ฉ”์„œ๋“œ์˜ ๊ฒฐ๊ณผ๋กœ ๋ฐ˜ํ™˜๋  ์ˆ˜ ์žˆ๋‹ค.
์ฆ‰, ๋ฉ”์„œ๋“œ๋ฅผ ๋ณ€์ˆ˜์ฒ˜๋Ÿผ ๋‹ค๋ฃจ๋Š” ๊ฒƒ์ด ๊ฐ€๋Šฅํ•˜๋‹ค.

2. ๋žŒ๋‹ค์‹ ์ž‘์„ฑํ•˜๊ธฐ

  • ๋ฉ”์„œ๋“œ์—์„œ ์ด๋ฆ„๊ณผ ๋ฐ˜ํ™˜ํƒ€์ž… ์ œ๊ฑฐ
  • ๋งค๊ฐœ๋ณ€์ˆ˜ ์„ ์–ธ๋ถ€์™€ ๋ชธํ†ต{} ์‚ฌ์ด์— -> ์ถ”๊ฐ€
//๊ธฐ์กด
๋ฐ˜ํ™˜ํƒ€์ž… ๋ฉ”์„œ๋“œ์ด๋ฆ„ (๋งค๊ฐœ๋ณ€์ˆ˜ ์„ ์–ธ)  {
  ...
}

//๋žŒ๋‹ค์‹
(๋งค๊ฐœ๋ณ€์ˆ˜ ์„ ์–ธ) ->  {
  ...
}
  • ๋ฐ˜ํ™˜๊ฐ’์ด ์žˆ๋Š” ๋ฉ”์„œ๋“œ๋Š” return ๋Œ€์‹  ์‹(expression)์œผ๋กœ ๋Œ€์‹ ํ•  ์ˆ˜ ์žˆ๋‹ค.(์—ฐ์‚ฐ ๊ฒฐ๊ณผ๊ฐ€ ์ž๋™์œผ๋กœ ๋ฐ˜ํ™˜๊ฐ’์ด ๋˜๊ณ  ; ์ƒ๋žต)
  • ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ํƒ€์ž…์€ ์ถ”๋ก ๊ฐ€๋Šฅํ•˜๋ฉด ์ƒ๋žต ๊ฐ€๋Šฅ (๋Œ€๋ถ€๋ถ„ ์ƒ๋žต ๊ฐ€๋Šฅ)
  • ๋‘ ๋งค๊ฐœ๋ณ€์ˆ˜ ์ค‘ ํ•˜๋‚˜์˜ ํƒ€์ž…๋งŒ ์ƒ๋žตํ•˜๋Š” ๊ฒƒ์€ ๋ถˆ๊ฐ€๋Šฅ
  • ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ํ•˜๋‚˜๋ฟ์ด๋ฉด ๊ด„ํ˜ธ() ์ƒ๋žต ๊ฐ€๋Šฅ
  • ์ค‘๊ด„ํ˜ธ{} ์•ˆ์˜ ๋ฌธ์žฅ์ด ํ•˜๋‚˜์ผ ๋•Œ๋Š” ์ค‘๊ด„ํ˜ธ{} ์ƒ๋žต ๊ฐ€๋Šฅ (๋ฌธ์žฅ ๋์— ; ์ƒ๋žต)
  • ์ค‘๊ด„ํ˜ธ{} ์•ˆ์˜ ๋ฌธ์žฅ์ด return๋ฌธ์ผ๊ฒฝ์šฐ ์ค‘๊ด„ํ˜ธ{} ์ƒ๋žต ๋ถˆ๊ฐ€๋Šฅ
//๊ธฐ์กด
int max(int a, int b) {
  return a > b ? a : b;
}

//๋žŒ๋‹ค์‹
(int a, int b) -> {
  return a > b ? a : b;
}

//return๋ฌธ ๋Œ€์‹  expression ์‚ฌ์šฉ
(int a, int b) -> a > b ? a: b

//๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž… ์ƒ๋žต
(a, b) -> a > b ? a : b

//๋งค๊ฐœ๋ณ€์ˆ˜ 1๊ฐœ์ผ ๊ฒฝ์šฐ ๊ด„ํ˜ธ ์ƒ๋žต
a -> a*a     //OK
int a -> a*a //์—๋Ÿฌ

//๋ณธ๋ฌธ ๋ฌธ์žฅ 1๊ฐœ์ผ ๊ฒฝ์šฐ ์ค‘๊ด„ํ˜ธ ์ƒ๋žต
(String name, int i) -> System.out.println(name+"="+i)

3. ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค(Functional Interface)

๋žŒ๋‹ค์‹์„ ๋‹ค๋ฃจ๊ธฐ ์œ„ํ•œ ์ธํ„ฐํŽ˜์ด์Šค

๋žŒ๋‹ค์‹์€ ๋ฉ”์„œ๋“œ์™€ ๋™๋“ฑํ•œ ๊ฒƒ์ด ์•„๋‹ˆ๋ผ ์ต๋ช…ํด๋ž˜์Šค์˜ ๊ฐ์ฒด์™€ ๋™๋“ฑํ•˜๋‹ค.

// ๋žŒ๋‹ค์‹
  (int a, int b) -> a > b ? a : b

// ์ต๋ช…ํด๋ž˜์Šค์˜ ๊ฐ์ฒด
  new Object()  {
    int max(int a, int b) {
      return a > b ? a : b ;
    }
  }

๋žŒ๋‹ค์‹์œผ๋กœ ์ •์˜๋œ ์ต๋ช… ๊ฐ์ฒด์˜ ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ•˜๋ ค๋ฉด ์ฐธ์กฐ๋ณ€์ˆ˜๊ฐ€ ํ•„์š”ํ•˜๋‹ค.
์ด ๋•Œ, ์ฐธ์กฐ๋ณ€์ˆ˜์˜ ํƒ€์ž…์€ ํด๋ž˜์Šค ๋˜๋Š” ์ธํ„ฐํŽ˜์ด์Šค๊ฐ€ ๊ฐ€๋Šฅํ•œ๋ฐ,
๋žŒ๋‹ค์‹๊ณผ ๋™๋“ฑํ•œ ๋ฉ”์„œ๋“œ๊ฐ€ ์ •์˜๋˜์–ด ์žˆ๋Š” ๊ฒƒ์ด์–ด์•ผ ํ•œ๋‹ค.

// ์˜ˆ๋ฅผ ๋“ค์–ด max() ๋ฉ”์„œ๋“œ๊ฐ€ ์ •์˜๋œ Myfunction ์ธํ„ฐํŽ˜์ด์Šค ์ •์˜
  interface MyFunction  {
    public abstract int max(int a, int b);

// MyFunction ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ตฌํ˜„ํ•œ ์ต๋ช…ํด๋ž˜์Šค ๊ฐ์ฒด ์ƒ์„ฑ
  MyFunction f = new MyFunction() {
    public int max (int a, int b);
      return a > b ? a : b;
    }
  }
  int big = f.max(5, 3);  //์ต๋ช… ๊ฐ์ฒด์˜ ๋ฉ”์„œ๋“œ ํ˜ธ์ถœ

// ์œ„์˜ ์ต๋ช… ๊ฐ์ฒด๋ฅผ ๋žŒ๋‹ค์‹์œผ๋กœ ๋Œ€์ฒด
  MyFunction f = (int a, int b) -> a > b ? a : b;
  int big = f.max(5, 3);

์œ„ ์ฒ˜๋Ÿผ MyFunction ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ตฌํ˜„ํ•œ ์ต๋ช… ๊ฐ์ฒด๋ฅผ ๋žŒ๋‹ค์‹์œผ๋กœ ๋Œ€์ฒด ๊ฐ€๋Šฅํ•œ ์ด์œ ๋Š” ๋žŒ๋‹ค์‹๋„ ์‹ค์ œ๋กœ๋Š” ์ต๋ช… ๊ฐ์ฒด์ด๊ณ , MyFunction ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ตฌํ˜„ํ•œ ์ต๋ช… ๊ฐ์ฒด์˜ ๋ฉ”์„œ๋“œ max()์™€ ๋žŒ๋‹ค์‹์˜ ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ํƒ€์ž…๊ณผ ๊ฐœ์ˆ˜, ๋ฐ˜ํ™˜๊ฐ’์ด ์ผ์น˜ํ•˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

๋‹จ, ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค์—๋Š” ์˜ค์ง ํ•˜๋‚˜์˜ ์ถ”์ƒ ๋ฉ”์„œ๋“œ๋งŒ ์ •์˜๋˜์–ด ์žˆ์–ด์•ผ ํ•œ๋‹ค. ๊ทธ๋ž˜์•ผ ๋žŒ๋‹ค์‹๊ณผ ์ธํ„ฐํŽ˜์ด์Šค๊ฐ€ 1:1๋กœ ์—ฐ๊ฒฐ๋˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ๋ฐ˜๋ฉด static ๋ฉ”์„œ๋“œ์™€ default ๋ฉ”์„œ๋“œ์˜ ๊ฐœ์ˆ˜์—๋Š” ์ œ์•ฝ์ด ์—†๋‹ค.

@FunctionalInterface๋ฅผ ๋ถ™์ด๋ฉด ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ์ •์˜ํ•˜์˜€๋Š”์ง€ ํ™•์ธํ•ด์ค€๋‹ค.

// ๊ธฐ์กด ์ธํ„ฐํŽ˜์ด์Šค์˜ ๋ฉ”์„œ๋“œ ๊ตฌํ˜„
  List<String> list = Arrays.asList("abc", "aaa", "bbb", "ccc");
  Collections.sort(list, new Comparator<String>() {
    public int compare(String s1, String s2)  {
      return s2.compareTo(s1);
    }
  });

// ๋žŒ๋‹ค์‹์œผ๋กœ ๊ตฌํ˜„
  List<String> list = Arrays.asList("abc", "aaa", "bbb", "ccc");
  Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋กœ ๋žŒ๋‹ค์‹์„ ์ฐธ์กฐํ•  ์ˆ˜ ์žˆ์ง€๋งŒ, ๋žŒ๋‹ค์‹์˜ ํƒ€์ž…์ด ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค์˜ ํƒ€์ž…๊ณผ ์ผ์น˜ํ•˜๋Š” ๊ฒƒ์€ ์•„๋‹ˆ๋‹ค. ๋žŒ๋‹ค์‹์€ ์ต๋ช… ๊ฐ์ฒด์ด๊ณ  ์ต๋ช… ๊ฐ์ฒด๋Š” ํƒ€์ž…์ด ์—†๋‹ค. (์ •ํ™•ํžˆ๋Š” ํƒ€์ž…์ด ์žˆ์ง€๋งŒ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ž„์˜๋กœ ์ด๋ฆ„์„ ์ •ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์•Œ ์ˆ˜ ์—†๋‹ค.) ๊ทธ๋Ÿฌ๋ฏ€๋กœ ์•„๋ž˜์™€ ๊ฐ™์ด ํ˜•๋ณ€ํ™˜์ด ํ•„์š”ํ•˜๋‹ค.

MyFunction f = (MyFunction) (()->{}); //

๋žŒ๋‹ค์‹์€ MyFunction์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์ง์ ‘ ๊ตฌํ˜„ํ•˜์ง€ ์•Š์•˜์ง€๋งŒ, ์ด ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ตฌํ˜„ํ•œ ํด๋ž˜์Šค์˜ ๊ฐ์ฒด์™€ ์™„์ „ํžˆ ๋™์ผํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์œ„์™€ ๊ฐ™์€ ํ˜•๋ณ€ํ™˜์„ ํ—ˆ์šฉํ•œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ด ํ˜•๋ณ€ํ™˜์€ ์ƒ๋žต ๊ฐ€๋Šฅํ•˜๋‹ค.

๋žŒ๋‹ค์‹์€ ์ด๋ฆ„์ด ์—†์„ ๋ฟ ๋ถ„๋ช…ํžˆ ๊ฐ์ฒด์ธ๋ฐ๋„, Object ํƒ€์ž…์œผ๋กœ ํ˜•๋ณ€ํ™˜ ํ•  ์ˆ˜ ์—†๋‹ค. ๋žŒ๋‹ค์‹์€ ์˜ค์ง ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋กœ๋งŒ ํ˜•๋ณ€ํ™˜์ด ๊ฐ€๋Šฅํ•˜๋‹ค. ๊ตณ์ด Object ํƒ€์ž…์œผ๋กœ ํ˜•๋ณ€ํ™˜ํ•˜๋ ค๋ฉด ์•„๋ž˜์™€ ๊ฐ™์ด ๋จผ์ € ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋กœ ๋ณ€ํ™˜ํ•ด์•ผ ํ•œ๋‹ค.

Object obj = (Object)(MyFunction)(()->{});
String str = (Object)(MyFunction)(()->{})).toString();

4. java.util.function ํŒจํ‚ค์ง€

์ด ํŒจํ‚ค์ง€์— ์ž์ฃผ ์“ฐ์ด๋Š” ํ˜•์‹์˜ ๋ฉ”์„œ๋“œ๋ฅผ ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋กœ ์ •์˜ํ•ด๋†“์•˜๋‹ค.

ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค ๋ฉ”์„œ๋“œ ์„ค๋ช…
java.lang.Runnable void run() ๋งค๊ฐœ๋ณ€์ˆ˜๋„ ์—†๊ณ , ๋ฐ˜ํ™˜๊ฐ’๋„ ์—†์Œ
Supplier T get() ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ์—†๊ณ , ๋ฐ˜ํ™˜๊ฐ’๋งŒ ์žˆ์Œ
Consumer void accept(T t) Supplier์™€ ๋ฐ˜๋Œ€๋กœ ๋งค๊ฐœ๋ณ€์ˆ˜๋งŒ ์žˆ๊ณ , ๋ฐ˜ํ™˜๊ฐ’์ด ์—†์Œ
Function R apply(T t) ์ผ๋ฐ˜์ ์ธ ํ•จ์ˆ˜. ํ•˜๋‚˜์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ๋ฐ›์•„์„œ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜
Predicate boolean test(T t) ์กฐ๊ฑด์‹์„ ํ‘œํ˜„ํ•˜๋Š”๋ฐ ์‚ฌ์šฉ. ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ํ•˜๋‚˜, ๋ฐ˜ํ™˜ ํƒ€์ž…์€ boolean
BiConsumer void accept(T t, U u) ๋‘๊ฐœ์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋งŒ ์žˆ๊ณ , ๋ฐ˜ํ™˜๊ฐ’์ด ์—†์Œ
BiPredicate boolean test(T t, U u) ์กฐ๊ฑด์‹์„ ํ‘œํ˜„ํ•˜๋Š”๋ฐ ์‚ฌ์šฉ๋จ. ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ๋‘˜, ๋ฐ˜ํ™˜๊ฐ’์€ boolean
BiFunction R apply(T t, U u) ๋‘๊ฐœ์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ๋ฐ›์•„์„œ ํ•˜๋‚˜์˜ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜
  • ์ˆ˜ํ•™์—์„œ ๊ฒฐ๊ณผ๋กœ true ๋˜๋Š” false๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ Predicate ๋ผ๊ณ  ํ•œ๋‹ค.
  • ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ 2๊ฐœ์ธ ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋Š” ์ด๋ฆ„ ์•ž์— ‘Bi’๊ฐ€ ๋ถ™๋Š”๋‹ค.
  • Supplier๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ์—†๊ณ  ๋ฐ˜ํ™˜๊ฐ’๋งŒ ์กด์žฌํ•˜๋Š”๋ฐ ๋ฉ”์„œ๋“œ๋Š” ๋‘ ๊ฐœ์˜ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•  ์ˆ˜ ์—†์œผ๋ฏ€๋กœ BiSupplier๊ฐ€ ์—†๋‹ค.
  • ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ํƒ€์ž…๊ณผ ๋ฐ˜ํ™˜ํƒ€์ž…์ด ์ผ์น˜ํ•  ๋•Œ๋Š” Function ๋Œ€์‹  UnaryOperator๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค. (๋งค๊ฐœ ๋ณ€์ˆ˜ 2๊ฐœ๋ฉด BinaryOperator)
// ์กฐ๊ฑด์‹ ํ‘œํ˜„์— ์‚ฌ์šฉ๋˜๋Š” Predicate

Predicate<String> isEmptyStr = s -> s.length() == 0;
String s = "";

if(isEmptyStr.test(s))
  System.out.println("This is an empty String.");

5. Function์˜ ํ•ฉ์„ฑ๊ณผ Predicate์˜ ๊ฒฐํ•ฉ

5.1. Function์˜ ํ•ฉ์„ฑ

๋‘ ๋žŒ๋‹ค์‹์„ ํ•ฉ์„ฑํ•ด์„œ ์ƒˆ๋กœ์šด ๋žŒ๋‹ค์‹์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.

ํ•จ์ˆ˜ f, g๊ฐ€ ์žˆ์„ ๋•Œ
f.andThen(g)๋Š” ํ•จ์ˆ˜ f๋ฅผ ๋จผ์ € ์ ์šฉํ•˜๊ณ  g ์ ์šฉ.
f.compose(g)๋Š” ํ•จ์ˆ˜ g๋ฅผ ๋จผ์ € ์ ์šฉํ•˜๊ณ  f ์ ์šฉ.

5.2. Predicate์˜ ๊ฒฐํ•ฉ

์—ฌ๋Ÿฌ Predicate๋ฅผ and(), or(), negate()๋กœ ์—ฐ๊ฒฐํ•ด์„œ ํ•˜๋‚˜์˜ ์ƒˆ๋กœ์šด Predicate๋กœ ๊ฒฐํ•ฉํ•  ์ˆ˜ ์žˆ๋‹ค. Predicate์˜ ๋์— negate()๋ฅผ ๋ถ™์ด๋ฉด ์กฐ๊ฑด์‹ ์ „์ฒด๊ฐ€ ๋ถ€์ •์ด ๋œ๋‹ค.

Predicate<Integer> p = i -> i < 100;
Predicate<Integer> q = i -> i < 200;
Predicate<Integer> r = i -> i%2 == 0;
Predicate<Integer> notP = p.negate();

// 100 <= i && (i < 200 || i%2==0)
Predicate<Integer> all = notP.and(q.or(r));
System.out.println(all.test(150));  // true

static ๋ฉ”์„œ๋“œ์ธ isEqual()์€ ๋‘ ๋Œ€์ƒ์„ ๋น„๊ตํ•˜๋Š” Predicate๋ฅผ ๋งŒ๋“ค ๋•Œ ์‚ฌ์šฉํ•œ๋‹ค.
isEqual()์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋น„๊ต๋Œ€์ƒ์„ ํ•˜๋‚˜ ์ง€์ •ํ•˜๊ณ , ๋˜ ๋‹ค๋ฅธ ๋น„๊ต๋Œ€์ƒ์€ test()์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ง€์ •ํ•œ๋‹ค.

Predicate<String> p = Predicate.isEqual(str1);
boolean result = p.test(str2);  //str1๊ณผ str2๊ฐ€ ๊ฐ™์€์ง€ ๋น„๊ตํ•˜์—ฌ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜

// ์œ„์˜ ๋‘ ๋ฌธ์žฅ์„ ํ•˜๋‚˜๋กœ ํ•ฉ์น˜๋ฉด
boolean result = Predicate.isEqual(str1).test(str2);

6. ๋ฉ”์„œ๋“œ ์ฐธ์กฐ(Method reference)

๋žŒ๋‹ค์‹์ด ํ•˜๋‚˜์˜ ๋ฉ”์„œ๋“œ๋งŒ ํ˜ธ์ถœํ•˜๋Š” ๊ฒฝ์šฐ, ๋ฉ”์„œ๋“œ ์ฐธ์กฐ๋ฅผ ํ†ตํ•ด ๋žŒ๋‹ค์‹์„ ๊ฐ„๋žตํžˆ ํ•  ์ˆ˜ ์žˆ๋‹ค.
ํด๋ž˜์Šค๋ช…::๋ฉ”์„œ๋“œ๋ช… ๋˜๋Š” ์ฐธ์กฐ๋ณ€์ˆ˜::๋ฉ”์„œ๋“œ๋ช…

// ๊ธฐ์กด
Function<String, Integer> f = (String s) -> Integer.parseInt(s);

// ๋ฉ”์„œ๋“œ ์ฐธ์กฐ
Funcation<String, Integer> f = Integer::parseInt;

์ƒ์„ฑ์ž๋ฅผ ํ˜ธ์ถœํ•˜๋Š” ๋žŒ๋‹ค์‹๋„ ๋ฉ”์„œ๋“œ ์ฐธ์กฐ๋กœ ๋ณ€ํ™˜ ๊ฐ€๋Šฅ

Supplier<MyClass> s = () -> new MyClass();  // ๋žŒ๋‹ค์‹
Supplier<MyClass> s = MyClass::new; // ๋ฉ”์„œ๋“œ ์ฐธ์กฐ

๋ฐฐ์—ด ์ƒ์„ฑํ•  ๊ฒฝ์šฐ

Function<Integer, int[]> f = x -> new int[x]; // ๋žŒ๋‹ค์‹
Function<Integer, int[]> f2 = int[]::new; // ๋ฉ”์„œ๋“œ ์ฐธ์กฐ