├── README.md
├── build.sbt
└── src
    └── main
        ├── java
            ├── ControlStructures.java
            ├── JavaClass.java
            ├── JavaClassAuxConstructor.java
            ├── JavaCollections.java
            ├── JavaExceptions.java
            ├── JavaFunctions.java
            ├── JavaInterface.java
            ├── JavaMethods.java
            └── JavaString.java
        └── scala
            ├── CaseClass.scala
            ├── ForComprehension.scala
            ├── Main.scala
            ├── MethodParameter.scala
            ├── PatternMatching.scala
            ├── Person.scala
            ├── ScalaClass.scala
            ├── ScalaClassAuxConstructor.scala
            ├── ScalaCollections.scala
            ├── ScalaControls.scala
            ├── ScalaExceptions.scala
            ├── ScalaFunctions.scala
            ├── ScalaMethods.scala
            ├── ScalaString.scala
            ├── ScalaTrait.scala
            ├── SingleObject.scala
            └── WordCount.scala


/README.md:
--------------------------------------------------------------------------------
 1 | ## 자바 개발자를 위한 스칼라 예제 모음
 2 | 
 3 | ### (무료) 온라인 책
 4 | 
 5 | * <https://scalabook.hatemogi.com>
 6 | 
 7 | ### (유료) 인프런 강의
 8 | 
 9 | * [자바 개발자를 위한 스칼라 맛보기 강의](https://inf.run/YPAU)
10 | 
11 | 
12 | ### 자바 예제 & 스칼라 예제 코드
13 | 
14 | * [src/main/java](https://github.com/hatemogi/scala-for-java-developers/tree/main/src/main/java) 디렉터리
15 | * [src/main/scala](https://github.com/hatemogi/scala-for-java-developers/tree/main/src/main/scala) 디렉터리


--------------------------------------------------------------------------------
/build.sbt:
--------------------------------------------------------------------------------
 1 | val scala3Version = "3.2.2"
 2 | 
 3 | lazy val root = project
 4 |   .in(file("."))
 5 |   .settings(
 6 |     name := "comparison",
 7 |     version := "0.1.0-SNAPSHOT",
 8 | 
 9 |     scalaVersion := scala3Version,
10 | 
11 |     libraryDependencies += "org.scalameta" %% "munit" % "0.7.29" % Test
12 |   )
13 | 


--------------------------------------------------------------------------------
/src/main/java/ControlStructures.java:
--------------------------------------------------------------------------------
 1 | import java.util.Arrays;
 2 | import java.util.List;
 3 | 
 4 | public class ControlStructures {
 5 |     static void conditionals(int x) {
 6 |         if (x == 1) System.out.println(x);
 7 |     }
 8 | 
 9 |     static void ifElseIf(int x) {
10 |         if (x < 0)
11 |             System.out.println("음수");
12 |         else if (x == 0)
13 |             System.out.println("zero");
14 |         else
15 |             System.out.println("양수");
16 |     }
17 | 
18 |     static int min(int a, int b) {
19 |         if (a < b)
20 |             return a;
21 |         else
22 |             return b;
23 |     }
24 | 
25 |     static int min3(int a, int b) {
26 |         return a < b ? a : b;
27 |     }
28 | 
29 |     static void whileLoop() {
30 |         int i = 0;
31 |         while (i < 3) {
32 |             System.out.println(i);
33 |             i++;
34 |         }
35 |     }
36 | 
37 |     static void forLoop() {
38 |         var ints = Arrays.asList(3, 4, 5);
39 |         for (int i: ints) System.out.println(i);
40 | 
41 |         for (int i: ints) {
42 |             int x = i * 2;
43 |             System.out.printf("i = %d, x = %d\n", i, x);
44 |         }
45 | 
46 |         List<Integer> ints2 = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
47 | 
48 |         for (int i: ints2) {
49 |             if (i % 2 == 0 && i < 5) {
50 |                 System.out.println(i);
51 |             }
52 |         }
53 |     }
54 | 
55 |     static String switch1(int weekday) {
56 |         String weekdayAsString = "";
57 |         switch (weekday) {
58 |             case 1: weekdayAsString = "월요일";
59 |                 break;
60 |             case 2: weekdayAsString = "화요일";
61 |                 break;
62 |             default: weekdayAsString = "기타";
63 |                 break;
64 |         }
65 |         return weekdayAsString;
66 |     }
67 | 
68 |     static String switch2(int i) {
69 |         String numAsString = "";
70 |         switch (i) {
71 |             case 1: case 3:
72 |             case 5: case 7: case 9:
73 |                 numAsString = "홀수";
74 |                 break;
75 |             case 2: case 4:
76 |             case 6: case 8: case 10:
77 |                 numAsString = "짝수";
78 |                 break;
79 |             default:
80 |                 numAsString = "범위초과";
81 |                 break;
82 |         }
83 |         return numAsString;
84 |     }
85 | 
86 |     public static void main(String[] args) {
87 |         ControlStructures.conditionals(3);
88 |         ControlStructures.conditionals(1);
89 |         System.out.println(ControlStructures.min(5, 3));
90 |         System.out.println(ControlStructures.min3(5, 3));
91 |         ControlStructures.whileLoop();
92 |         ControlStructures.forLoop();
93 |         System.out.println(ControlStructures.switch1(2));
94 |         System.out.println(ControlStructures.switch2(3));
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/main/java/JavaClass.java:
--------------------------------------------------------------------------------
 1 | public class JavaClass {
 2 | 
 3 |     public class Person {
 4 |         public String name;
 5 |         public int age;
 6 | 
 7 |         public Person(String name, int age) {
 8 |             this.name = name;
 9 |             this.age = age;
10 |         }
11 | 
12 |         @Override
13 |         public String toString() {
14 |             return String.format("%s님은 %d세입니다.", name, age);
15 |         }
16 |     }
17 | 
18 |     public void run() {
19 |         System.out.println(new Person("홍길동", 20));
20 |     }
21 | 
22 |     public static void main(String[] args) {
23 |         new JavaClass().run();
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/main/java/JavaClassAuxConstructor.java:
--------------------------------------------------------------------------------
 1 | public class JavaClassAuxConstructor {
 2 | 
 3 |     public class Person {
 4 |         public String name;
 5 |         public int age;
 6 | 
 7 |         // 주 생성자 (primary constructor)
 8 |         public Person(String name, int age) {
 9 |             this.name = name;
10 |             this.age = age;
11 |         }
12 | 
13 |         // 인수 없는 생성자
14 |         public Person() {
15 |             this("", 0);
16 |         }
17 | 
18 |         // 인수 하나 받는 생성자
19 |         public Person(String name) {
20 |             this(name, 0);
21 |         }
22 | 
23 |         @Override
24 |         public String toString() {
25 |             return String.format("%s님은 %d세입니다.", name, age);
26 |         }
27 |     }
28 | 
29 |     public void run() {
30 |         System.out.println(new Person("홍길동"));
31 |     }
32 | 
33 |     public static void main(String[] args) {
34 |         new JavaClassAuxConstructor().run();
35 |     }
36 | 
37 | }
38 | 


--------------------------------------------------------------------------------
/src/main/java/JavaCollections.java:
--------------------------------------------------------------------------------
 1 | import java.util.List;
 2 | import java.util.Set;
 3 | import java.util.Map;
 4 | 
 5 | import static java.util.stream.Collectors.toList;
 6 | 
 7 | public class JavaCollections {
 8 |     public static void main(String[] args) {
 9 |         List<String> stringList = List.of("a", "b", "c");
10 |         stringList.forEach(System.out::println);
11 | 
12 |         Set<String> set = Set.of("a", "b", "c");
13 | 
14 | 
15 |         Map<String, Integer> map = Map.of(
16 |                 "a", 1,
17 |                 "b", 2,
18 |                 "c", 3
19 |         );
20 | 
21 |         System.out.println(map);
22 | 
23 |         String[] a = {"a", "b"};
24 | 
25 |         var squared = List.of(1, 2, 3).stream().map(x -> x * x).collect(toList());
26 |         System.out.println(squared);
27 |     }
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/src/main/java/JavaExceptions.java:
--------------------------------------------------------------------------------
 1 | import java.io.IOException;
 2 | import java.util.Optional;
 3 | 
 4 | public class JavaExceptions {
 5 |     void writeTextToFile(String text) throws IOException {
 6 | 
 7 |     }
 8 | 
 9 |     Optional<Integer> makeInt(String s) {
10 |         try {
11 |             return Optional.of(Integer.parseInt(s));
12 |         } catch (NumberFormatException e) {
13 |             return Optional.empty();
14 |         }
15 |     }
16 | 
17 |     public void run() {
18 |         String text = "안녕하세요";
19 |         try {
20 |             writeTextToFile(text);
21 |         } catch (IOException ioe) {
22 |             System.out.println(ioe.getMessage());
23 |         } catch (NumberFormatException nfe) {
24 |             System.out.println(nfe.getMessage());
25 |         } finally {
26 |             System.out.println("여기서 리소스 정리");
27 |         }
28 |     }
29 | 
30 |     public static void main(String[] args) {
31 |         new JavaExceptions().run();
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/main/java/JavaFunctions.java:
--------------------------------------------------------------------------------
 1 | import java.util.function.Function;
 2 | import java.util.stream.Stream;
 3 | 
 4 | public class JavaFunctions {
 5 |     public static void main(String[] args) {
 6 |         Stream.of(1, 2, 3).map(x -> x + 1).forEach(System.out::println);
 7 | 
 8 |         Function<Integer, Integer> add1 = x -> x + 1;
 9 |         Stream.of(1, 2, 3).map(add1).forEach(System.out::println);
10 | 
11 |         Function<Integer, Integer> square = x -> x * x;
12 |         Function<Integer, Integer> add1Square = square.compose(add1);
13 | 
14 |         Stream.of(1, 2, 3).map(add1).map(square).forEach(System.out::println);
15 |         Stream.of(1, 2, 3).map(add1Square).forEach(System.out::println);
16 | 
17 |         Function<Integer, Integer> doubler = i -> i * 2;
18 |         Stream.of(1, 2, 3).map(doubler).forEach(System.out::println);
19 | 
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/main/java/JavaInterface.java:
--------------------------------------------------------------------------------
 1 | public class JavaInterface {
 2 | 
 3 |     interface Adder {
 4 |         default int add(int a, int b) {
 5 |             return a + b;
 6 |         }
 7 |     }
 8 | 
 9 |     interface Multiplier {
10 |         default int multiply (int a, int b) {
11 |             return a * b;
12 |         }
13 |     }
14 | 
15 |     static class JavaMath implements Adder, Multiplier {
16 |         public int add(int a, int b) { return a * b; }
17 |     }
18 | 
19 |     public static void main(String[] args) {
20 |         JavaMath jm = new JavaMath();
21 |         System.out.println(jm.add(1, 1));
22 |         System.out.println(jm.multiply(2, 2));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/main/java/JavaMethods.java:
--------------------------------------------------------------------------------
 1 | public class JavaMethods {
 2 | 
 3 |     public int add(int a, int b) {
 4 |         return a + b;
 5 |     }
 6 | 
 7 |     public double triangle(double a, double b) {
 8 |         double a2 = a * a;
 9 |         double b2 = b * b;
10 |         return Math.sqrt(a2 + b2);
11 |     }
12 | 
13 |     public static boolean isNullOrEmpty(String s) {
14 |         return s == null || s.trim().isEmpty();
15 |     }
16 | 
17 |     public static void main(String[] args) {
18 |         JavaMethods m = new JavaMethods();
19 |         System.out.println(m.add(2, 3));
20 |         System.out.println(m.triangle(3, 4));
21 |         final int i = 1;
22 |         var j = 2;
23 |         System.out.println(i + j);
24 |         System.out.println(isNullOrEmpty(null));
25 |         System.out.println(isNullOrEmpty("  "));
26 | 
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/main/java/JavaString.java:
--------------------------------------------------------------------------------
 1 | public class JavaString {
 2 |     public static void main(String[] args) {
 3 |         System.out.println(
 4 |                 "Hello, World!".replace("World", "Korea")
 5 |         );
 6 | 
 7 |         String name = "홍길동";
 8 |         final String str = String.format("안녕하세요, %s님!", name); // => "안녕하세요, 홍길동님!"
 9 |         final String sum = String.format("1 + 2 = %d", 1 + 2);  // => "1 + 2 = 3"
10 |         System.out.println(str);
11 |         System.out.println(sum);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/scala/CaseClass.scala:
--------------------------------------------------------------------------------
 1 | object CaseClass extends App {
 2 | 
 3 |   case class Point(x: Double, y: Double)
 4 | 
 5 |   case class Circle(point: Point, radius: Double)
 6 | 
 7 |   val center = Point(0.0, 0.0)
 8 |   val smallCircle = Circle(center, 1.0)
 9 |   println(smallCircle.radius) // => 1.0
10 | 
11 |   println(Circle(center, 1.0) == Circle(center, 1.0)) // => true
12 |   println(Circle(center, 1.0) == Circle(center, 2.0)) // => false
13 | 
14 |   val aCircle = Circle(Point(0.0, 0.0), 1.0)
15 |   val biggerCircle = aCircle.copy(radius = 2.0)
16 |   val movedCircle = biggerCircle.copy(point = Point(2.0, 2.0))
17 | 
18 |   println(movedCircle)
19 | }
20 | 


--------------------------------------------------------------------------------
/src/main/scala/ForComprehension.scala:
--------------------------------------------------------------------------------
 1 | object ForComprehension extends App {
 2 |   val xs = List(1, 2, 3)
 3 |   for (x <- xs) println(x)
 4 | 
 5 |   for (n <- 0 to 9) println(n)
 6 | 
 7 |   for {
 8 |     i <- 2 to 9
 9 |     j <- 1 to 9
10 |   } println(s"$i x $j = ${i * j}")
11 | 
12 |   val ys = for (x <- xs) yield x * 2 // => List(2, 4, 6)
13 |   println(ys)
14 | 
15 |   val xs2 = List(3, 4, 5)
16 |   val ys2 = List(1, 2)
17 | 
18 |   println(for {
19 |     x <- xs2
20 |     y <- ys2
21 |   } yield x * y)
22 |   // => List(3, 6, 4, 8, 5, 10)
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/src/main/scala/Main.scala:
--------------------------------------------------------------------------------
 1 | @main def hello: Unit = 
 2 |   println(
 3 |     """안녕하세요,
 4 |       |띄어쓰기 위치를
 5 |       |기호를 이용해서 표시해 봅시다.
 6 |     """.stripMargin
 7 |   )
 8 |   println(new Person("홍길동", 45))
 9 | 
10 | 


--------------------------------------------------------------------------------
/src/main/scala/MethodParameter.scala:
--------------------------------------------------------------------------------
 1 | object MethodParameter extends App {
 2 |   def update(key: String, value: Int) =
 3 |     println(s"$key -> $value")
 4 | 
 5 |   update("x", 3)
 6 |   update(key = "x", value = 3)
 7 |   update(value = 3, key = "x") // 좋은 방법은 아니지만, 순서는 상관 없이 쓸 수 있습니다.
 8 | 
 9 |   def greeting(name: String, role: String = "개발자") =
10 |     println(s"안녕하세요, ${role} ${name}님.")
11 | 
12 |   greeting("길동") // => 안녕하세요, 개발자 길동님.
13 |   greeting("둘리", "기획자") // => 안녕하세요, 기획자 둘리님.
14 | 
15 |   def echoInt(n: Int): Int =
16 |     println(s"n = $n")
17 |     n
18 | 
19 |   def ifByValue(cond: Boolean, onTrue: Int, onFalse: Int): Int =
20 |     if cond then onTrue
21 |     else onFalse
22 | 
23 |   ifByValue(true, echoInt(1), echoInt(2)) // => 1반환, "n = 1", "n = 2" 둘 다 프린트
24 |   ifByValue(false, echoInt(1), echoInt(2))
25 | 
26 |   def ifByName(cond: Boolean, onTrue: => Int, onFalse: => Int): Int =
27 |     if cond then onTrue
28 |     else onFalse
29 | 
30 |   ifByName(true, echoInt(1), echoInt(2)) // => 1반환, "n = 1"만 프린트
31 |   ifByName(false, echoInt(1), echoInt(2)) // => 2반환, "n = 2"만 프린트
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/src/main/scala/PatternMatching.scala:
--------------------------------------------------------------------------------
 1 | object PatternMatching extends App {
 2 |   def daysToString(day: Int): String = day match {
 3 |     case 1 => "하루"
 4 |     case 2 => "이틀"
 5 |     case 3 => "사흘"
 6 |     case 4 => "나흘"
 7 |     case _ => day + "일"
 8 |   }
 9 | 
10 |   println(daysToString(2)) // => "이틀"
11 |   println(daysToString(5)) // => "5일"
12 | 
13 |   trait Animal
14 |   case class Cat(name: String, kind: String) extends Animal
15 |   case class Dog(name: String, age: Int) extends Animal
16 |   case class Person(name: String, adult: Boolean) extends Animal
17 | 
18 |   def show(animal: Animal): String =
19 |     animal match {
20 |       case Cat(name, kind)     => s"고양이 ${name}은 ${kind}종입니다."
21 |       case Dog(name, age)      => s"강아지 ${name}는 ${age}살입니다."
22 |       case Person(name, true)  => s"${name}님은 성인입니다."
23 |       case Person(name, false) => s"${name}님은 미성년자입니다."
24 |     }
25 | 
26 |   println(show(Dog("금비", 3))) // => "강아지 금비는 3살입니다."
27 |   println(show(Person("홍길동", true)))
28 | }
29 | 


--------------------------------------------------------------------------------
/src/main/scala/Person.scala:
--------------------------------------------------------------------------------
 1 | class Person(var name: String, var age: Int):
 2 |   // 인수 없는 보조 생성자
 3 |   def this() = this("", 0)
 4 | 
 5 |   // 인수 하나 받는 보조 생성자
 6 |   def this(name: String) = this(name, 0)
 7 | 
 8 |   override def toString = s"${name}님은 ${age}세입니다."
 9 |   println(Vector(1, 2, 3))
10 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaClass.scala:
--------------------------------------------------------------------------------
1 | object ScalaClass extends App {
2 | 
3 |   class Person(var name: String, var age: Int) {
4 |     override def toString = s"${name}님은 ${age}세입니다."
5 |   }
6 | 
7 |   println(new Person("홍길동", 20))
8 | }
9 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaClassAuxConstructor.scala:
--------------------------------------------------------------------------------
 1 | object ScalaClassAuxConstructor extends App {
 2 |   class Person(var name: String, var age: Int) {
 3 |     // 인수 없는 보조 생성자
 4 |     def this() = this("", 0)
 5 | 
 6 |     // 인수 하나 받는 보조 생성자
 7 |     def this(name: String) = this(name, 0)
 8 | 
 9 |     override def toString = s"${name}님은 ${age}세입니다."
10 |   }
11 | 
12 |   println(new Person("홍길동"))
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaCollections.scala:
--------------------------------------------------------------------------------
 1 | object ScalaCollections extends App {
 2 |   val strings = Array("a", "b", "c")
 3 | 
 4 |   val set = Set("a", "b", "c")
 5 |   println(set)
 6 | 
 7 |   val map = Map(
 8 |     "a" -> 1,
 9 |     "b" -> 2,
10 |     "c" -> 3
11 |   )
12 | 
13 |   println(map)
14 | 
15 |   val a = Array("a", "b")
16 |   a.foreach(println)
17 | 
18 |   val squared = List(1, 2, 3).map(x => x * x)
19 |   println(squared)
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaControls.scala:
--------------------------------------------------------------------------------
 1 | object ScalaControls extends App {
 2 |   def conditionals(x: Int) =
 3 |     if (x == 1) println(x)
 4 | 
 5 |   conditionals(1)
 6 | 
 7 |   def conditionalBlock(x: Int) =
 8 |     if (x == 1) {
 9 |       println("x는 1입니다:")
10 |       println(x)
11 |     }
12 | 
13 |   conditionalBlock(1)
14 | 
15 |   def ifElseIf(x: Int) =
16 |     if (x < 0)
17 |       println("음수")
18 |     else if (x == 0)
19 |       println("0")
20 |     else
21 |       println("양수")
22 | 
23 |   ifElseIf(1) // => 양수
24 | 
25 |   def min(a: Int, b: Int): Int =
26 |     if (a < b) a else b
27 | 
28 |   println(min(3, 5)) // => 3
29 | 
30 |   var i = 0
31 |   while (i < 3) {
32 |     println(i)
33 |     i += 1
34 |   }
35 | 
36 |   val ints = List(3, 4, 5)
37 |   for (i <- ints) println(i)
38 |   for (i <- ints) {
39 |     val x = i * 2
40 |     println(s"i = $i, x = $x")
41 |   }
42 | 
43 |   for {
44 |     i <- 1 to 2
45 |     j <- 'a' to 'b'
46 |     k <- 1 to 10 by 5
47 |   } println(s"i = $i, j = $j, k = $k")
48 | 
49 |   val ints2 = (1 to 10).toList
50 |   for {
51 |     i <- ints2
52 |     if i % 2 == 0
53 |     if i < 5
54 |   } println(i)
55 | 
56 |   val weekday = 2
57 |   val weekdayAsString = weekday match {
58 |     case 1 => "월요일"
59 |     case 2 => "화요일"
60 |     case _ => "기타"
61 |   }
62 | 
63 |   println(weekdayAsString)
64 | 
65 |   i = 3
66 |   val numAsString = i match {
67 |     case 1 | 3 | 5 | 7 | 9  => "홀수"
68 |     case 2 | 4 | 6 | 8 | 10 => "짝수"
69 |     case _                  => "범위초과"
70 |   }
71 | 
72 |   println(numAsString)
73 | }
74 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaExceptions.scala:
--------------------------------------------------------------------------------
 1 | import java.io.IOException
 2 | 
 3 | object ScalaExceptions extends App {
 4 | 
 5 |   def writeTextToFile(text: String) = {}
 6 | 
 7 |   val text = "안녕하세요"
 8 | 
 9 |   try {
10 |     writeTextToFile(text)
11 |   } catch {
12 |     case ioe: IOException =>
13 |       println(ioe.getMessage)
14 |     case nfe: NumberFormatException =>
15 |       println(nfe.getMessage)
16 |   } finally {
17 |     println("여기서 리소스 정리")
18 |   }
19 | 
20 |   def makeInt(s: String): Option[Int] =
21 |     try {
22 |       Some(s.toInt)
23 |     } catch {
24 |       case e: NumberFormatException => None
25 |     }
26 | 
27 |   makeInt("123") match {
28 |     case Some(i) => println(s"정수 i = $i")
29 |     case None    => println("정수로 변환할 수 없어요")
30 |   }
31 | 
32 |   def makeIntE(s: String): Either[String, Int] =
33 |     try {
34 |       Right(s.toInt)
35 |     } catch {
36 |       case e: NumberFormatException => Left(e.getMessage)
37 |     }
38 | 
39 |   makeIntE("123e") match {
40 |     case Left(e)  => println(e)
41 |     case Right(i) => println(s"정수 i = $i")
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaFunctions.scala:
--------------------------------------------------------------------------------
 1 | object ScalaFunctions extends App {
 2 |   List(1, 2, 3).map(x => x + 1).foreach(println)
 3 | 
 4 |   val add1 = (x: Int) => x + 1
 5 |   val square = (x: Int) => x * x
 6 |   List(1, 2, 3).map(add1) // =>  List(2, 3, 4)
 7 | 
 8 |   val add1Square = square.compose(add1)
 9 |   println(List(1, 2, 3).map(add1Square))
10 | 
11 |   val doubler = (i: Int) => i * 2
12 |   println(List(1, 2, 3).map(doubler))
13 |   println(List(1, 2, 3).map(_ * 2))
14 | 
15 |   def greeting(name: String = "길동", role: String) = {
16 |     println(s"안녕하세요, ${role} ${name}님.")
17 |   }
18 | 
19 |   greeting(role = "개발자")
20 | }
21 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaMethods.scala:
--------------------------------------------------------------------------------
 1 | object ScalaMethods extends App {
 2 |   def add(a: Int, b: Int): Int = a + b
 3 | 
 4 |   println(add(2, 3))
 5 | 
 6 |   def triangle(a: Double, b: Double): Double = {
 7 |     val a2 = a * a
 8 |     val b2 = b * b
 9 |     Math.sqrt(a2 + b2)
10 |   }
11 | 
12 |   println(triangle(3.0, 4.0))
13 | 
14 |   object StringUtils {
15 |     def isNullOrEmpty(s: String): Boolean = s == null || s.trim.isEmpty
16 |   }
17 | 
18 |   println(StringUtils.isNullOrEmpty(" "))
19 | 
20 |   def normalAdder(x: Int, y: Int) = x + y
21 | 
22 |   def multiAdder(x: Int)(y: Int): Int = x + y
23 | 
24 |   println(normalAdder(2, 3)) // => 5
25 |   println(multiAdder(2)(3)) // => 5
26 | 
27 |   val xs = List(1, 2, 3)
28 | 
29 |   println(xs.map(x => normalAdder(2, x))) // => List(3, 4, 5)
30 |   println(xs.map(normalAdder(2, _))) // => List(3, 4, 5)
31 |   println(xs.map(multiAdder(2)(_))) // => List(3, 4, 5)
32 |   println(xs.map(multiAdder(2))) // => List(3, 4, 5)
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaString.scala:
--------------------------------------------------------------------------------
 1 | object ScalaString extends App {
 2 |   println("Hello, World!".replace("World", "Korea"))
 3 | 
 4 |   val multiline =
 5 |     """안녕하세요,
 6 |     |여러 줄에 걸친
 7 |     |문자열입니다.
 8 |     """.stripMargin
 9 | 
10 |   println(multiline)
11 | 
12 |   val name = "홍길동"
13 |   val str = s"안녕하세요, ${name}님!" // => "안녕하세요, 홍길동님!"
14 |   val sum = s"1 + 2 = ${1 + 2}"
15 | 
16 |   println(str)
17 |   println(sum)
18 | 
19 |   val jsonString =
20 |     """{
21 |       |  "message": "안녕하세요",
22 |       |  "status": 200
23 |       |}""".stripMargin
24 | 
25 |   println(jsonString)
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main/scala/ScalaTrait.scala:
--------------------------------------------------------------------------------
 1 | object ScalaTrait extends App {
 2 | 
 3 |   trait Adder {
 4 |     def add(a: Int, b: Int) = a + b
 5 |   }
 6 | 
 7 |   trait Multiplier {
 8 |     def multiply(a: Int, b: Int) = a * b
 9 |   }
10 | 
11 |   class ScalaMath extends Adder, Multiplier
12 | 
13 |   val sm = new ScalaMath
14 |   println(sm.add(1, 1))
15 |   println(sm.multiply(2, 2))
16 | }
17 | 


--------------------------------------------------------------------------------
/src/main/scala/SingleObject.scala:
--------------------------------------------------------------------------------
 1 | object SingleObject extends App {
 2 |   object StringUtils {
 3 |     def isNullOrEmpty(s: String): Boolean =
 4 |       s == null || s.trim.isEmpty
 5 |   }
 6 | 
 7 |   class Car(val cc: Int) {
 8 |     import Car._
 9 |     def taxPerYear: Int = taxPerCc(cc).intValue * cc
10 |   }
11 | 
12 |   object Car {
13 |     // 배기량에 따른 cc당 자동차세 + 교육세 30%
14 |     private def taxPerCc(cc: Int) =
15 |       (if cc <= 1000 then 80
16 |        else if cc <= 1600 then 140
17 |        else 200) * 1.3
18 | 
19 |   }
20 | 
21 |   val car = new Car(2000)
22 |   println(car.taxPerYear) // => 520000
23 | }
24 | 


--------------------------------------------------------------------------------
/src/main/scala/WordCount.scala:
--------------------------------------------------------------------------------
 1 | import scala.io.Source
 2 | 
 3 | object WordCount extends App {
 4 |   val words = for {
 5 |     lines <- Source
 6 |       .fromURL("https://www.gutenberg.org/cache/epub/100/pg100.txt")
 7 |       .getLines()
 8 |     words <- lines.split(" ")
 9 |   } yield words.strip
10 |   words.toList.groupBy(identity).map
11 | }
12 | 


--------------------------------------------------------------------------------