익명 클래스, 람다, 스트림 및 Optional

src/main/java/nextstep/blackJack/Foo.java

@@ -0,0 +1,4 @@
+package nextstep.blackJack;
+
+public class Foo {
+}

src/main/java/nextstep/blackJack/GameUser.java

@@ -0,0 +1,7 @@
+package nextstep.blackJack;
+
+public class GameUser extends Gamer {
+    public GameUser(String name) {
+        super(name);
+    }
+}

src/main/java/nextstep/blackJack/Gamer.java

@@ -0,0 +1,67 @@
+package nextstep.blackJack;
+
+import nextstep.blackJack.deck.Card;
+import nextstep.blackJack.deck.CardNumber;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public abstract class Gamer {
+    private final Set<Card> cards;
+    private final String name;
+    private Integer balance;
+    private Integer cardSum = 0;
+    public Gamer(final String name) {
+        this.name = name;
+        this.balance = 100000;
+        this.cards = new HashSet<>();
+    }
+
+    public void betMoney(Integer betMoney) {
+        this.balance -= betMoney;
+    }
+
+    public String getName(){
+        return this.name;
+    }
+
+    public Integer getBalance() {
+        return balance;
+    }
+
+    public void addCard(Card card) {
+        if (!cards.contains(card)){
+            cardSum += card.getCardNumber().getNumber();
+        }
+        cards.add(card);
+    }
+
+    public boolean isHaveAce(){
+        return this.cards.stream().map(Card::getCardNumber).anyMatch(CardNumber::isAce);
+    }
+
+    public boolean isFull(){
+        return this.cardSum > 21;
+    }
+
+    public Integer getSum() {
+//        cardSum = cards.stream().map(Card::getCardNumber).map(CardNumber::getNumber).reduce(0, Integer::sum);
+        return cardSum;
+    }
+
+    private void calculateAce(){
+        if (isHaveAce()){
+            this.cardSum = getMax();
+        }
+    }
+
+    private int getMax() {
+        return Math.max(getAbsoluteSum(cardSum),getAbsoluteSum(cards.stream().map(Card::getCardNumber).map(CardNumber::getNumber).reduce(0, Integer::sum) + 10));
+    }
+
+    private int getAbsoluteSum(int cardSum){
+        return Math.abs(cardSum - 21);
+    }
+}

src/main/java/nextstep/blackJack/Trump.java

@@ -0,0 +1,12 @@
+package nextstep.blackJack;
+
+public abstract class Trump {
+
+    public static void createCardsByGameStart() {
+
+    }
+
+    public static Trump drawRandomCard() {
+        return null;
+    }
+}

src/main/java/nextstep/blackJack/deck/Card.java

@@ -0,0 +1,33 @@
+package nextstep.blackJack.deck;
+
+import java.util.Objects;
+
+public class Card {
+    private final CardShape cardShape;
+    private final CardNumber cardNumber;
+    public Card(CardShape cardShape, CardNumber cardNumber) {
+        this.cardShape = cardShape;
+        this.cardNumber = cardNumber;
+    }
+
+    public CardShape getCardShape() {
+        return cardShape;
+    }
+
+    public CardNumber getCardNumber() {
+        return cardNumber;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Card card = (Card) o;
+        return cardShape == card.cardShape && cardNumber == card.cardNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cardShape, cardNumber);
+    }
+}

src/main/java/nextstep/blackJack/deck/CardNumber.java

@@ -0,0 +1,26 @@
+package nextstep.blackJack.deck;
+
+public enum CardNumber {
+    ACE(1),
+    TWO(2),
+    THREE(3),
+    FOUR(4),
+    FIVE(5),
+    SIX(6),
+    SEVEN(7),
+    EIGHT(8),
+    NINE(9),
+    J(10), Q(10), K(10);
+    private final Integer number;
+
+    CardNumber(Integer number) {
+        this.number = number;
+    }
+    public Integer getNumber() {
+        return this.number;
+    }
+
+    public boolean isAce(){
+        return this.equals(ACE);
+    }
+}

src/main/java/nextstep/blackJack/deck/CardShape.java

