code improvements (adding Card & Hand classes)

exercises/poker/src/example/java/Card.java

+public class Card {
+	private int rank;
+	private int suit;
+
+	public Card(String card) {
+		rank = parseRank(card);
+		suit = parseSuit(card);
+	}
+
+	public int getRank() {
+		return rank;
+	}
+
+	public int getSuit() {
+		return suit;
+	}
+
+	private static int parseRank(String card) {
+		return "..23456789TJQKA".indexOf(card.charAt(0));
+	}
+
+	private static int parseSuit(String card) {
+		return ".HSDC".indexOf(card.charAt(1));
+	}
+}

exercises/poker/src/example/java/Hand.java

+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Hand {
+	private String input;
+	private int score;
+
+	public Hand(String hand) {
+		this.input = hand;
+		this.score = scoreHand(parseCards(hand));
+	}
+
+	public int getScore() {
+		return score;
+	}
+
+	public String getInput() {
+		return input;
+	}
+
+	private static List<Card> parseCards(String hand) {
+		ArrayList<Card> parsedCards = new ArrayList<Card>();
+		String[] parseString = hand.split(" ");
+		for (int i = 0; i < parseString.length; i++) {
+			parsedCards.add(new Card(parseString[i]));
+		}
+		return parsedCards;
+	}
+
+	private static Map<Integer, Integer> getFrequencyMap(List<Card> cards) {
+		Map<Integer, Integer> frequencymap = new HashMap<Integer, Integer>() ;
+		for (Card c : cards) {
+			if (frequencymap.containsKey(c.getRank())) {
+				frequencymap.put(c.getRank(), frequencymap.get(c.getRank()) + 1);
+			} else {
+				frequencymap.put(c.getRank(), 1);
+			}
+		}
+		return frequencymap;
+	}
+
+	private static int scoreHand(List<Card> cards) {
+		List<Card> cardsByRank = new ArrayList<Card>();
+
+		cardsByRank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
+				.collect(Collectors.toList());
+
+		Map<Integer, Integer> frequencymap = getFrequencyMap(cards);
+		List<Integer> ranks = frequencymap.entrySet().stream().map(x -> x.getKey())
+				.sorted(Comparator.reverseOrder()).collect(Collectors.toList());
+
+		frequencymap = frequencymap.entrySet().stream()
+				.sorted(Map.Entry.comparingByValue(Collections.reverseOrder())).collect(Collectors
+						.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
+
+		List<Integer> rankCounts = frequencymap.entrySet().stream().map(x -> x.getValue())
+				.collect(Collectors.toList());
+
+		List<Integer> suits = cards.stream().map(s -> s.getSuit()).collect(Collectors.toList());
+
+		if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
+			ranks = Arrays.asList(5, 4, 3, 2, 1);
+		}
+
+		boolean flush = suits.stream().distinct().count() == 1;
+		boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
+		Iterator<Integer> itr = frequencymap.keySet().iterator();
+		int pairA = itr.next();
+
+		if (straight && flush) {
+			return 800 + frequencymap.keySet().iterator().next();
+		}
+		if (rankCounts.equals(Arrays.asList(4, 1))) {
+			return (700 + (cardsByRank.get(0)).getRank());
+		}
+		if (rankCounts.equals(Arrays.asList(3, 2))) {
+			return 600 + cardsByRank.get(0).getRank();
+		}
+		if (flush) {
+			return 500 + frequencymap.keySet().iterator().next();
+		}
+		if (straight) {
+			return 400 + frequencymap.keySet().iterator().next();
+		}
+		if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
+			return 300 + cardsByRank.get(0).getRank();
+		}
+		if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
+			return 200 + Math.max(pairA, itr.next());
+		}
+		if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
+			return 100 + pairA;
+		}
+		Collections.sort(ranks, (a, b) -> b.compareTo(a));
+		Collections.reverse(ranks);
+		return ranks.get(0);
+	}
+}

