feat: 스트림, 람다, Optional 기능구현

BACKJAC_README.md

@@ -0,0 +1,38 @@
+블랙잭 게임을 변형한 프로그램을 구현한다. 
+
+블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+
+- 카드 덱
+♠♥♦♣ 네 수트(문양)
+A, 2, 3, 4, 5, 6, 7, 8, 9, 10 + 잭(J, Jack), 퀸(Q, Queen), 킹(K, King) 메이저 카드 = 52장 + 조커 2장  = 54장
+
+- Deck
+1. spadeCard = 13장 + 조커 1장 [v]
+    - cardlist
+2. heartCard = 13장 + 조커 1장 [v]
+    - cardlist
+3. diamondCard = 13장 [v]
+    - cardlist
+4. cloverCard = 13장 [v]
+    - cardlist
+
+- 셔플기능 [v]
+
+- player
+1. UserA [v]
+2. UserB [v]
+3. dealer [v]
+
+- 10000 -> 1칩이라고 가정
+
+1. 플레이어는 게임을 시작할 때 배팅 금액을 정해야 한다. 
+2. 카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 Ace는 1 또는 11로 계산할 수 있으며, King, Queen, Jack은 각각 10으로 계산한다. [v]
+3. 게임을 시작하면 플레이어는 두 장의 카드를 지급 받으며, 두 장의 카드 숫자를 합쳐 21을 초과하지 않으면서 21에 가깝게 만들면 이긴다. 
+4. 21을 넘지 않을 경우 원한다면 얼마든지 카드를 계속 뽑을 수 있다. 단, 카드를 추가로 뽑아 21을 초과할 경우 배팅 금액을 모두 잃게 된다. 
+5. 처음 두 장의 카드 합이 21일 경우 블랙잭이 되면 베팅 금액의 1.5 배를 딜러에게 받는다. 딜러와 플레이어가 모두 동시에 블랙잭인 경우 플레이어는 베팅한 금액을 돌려받는다.
+6. 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다. 
+7. 딜러가 21을 초과하면 그 시점까지 남아 있던 플레이어들은 가지고 있는 패에 상관 없이 승리해 베팅 금액을 받는다.
+
+
+
+

STREAM_README.md

@@ -0,0 +1,5 @@
+1. 단어의 길이가 12자를 초과하는 단어를 추출한다.
+2. 12자가 넘는 단어 중 길이가 긴 순서로 100개의 단어를 추출한다.
+3. 단어 중복을 허용하지 않는다. 즉, 서로 다른 단어 100개를 추출해야 한다.
+4. 추출한 100개의 단어를 출력한다. 모든 단어는 소문자로 출력해야 한다.
+

src/main/java/nextstep/blackjac/Main.java

@@ -0,0 +1,13 @@
+package nextstep.blackjac;
+
+import nextstep.blackjac.controller.UserController;
+import nextstep.blackjac.view.BlackJacView;
+
+public class Main {
+    private static UserController userController = new UserController();
+
+    public static void main(String[] args) {
+        userController.play();
+    }
+
+}

src/main/java/nextstep/blackjac/card/Card.java

@@ -0,0 +1,47 @@
+package nextstep.blackjac.card;
+
+import java.util.*;
+
+public class Card {
+    private String cardName;
+    private String cardShape;
+    private int cardNumber;
+
+    public Card(String cardName, String cardShape, int cardNumber) {
+        this.cardName = cardName;
+        this.cardShape = cardShape;
+        this.cardNumber = cardNumber;
+    }
+
+    public Card(String cardName, String cardShape) {
+        this.cardName = cardName;
+        this.cardShape = cardShape;
+    }
+
+    public Card(String cardShape, int cardNumber) {
+        this.cardShape = cardShape;
+        this.cardNumber = cardNumber;
+    }
+
+    public int cardNumberTotal(Card card) {
+        return card.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 cardNumber == card.cardNumber && Objects.equals(cardName, card.cardName) && Objects.equals(cardShape, card.cardShape);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cardName, cardShape, cardNumber);
+    }
+
+    @Override
+    public String toString() {
+        return cardNumber + cardShape;
+    }
+}