@@ -0,0 +1,21 @@
+package nextstep.blackJack.deck;
+
+import java.util.Arrays;
+
+public enum CardShape {
+    SPADE("SPADE"),
+    HEART("HEART"),
+    DIAMOND("DIAMOND"),
+    CLOVER("CLOVER");
+
+    private final String name;
+
+    CardShape(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+}

src/main/java/nextstep/blackJack/deck/Cards.java

@@ -0,0 +1,41 @@
+package nextstep.blackJack.deck;
+
+import java.util.*;
+
+public class Cards {
+    private final Stack<Card> cards;
+
+    private Cards() {
+        this.cards = createCards();
+    }
+
+    public int size(){
+        return cards.size();
+    }
+
+    public static Cards ofGame(){
+        return new Cards();
+    }
+
+    public void shuffleCards(){
+        Collections.shuffle(this.cards);
+    }
+
+    private void addToCards(CardShape cardShape, Stack<Card> cards) {
+        for (CardNumber cardNumber : CardNumber.values()) {
+            cards.add(new Card(cardShape, cardNumber));
+        }
+    }
+
+    public Stack<Card> createCards() {
+        Stack<Card> cards = new Stack<>();
+        for (CardShape cardShape : CardShape.values()) {
+            addToCards(cardShape, cards);
+        }
+        return cards;
+    }
+
+    public Card pickCard() {
+        return cards.pop();
+    }
+}

src/main/java/nextstep/blackJack/deck/ShuffleStrategy.java

@@ -0,0 +1,8 @@
+package nextstep.blackJack.deck;
+
+import java.util.Stack;
+
+@FunctionalInterface
+public interface ShuffleStrategy {
+    void shuffle(Stack<Card> cards);
+}

src/main/java/nextstep/fp/Lambda.java

@@ -1,5 +1,6 @@
 package nextstep.fp;
 
+import java.util.EnumMap;
 import java.util.List;
 
 public class Lambda {
@@ -18,39 +19,22 @@ public static void printAllLambda(List<Integer> numbers) {
     }
 
     public static void runThread() {
-        new Thread(new Runnable() {
-            @Override
-            public void run() {
-                System.out.println("Hello from thread");
-            }
-        }).start();
+        new Thread(() -> System.out.println("Hello from thread")).start();
     }
 
     public static int sumAll(List<Integer> numbers) {
-        int total = 0;
-        for (int number : numbers) {
-            total += number;
-        }
-        return total;
+        return sumByCondition(numbers, number -> true);
     }
 
     public static int sumAllEven(List<Integer> numbers) {
-        int total = 0;
-        for (int number : numbers) {
-            if (number % 2 == 0) {
-                total += number;
-            }
-        }
-        return total;
+        return sumByCondition(numbers, number -> number % 2 == 0);
     }
 
     public static int sumAllOverThree(List<Integer> numbers) {
-        int total = 0;
-        for (int number : numbers) {
-            if (number > 3) {
-                total += number;
-            }
-        }
-        return total;
+        return sumByCondition(numbers, number -> number > 3);
+    }
+
+    public static int sumByCondition(List<Integer> numbers, SumWithCondition sumWithCondition){
+        return numbers.stream().filter(sumWithCondition::sumCondition).reduce(0, Integer::sum);
     }
 }

src/main/java/nextstep/fp/StreamStudy.java

@@ -5,8 +5,10 @@
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class StreamStudy {
 
@@ -27,6 +29,19 @@ public static void printLongestWordTop100() throws IOException {
                 .get("src/main/resources/fp/war-and-peace.txt")), StandardCharsets.UTF_8);
         List<String> words = Arrays.asList(contents.split("[\\P{L}]+"));
 
+        words.stream()
+                .filter(s -> s.length() > 12)
+                .sorted(Comparator.comparing(String::length).reversed())
+                .distinct()
+                .limit(100)
+                .map(String::toLowerCase)
+                .forEach(System.out::println);
+
+
+        //단어의 길이가 12자를 초과하는 단어를 추출한다.
+        //12자가 넘는 단어 중 길이가 긴 순서로 100개의 단어를 추출한다.
+        //단어 중복을 허용하지 않는다. 즉, 서로 다른 단어 100개를 추출해야 한다.
+        //추출한 100개의 단어를 출력한다. 모든 단어는 소문자로 출력해야 한다.
         // TODO 이 부분에 구현한다.
     }
 
@@ -39,6 +54,6 @@ public static long sumAll(List<Integer> numbers) {
     }
 
     public static long sumOverThreeAndDouble(List<Integer> numbers) {
-        return 0;
+        return numbers.stream().filter(x -> x > 3).map(x -> x * 2).reduce(0, Integer::sum);
     }
 }

src/main/java/nextstep/fp/SumWithCondition.java

@@ -0,0 +1,7 @@
+package nextstep.fp;
+
+import java.util.List;
+@FunctionalInterface
+public interface SumWithCondition {
+    boolean sumCondition(int number);
+}

src/main/java/nextstep/optional/ComputerStore.java

@@ -3,6 +3,8 @@
 import nextstep.optional.Computer.Soundcard;
 import nextstep.optional.Computer.USB;
 
+import java.util.Optional;
+
 public class ComputerStore {
     public static final String UNKNOWN_VERSION = "UNKNOWN";
 
@@ -21,6 +23,7 @@ public static String getVersion(Computer computer) {
     }
 
     public static String getVersionOptional(Computer computer) {
-        return null;
+        return Optional.ofNullable(computer).map(Computer::getSoundcard).map(Soundcard::getUsb).map(USB::getVersion).orElse(UNKNOWN_VERSION);
+//        return null;
     }
 }

src/main/java/nextstep/optional/Expression.java

@@ -1,5 +1,13 @@
 package nextstep.optional;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 enum Expression {
     PLUS("+"), MINUS("-"), TIMES("*"), DIVIDE("/");
 
@@ -12,14 +20,19 @@ enum Expression {
     private static boolean matchExpression(Expression e, String expression) {
         return expression.equals(e.expression);
     }
+    public String getExpression(){
+        return this.expression;
+    }
+    private static final Map<String, Expression> expressionMap = Collections.unmodifiableMap(
+            Arrays.stream(values()).collect(Collectors.toMap(Expression::getExpression, Function.identity()))
+    );
 
     static Expression of(String expression) {
-        for (Expression v : values()) {
-            if (matchExpression(v, expression)) {
-                return v;
-            }
-        }
-
-        throw new IllegalArgumentException(String.format("%s는 사칙연산에 해당하지 않는 표현식입니다.", expression));
+        return Optional.ofNullable(expressionMap.get(expression)).orElseThrow(
+                () -> new IllegalArgumentException(String.format("%s는 사칙연산에 해당하지 않는 표현식입니다.", expression))
+        );
+//        return Arrays.stream(values()).filter(v -> matchExpression(v, expression)).findAny().orElseThrow(
+//                () -> new IllegalArgumentException(String.format("%s는 사칙연산에 해당하지 않는 표현식입니다.", expression))
+//        );
     }
 }