exercises/poker/src/example/java/Poker.java

 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
 import java.util.Comparator;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 public class Poker {
-	private static class Card {
-		private int rank;
-		private int suit;
-
-		public Card(String card) {
-			rank = parseRank(card);
-			suit = parseSuit(card);
-		}
-
-		private int getRank() {
-			return rank;
-		}
-
-		private int getSuit() {
-			return suit;
-		}
-
-		private static int parseRank(String card) {
-			return "..23456789TJQKA".indexOf(card.charAt(0));
-		}
-
-		private static int parseSuit(String card) {
-			return ".HSDC".indexOf(card.charAt(1));
-		}
-	}
-
-		private static class Hand {
-			private String input;
-			private int score;
-
-			private Hand(String hand) {
-				this.input = hand;
-				this.score = scoreHand(parseCards(hand));
-			}
-
-			private int getScore() {
-				return score;
-			}
-
-			private String getInput() {
-				return input;
-			}
-
-			private static List<Card> parseCards(String hand) {
-				ArrayList<Card> parseCards = new ArrayList<Card>();
-				String[] parseString = hand.split(" ");
-				for (int i = 0; i < parseString.length; i++) {
-					parseCards.add(new Poker.Card(parseString[i]));
-				}
-				return parseCards;
-			}
-
-			private static int scoreHand(List<Card> cards) {
-
-				List<Card> cardsByrank = new ArrayList<Card>();
-
-				cardsByrank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
-						.collect(Collectors.toList());
-
-				Map<Integer, Integer> frequencymap = new HashMap<Integer, Integer>();
-				for (Card c : cards) {
-					if (frequencymap.containsKey(c.rank)) {
-						frequencymap.put(c.getRank(), frequencymap.get(c.getRank()) + 1);
-					} else {
-						frequencymap.put(c.getRank(), 1);
-					}
-				}
-
-				List<Integer> ranks = frequencymap.entrySet().stream().map(x -> x.getKey())
-						.sorted(Comparator.reverseOrder()).collect(Collectors.toList());
-
-				frequencymap = frequencymap.entrySet().stream()
-						.sorted(Map.Entry.comparingByValue(Collections.reverseOrder())).collect(Collectors
-								.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
-
-				List<Integer> rankCounts = frequencymap.entrySet().stream().map(x -> x.getValue())
-						.collect(Collectors.toList());
-
-				List<Integer> suits = cards.stream().map(s -> s.getSuit()).collect(Collectors.toList());
-
-				if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
-					ranks = Arrays.asList(5, 4, 3, 2, 1);
-				}
-
-				boolean flush = suits.stream().distinct().count() == 1;
-				boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
-				Iterator<Integer> itr = frequencymap.keySet().iterator();
-				int pairA = itr.next();
-
-				if (straight && flush) {
-					return 800 + frequencymap.keySet().iterator().next();
-				}
-				if (rankCounts.equals(Arrays.asList(4, 1))) {
-					return (700 + (cardsByrank.get(0)).getRank());
-				}
-				if (rankCounts.equals(Arrays.asList(3, 2))) {
-					return 600 + cardsByrank.get(0).getRank();
-				}
-				if (flush) {
-					return 500 + frequencymap.keySet().iterator().next();
-				}
-				if (straight) {
-					return 400 + frequencymap.keySet().iterator().next();
-				}
-				if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
-					return 300 + cardsByrank.get(0).getRank();
-				}
-				if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
-					return 200 + Math.max(pairA, itr.next());
-				}
-				if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
-					return 100 + pairA;
-				}
-				Collections.sort(ranks, (a, b) -> b.compareTo(a));
-				Collections.reverse(ranks);
-				return ranks.get(0);
-			}
-		}
 			public static List<String> bestHands(List<String> hands) {
 				ArrayList<Hand> scoredHands = new ArrayList<Hand>();
 
-				for (String s : hands) {
+				for (String s : hands)
 					scoredHands.add(new Hand(s));
-				}
 
 				int maxscore = scoredHands.stream().map(h -> h.getScore()).max(Comparator.naturalOrder()).get();
 				return scoredHands.stream().filter(h -> h.getScore() == maxscore).map(h -> h.getInput())

exercises/poker/src/main/java/Poker.java

 import java.util.List;
-
 import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 
 public class Poker {
-
 	public static List<String> bestHands(List<String> hands) {
-		{
 			throw new NotImplementedException();
-		}
 	}
 }

exercises/poker/src/test/java/PokerTest.java

 public class PokerTest
 {
     @Test
-    public void OneHand()
-    {
+    public void oneHand() {
         final String hand = "4S 5S 7H 8D JC";
         assertEquals(Arrays.asList(hand),Poker.bestHands(Arrays.asList(hand)));
     }
 
     @Test
     @Ignore
-    public void NothingVsOnePair()
-    {
+    public void nothingVsOnePair() {
         final String nothing = "4S 5H 6S 8D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
         assertEquals(Arrays.asList(pairOf4), Poker.bestHands(Arrays.asList(nothing, pairOf4)));
 
     @Test
     @Ignore
-    public void TwoPairs()
-    {
+    public void twoPairs() {
         final String pairOf2 = "4S 2H 6S 2D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
         assertEquals(Arrays.asList(pairOf4), Poker.bestHands(Arrays.asList(pairOf2,pairOf4)));
 
     @Test
     @Ignore
-    public void OnePairVsDoublePair()
-    {
+    public void onePairVsDoublePair() {
         final String pairOf8 = "2S 8H 6S 8D JH";
         final String doublePair = "4S 5H 4S 8D 5H";
         assertEquals(Arrays.asList(doublePair), Poker.bestHands(Arrays.asList(pairOf8, doublePair)));
 
     @Test
     @Ignore
-    public void TwoDoublePairs()
-    {
+    public void twoDoublePairs() {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String doublePair4And5 = "4S 5H 4S 8D 5H";
         assertEquals(Arrays.asList(doublePair2And8), Poker.bestHands(Arrays.asList(doublePair2And8, doublePair4And5)));
 
     @Test
     @Ignore
-    public void DoublePairVsThree()
-    {
+    public void doublePairVsThree() {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String threeOf4 = "4S 5H 4S 8D 4H";
         assertEquals(Arrays.asList(threeOf4 ), Poker.bestHands(Arrays.asList(doublePair2And8, threeOf4 )));
 
     @Test
     @Ignore
-    public void TwoThrees()
-    {
+    public void twoThrees() {
         final String threeOf2 = "2S 2H 2S 8D JH";
         final String threeOf1 = "4S AH AS 8D AH";
         assertEquals(Arrays.asList(threeOf1), Poker.bestHands(Arrays.asList(threeOf2, threeOf1)));
 
     @Test
     @Ignore
-    public void ThreeVsStraight()
-    {
+    public void threeVsStraight() {
         final String threeOf4 = "4S 5H 4S 8D 4H";
         final String straight = "3S 4H 2S 6D 5H";
         assertEquals(Arrays.asList(straight), Poker.bestHands(Arrays.asList(threeOf4, straight )));
 
     @Test
     @Ignore
-    public void TwoStraights()
-    {
+    public void twoStraights() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String straightTo9 = "5S 7H 8S 9D 6H";
         assertEquals(Arrays.asList(straightTo9 ), Poker.bestHands(Arrays.asList(straightTo8, straightTo9 )));
 
     @Test
     @Ignore
-    public void StraightVsFlush()
-    {
+    public void straightVsFlush() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
         assertEquals(Arrays.asList(flushTo7 ), Poker.bestHands(Arrays.asList(straightTo8, flushTo7 )));
 
     @Test
     @Ignore
-    public void TwoFlushes()
-    {
+    public void twoFlushes() {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
         assertEquals(Arrays.asList(flushTo8), Poker.bestHands(Arrays.asList(flushTo8, flushTo7)));
 
     @Test
     @Ignore
-    public void FlushVsFull()
-    {
+    public void flushVsFull() {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String full = "4S 5H 4S 5D 4H";
         assertEquals(Arrays.asList(full ), Poker.bestHands(Arrays.asList(full, flushTo8)));
 
     @Test
     @Ignore
-    public void TwoFulls()
-    {
+    public void twoFulls() {
         final String fullOf4By9 = "4H 4S 4D 9S 9D";
         final String fullOf5By8 = "5H 5S 5D 8S 8D";
         assertEquals(Arrays.asList(fullOf5By8 ), Poker.bestHands(Arrays.asList(fullOf4By9, fullOf5By8)));
 
     @Test
     @Ignore
-    public void FullVsSquare()
-    {
+    public void fullVsSquare() {
         final String full = "4S 5H 4S 5D 4H";
         final String squareOf3 = "3S 3H 2S 3D 3H";
         assertEquals(Arrays.asList(squareOf3 ), Poker.bestHands(Arrays.asList(full, squareOf3 )));
 
     @Test
     @Ignore
-    public void TwoSquares()
-    {
+    public void twoSquares() {
         final String squareOf2 = "2S 2H 2S 8D 2H";
         final String squareOf5 = "4S 5H 5S 5D 5H";
         assertEquals(Arrays.asList(squareOf5), Poker.bestHands(Arrays.asList(squareOf2, squareOf5)));
 
     @Test
     @Ignore
-    public void SquareVsStraightFlush()
-    {
+    public void squareVsStraightFlush() {
         final String squareOf5 = "4S 5H 5S 5D 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
         assertEquals(Arrays.asList(straightFlushTo9 ), Poker.bestHands(Arrays.asList(squareOf5, straightFlushTo9 )));
 
     @Test
     @Ignore
-    public void TwoStraightFlushes()
-    {
+    public void twoStraightFlushes() {
         final String straightFlushTo8 = "4H 6H 7H 8H 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
         assertEquals(Arrays.asList(straightFlushTo9 ), Poker.bestHands(Arrays.asList(straightFlushTo8, straightFlushTo9)));
 
     @Test
     @Ignore
-    public void ThreeHandWithTie()
-    {
+    public void threeHandWithTie() {
         final String spadeStraightTo9 = "9S 8S 7S 6S 5S";
         final String diamondStraightTo9 = "9D 8D 7D 6D 5D";
         final String threeOf4 = "4D 4S 4H QS KS";
 
     @Test
     @Ignore
-    public void StraightTo5AgainstAPairOfJacks()
-    {
+    public void straightTo5AgainstAPairOfJacks() {
         final String straightTo5 = "2S 4D 5C 3S AS";
         final String twoJacks = "JD 8D 7D JC 5D";
         assertEquals(Arrays.asList(straightTo5), Poker.bestHands(Arrays.asList(straightTo5, twoJacks)));