src/main/java/nextstep/blackjac/card/CardDeck.java

@@ -0,0 +1,56 @@
+package nextstep.blackjac.card;
+
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class CardDeck {
+    private SpadeCard spadeCardDeck;
+    private HeartCard heartCardDeck;
+    private DiamondCard diamondCardDeck;
+    private CloverCard cloverCardDeck;
+    private Stack<Card> cardDeck;
+
+    public CardDeck() {
+        spadeCardDeck = new SpadeCard("spade");
+        heartCardDeck = new HeartCard("heart");
+        diamondCardDeck = new DiamondCard("diamond");
+        cloverCardDeck = new CloverCard("clover");
+    }
+
+    public void shuffle() {
+        List<Card> cardDeck = concat();
+        Collections.shuffle(cardDeck);
+        cardDeck = createDeck(cardDeck);
+    }
+
+    private List<Card> concat() {
+        cardShuffle();
+        List<Card> shuffleSpadeCardDeck = spadeCardDeck.getCardList();
+        List<Card> shuffleHeartCardDeck = heartCardDeck.getCardList();
+        List<Card> shuffleDiamondCardDeck = diamondCardDeck.getCardList();
+        List<Card> shuffleCloverCardDeck = cloverCardDeck.getCardList();
+
+        return Stream.of(shuffleSpadeCardDeck, shuffleHeartCardDeck, shuffleDiamondCardDeck, shuffleCloverCardDeck)
+                .flatMap(List::stream)
+                .collect(Collectors.toList());
+    }
+
+    private void cardShuffle() {
+        spadeCardDeck.shuffle();
+        heartCardDeck.shuffle();
+        diamondCardDeck.shuffle();
+        cloverCardDeck.shuffle();
+    }
+
+    private Stack<Card> createDeck(List<Card> shuffleCard) {
+        cardDeck = new Stack<Card>();
+        cardDeck.addAll(shuffleCard);
+        return cardDeck;
+    }
+
+    public Stack<Card> getCardDeck() {
+        return cardDeck;
+    }
+}

src/main/java/nextstep/blackjac/card/CloverCard.java

@@ -0,0 +1,12 @@
+package nextstep.blackjac.card;
+
+public class CloverCard extends Deck {
+    public CloverCard(String cardShape) {
+        super(cardShape);
+    }
+
+    @Override
+    void addJoker() {
+
+    }
+}

src/main/java/nextstep/blackjac/card/Deck.java

@@ -0,0 +1,45 @@
+package nextstep.blackjac.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+public abstract class Deck {
+
+    protected List<Card> cardList;
+    protected int cardCount = 13;
+    protected String cardShape;
+
+    protected Deck(String cardShape) {
+        this.cardShape = Optional.ofNullable(cardShape)
+                .orElseThrow(() -> new IllegalArgumentException("카드 모양이 잘 못 되었습니다."));
+        cardList = new ArrayList<>();
+        init();
+        addJoker();
+    }
+
+    void init() {
+        cardList.add(new Card("A", cardShape, 1));
+        cardList.add(new Card("2", cardShape, 2));
+        cardList.add(new Card("3", cardShape, 3));
+        cardList.add(new Card("4", cardShape, 4));
+        cardList.add(new Card("5", cardShape, 5));
+        cardList.add(new Card("6", cardShape, 6));
+        cardList.add(new Card("7", cardShape, 7));
+        cardList.add(new Card("8", cardShape, 8));
+        cardList.add(new Card("9", cardShape, 9));
+        cardList.add(new Card("10", cardShape, 10));
+        cardList.add(new Card("Jack", cardShape, 10));
+        cardList.add(new Card("Queen", cardShape, 10));
+        cardList.add(new Card("King", cardShape, 10));
+    }
+
+    void shuffle() {
+        Collections.shuffle(getCardList());
+    }
+    abstract void addJoker();
+    public List<Card> getCardList() {
+        return cardList;
+    }
+}

src/main/java/nextstep/blackjac/card/DiamondCard.java

@@ -0,0 +1,12 @@
+package nextstep.blackjac.card;
+
+public class DiamondCard extends Deck {
+    public DiamondCard(String cardShape) {
+        super(cardShape);
+    }
+
+    @Override
+    void addJoker() {
+
+    }
+}

src/main/java/nextstep/blackjac/card/HeartCard.java

@@ -0,0 +1,12 @@
+package nextstep.blackjac.card;
+
+public class HeartCard extends Deck {
+    public HeartCard(String cardShape) {
+        super(cardShape);
+    }
+
+    @Override
+    void addJoker() {
+        cardList.add(new Card("Joker", cardShape, 10));
+    }
+}

src/main/java/nextstep/blackjac/card/SpadeCard.java

@@ -0,0 +1,13 @@
+package nextstep.blackjac.card;
+
+public class SpadeCard extends Deck {
+    public SpadeCard(String cardShape) {
+        super(cardShape);
+    }
+
+    @Override
+    void addJoker() {
+        cardList.add(new Card("Joker", cardShape, 10));
+    }
+
+}

src/main/java/nextstep/blackjac/controller/UserController.java

@@ -0,0 +1,47 @@
+package nextstep.blackjac.controller;
+
+import nextstep.blackjac.card.Card;
+import nextstep.blackjac.card.CardDeck;
+import nextstep.blackjac.user.User;
+import nextstep.blackjac.user.Users;
+import nextstep.blackjac.utils.Utils;
+import nextstep.blackjac.view.BlackJacView;
+
+import java.util.List;
+import java.util.Stack;
+
+public class UserController {
+
+    private BlackJacView blackJacView = new BlackJacView();
+    private CardDeck cardDeck = new CardDeck();
+    private Users users;
+    private Stack<Card> shuffleCardDeck;
+
+
+    public void play() {
+        while (true) {
+            String names = blackJacView.joinPeople();
+            List<String> userNames = Utils.splitName(names);
+            List<Integer> money = blackJacView.batting(userNames);
+
+            users = new Users(userNames, money);
+            List<User> userList = users.getUsers();
+
+            cardDeck.shuffle();
+            shuffleCardDeck = cardDeck.getCardDeck();
+
+            users.givenCards(shuffleCardDeck);
+            blackJacView.givenCard(names, userList);
+
+            blackJacView.givenMoreCard(userList, shuffleCardDeck);
+            blackJacView.finalPayment(userList);
+
+            if (blackJacView.endGame()) {
+                break;
+            }
+        }
+    }
+
+
+
+}

src/main/java/nextstep/blackjac/domain/Condition.java

@@ -0,0 +1,6 @@
+package nextstep.blackjac.domain;
+
+@FunctionalInterface
+public interface Condition {
+    boolean condition(int x);
+}

src/main/java/nextstep/blackjac/user/Chip.java

@@ -0,0 +1,14 @@
+package nextstep.blackjac.user;
+
+public class Chip {
+    private int chip;
+
+    public Chip(int chip) {
+        this.chip = chip;
+    }
+    public Chip chip(int chip) {
+        this.chip = chip;
+        return this;
+    }
+
+}

src/main/java/nextstep/blackjac/user/Dealer.java

@@ -0,0 +1,11 @@
+package nextstep.blackjac.user;
+
+public class Dealer extends User {
+    private static final String name = "Dealer";
+    public static final int AUTO_GIVEN_CARD = 16;
+
+    public Dealer() {
+        super(name, UserRole.DEALER);
+    }
+
+}