I have another assignment due for an advance java programming class that I do not understand how to do. I don\'t know how to implement the comparable interface and sort the cards from lowest to highest based on suit within rank. And I also dont understand how I am suppose to add a static nested class that implements the comparator interface and then sort the cards lowest to highest based on rank within a suit. Then I have to add the different buttons and I am not sure which class that these buttons are to be placed in. The buttons I have to add are: Deal Button, Fish Sort Button, Spades Sort Button, and a Reverse Toggle Button. The description for each button is in the instructions below: Program 4 – Sorting with nested classes and lambda expressions This program is a bit different from our others. Just like the last program, you will start with the project that is attached to this assignment. Remember to rename the project. You will lose points if you do not. Also, remember that you need to submit an Eclipse project, not just Java files. You will lose points there as well. The main point of the exercise is to demonstrate your ability to use various types of nested classes. Of course, sorting is important as well, but you don’t really need to do much more than create the class that does the comparison. In general, I like giving you some latitude in how you design and implement your projects. However, for this assignment, each piece is very specific as to how I want you to implement things. There are a number of parts to this program. Make certain you accomplish the two additions to the Card class early-on since much of the rest of your program will depend on that work. The requirements: Properly named project, good code (avoid redundancy), nice UI, etc. (20 pts) Implement the Comparable interface in the Card class. (15 pts) Sort the cards lowest to highest based on suit within rank, e.g. 2 clubs 2 diamonds 2 hearts 2 spades 3 clubs 3 diamonds etc. Add a static nested class to the Card class that implements the Comparator interface. (15 pts) Sort the cards lowest to highest based on rank within suit, e.g. 2 clubs 3 clubs 4 clubs 5 clubs etc. In the UI, add the following to your interface. Deal Button (10 pts) Implement the Deal action handler using an inner class (not local). You may want to pull some of the code from the show method that is already there. Or better, put the common code into a class and call it. Fish Sort Button (15 pts) Sort the code in a way that would be useful playing Go Fish. I.e. with all of the cards grouped together. Implement the action handler using a lambda expression in the UI. The code in the lambda expression should depend on the Card class for the actual sorting (i.e. the natural order). It must not call any other method in the UI class. Spades Sort Button (15 pts) Order the cards in such a way that they would be useful playing Spades; i.e. with the cards sorted by rank within suit and the suits in the order pro.

1. I have another assignment due for an advance java programming class that I do not understand
how to do. I don't know how to implement the comparable interface and sort the cards from
lowest to highest based on suit within rank. And I also dont understand how I am suppose to add
a static nested class that implements the comparator interface and then sort the cards lowest to
highest based on rank within a suit. Then I have to add the different buttons and I am not sure
which class that these buttons are to be placed in. The buttons I have to add are: Deal Button,
Fish Sort Button, Spades Sort Button, and a Reverse Toggle Button. The description for each
button is in the instructions below:
Program 4 – Sorting with nested classes and lambda expressions
This program is a bit different from our others. Just like the last program, you will start with the
project that is attached to this assignment. Remember to rename the project. You will lose points
if you do not. Also, remember that you need to submit an Eclipse project, not just Java files. You
will lose points there as well.
The main point of the exercise is to demonstrate your ability to use various types of nested
classes. Of course, sorting is important as well, but you don’t really need to do much more than
create the class that does the comparison. In general, I like giving you some latitude in how you
design and implement your projects. However, for this assignment, each piece is very specific as
to how I want you to implement things. There are a number of parts to this program. Make
certain you accomplish the two additions to the Card class early-on since much of the rest of
your program will depend on that work.
The requirements:
Properly named project, good code (avoid redundancy), nice UI, etc. (20 pts)
Implement the Comparable interface in the Card class. (15 pts)
Sort the cards lowest to highest based on suit within rank, e.g.
2 clubs
2 diamonds
2 hearts
2 spades
3 clubs
3 diamonds
etc.
Add a static nested class to the Card class that implements the Comparator interface. (15 pts)
Sort the cards lowest to highest based on rank within suit, e.g.
2 clubs
3 clubs

2. 4 clubs
5 clubs
etc.
In the UI, add the following to your interface.
Deal Button (10 pts)
Implement the Deal action handler using an inner class (not local). You may want to pull some
of the code from the show method that is already there. Or better, put the common code into a
class and call it.
Fish Sort Button (15 pts)
Sort the code in a way that would be useful playing Go Fish. I.e. with all of the cards grouped
together. Implement the action handler using a lambda expression in the UI. The code in the
lambda expression should depend on the Card class for the actual sorting (i.e. the natural order).
It must not call any other method in the UI class.
Spades Sort Button (15 pts)
Order the cards in such a way that they would be useful playing Spades; i.e. with the cards sorted
by rank within suit and the suits in the order provided by the nested class in #2 above. You
actually want to reverse this sort before displaying. Implement the action handler using an
anonymous class in the UI. The code in the anonymous class should depend on the Card class for
the actual sorting; i.e. the Comparator that you added above.
Reverse Toggle Button (10 pts)
If this toggle is checked, the order of the sort is reversed, e.g.
AS, AH, 8H, 8D, 8C
becomes
8C, 8D, 8H, AH, AS
Clicking the toggle should have no effect. However, pushing the Spades Sort buttons should
result in a reversed ordering if the toggle button is selected. Unchecking the button and pushing
Spades Sort should result in the original sort. Note that this does not merely reverse the order; if
the button is checked pushing the SpadesSort button any number of times should always result in
the same ordering. You do not have to apply this to the Fish Sort, but see below. This action can
be accomplished in a number of ways. Some are simpler than others, some more efficient.
Extra Credit
Fish Sort and Reverse Toggle (3 pts)
Find a means to reverse sort that does not require reversing after sorting for the Fish Sort. That
is, the sort itself should do the reverse. Do not add code outside the lambda expression. It should
check whether the toggle button is checked and act appropriately. You must keep the Fish Sort
action in a lambda expression. This may take some research.

3. Bridge Sort Button (10 pts)
This sort is similar to the Spade sort where all of the cards are grouped by suit. However, the
groups of suits should then be sorted by how many are in each suit. E.g. if there are 2 spades, 5
hearts, 3 diamonds and 3 clubs, the hearts would be first, followed by the diamonds, clubs and
spades in that order. This will take some thinking on your part; it isn’t a simple problem. You
can do this in an inner class, anonymous class or even a static method in the Card class…or
something else you think of.
Turn your program in by zipping your project directory (or export it from Eclipse) and submit it
to D2L. Remember, the Eclipse project needs a new name that contains your last name. Do not
leave it the same as it is now. You may leave the package names just as they are.
Remember, I will be grading each of these on whether they work and whether you did each as
specified. Note that if you were really developing something like this you might opt for
everything in anonymous classes, or lambda expressions, or inner classes. However, I want to
see that you can do all of these, and do them where they are specified, so follow the instructions
carefully.
OK, you are all adding up the points, and yes, 113 would be possible if everything is exactly
correct.
We have some classes to start off that are done for us, now we have to do what the instructions
say above. The classes are as follows that are done for us:
IN THE CARDS.MODEL PACKAGE ARE THE FOLLOWING CLASSES:
Card.java class:
import java.util.Comparator;
public class Card implements Comparable
{
public final int SUIT_SIZE = 13;
public static final int CLUB = 0;
public static final int DIAMOND = 1;
public static final int HEART = 2;
public static final int SPADE = 3;
private int suit; // clubs = 0, diamonds = 1, hearts = 2, spades = 3
private int rank; // deuce = 0, three = 1, four = 2, ..., king = 11, ace = 12
private boolean isFaceUp = true; // not used for our program
// create a new card based on integer 0 = 2C, 1 = 3C, ..., 51 = AS
public Card(int card) {
rank = card % SUIT_SIZE;

4. suit = card / SUIT_SIZE;
}
public int getRank() {
return rank;
}
public int getSuit() {
return suit;
}
public boolean isFaceUp()
{
return isFaceUp;
}
public void flip()
{
isFaceUp = !isFaceUp;
}
// represent cards like "2H", "9C", "JS", "AD"
public String toString() {
String ranks = "23456789TJQKA";
String suits = "CDHS";
return ranks.charAt(rank) + "" + suits.charAt(suit);
}
@Override
public int compareTo(Card o) {
// TODO Auto-generated method stub
return 0;
}
}
Deck.java class:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
public class Deck implements Iterator
{
// list of cards still in the deck

5. private ArrayList deck = new ArrayList<>();
// list of cards being used
private ArrayList used = new ArrayList<>();
// used to shuffle the deck
Random dealer = new Random();
private ArrayList myCardList;
private int myIndex;
public Deck()
{
// builds the deck
for (int i = 0; i < 52; i++) {
deck.add(new Card(i));
}
}
public ArrayList deal(int handSize)
{
ArrayList hand = new ArrayList<>();
// do we need more cards? If so, shuffle
if (deck.size() < handSize) {
shuffle();
}
for (int i=0; i < handSize; i++) {
Card next = deck.remove(deck.size() - 1);
hand.add(next);
used.add(next);
}
return hand;
}
public void shuffle()
{
deck.addAll(used);

6. for (int i=0; i < deck.size() - 1; i++) {
int swap = dealer.nextInt(deck.size() - i) + i;
if (swap != i) {
Card tmp1 = deck.get(i);
Card tmp2 = deck.get(swap);
deck.set(i, tmp2);
deck.set(swap, tmp1);
}
}
}
// just used for testing
public static void showHand(ArrayList hand)
{
for (Card c : hand) {
System.out.printf(" %s",c);
}
System.out.println();
}
// just used for testing
public static void main(String args[])
{
Deck deck = new Deck();
deck.shuffle();
ArrayList hand = deck.deal(5);
showHand(hand);
deck.shuffle();
hand = deck.deal(5);
showHand(hand);
}
@Override
public boolean hasNext() {
return myIndex < myCardList.size();
}
@Override

7. public Object next()
{
Card card = (Card)myCardList.get(myIndex);
return card;
}
}
IN THE CARDS.VIEW PACKAGE, THE TWO CLASSES ARE AS FOLLOWS:
HandDisplayWindow.java class:
import edu.trident.lanigan.cpt237.cards.model.Card;
import edu.trident.lanigan.cpt237.cards.model.Deck;
import javafx.geometry.Orientation;
import javafx.scene.Scene;
import javafx.scene.control.ListCell;
import javafx.scene.control.ListView;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;
public class HandDisplayWindow
{
private final int SUIT_SIZE = 13;
private Image[] cardImages = new Image[4*SUIT_SIZE];
private Stage myStage;
ListView listView = new ListView<>();
Deck deck;
int handSize;
public HandDisplayWindow(Stage stage, int size)
{
handSize = size;
myStage = stage;
myStage.setTitle("Card Hand");
BorderPane pane = new BorderPane();
Scene scene = new Scene(pane);
myStage.setScene(scene);
listView.setCellFactory(param -> new ListCell() {

8. private ImageView imageView = new ImageView();
@Override
public void updateItem(Card card, boolean empty)
{
super.updateItem(card, empty);
if (empty) {
setGraphic(null);
} else {
// determine the index of the card
int index = card.getSuit() * SUIT_SIZE + card.getRank();
imageView.setImage(cardImages[index]);
imageView.setPreserveRatio(true);
imageView.setFitWidth(50);
setGraphic(imageView);
}
}
});
listView.setOrientation(Orientation.HORIZONTAL);
pane.setCenter(listView);
myStage.setHeight(150);
myStage.setWidth(68 * handSize);
loadImages();
}
private void loadImages()
{
String resourceDir = "file:resources/cardspng/";
char[] suits = { 'c', 'd', 'h', 's' };
char[] rank = { '2', '3', '4', '5', '6', '7', '8', '9', '0', 'j', 'q', 'k', 'a' };
int slot = 0;
// load images
for (int s = 0; s < 4; s++) {
for (int r = 0; r < SUIT_SIZE; r++) {
String path = resourceDir + suits[s] + rank[r] + ".png";
cardImages[slot] = new Image(path);
slot++;
}

9. }
}
public void show(Deck deck)
{
this.deck = deck;
if (deck != null)
listView.getItems().setAll(deck.deal(handSize));
myStage.show();
}
}
MainApplication.java class:
import edu.trident.lanigan.cpt237.cards.model.Deck;
import javafx.application.Application;
import javafx.stage.Stage;
public class MainApplication extends Application
{
@Override
public void start(Stage primaryStage) throws Exception
{
HandDisplayWindow ui = new HandDisplayWindow(primaryStage, 13);
Deck deck = new Deck();
deck.shuffle();
ui.show(deck);
}
public static void main(String[] args)
{
Application.launch(args);
}
}
Solution
import java.util.Comparator;
public class Card implements Comparable
{
public final int SUIT_SIZE = 13;

10. public static final int CLUB = 0;
public static final int DIAMOND = 1;
public static final int HEART = 2;
public static final int SPADE = 3;
private int suit; // clubs = 0, diamonds = 1, hearts = 2, spades = 3
private int rank; // deuce = 0, three = 1, four = 2, ..., king = 11, ace = 12
private boolean isFaceUp = true; // not used for our program
// create a new card based on integer 0 = 2C, 1 = 3C, ..., 51 = AS
public Card(int card) {
rank = card % SUIT_SIZE;
suit = card / SUIT_SIZE;
}
public int getRank() {
return rank;
}
public int getSuit() {
return suit;
}
public boolean isFaceUp()
{
return isFaceUp;
}
public void flip()
{
isFaceUp = !isFaceUp;
}
// represent cards like "2H", "9C", "JS", "AD"
public String toString() {
String ranks = "23456789TJQKA";
String suits = "CDHS";
return ranks.charAt(rank) + "" + suits.charAt(suit);
}
@Override
public int compareTo(Card o) {

11. // TODO Auto-generated method stub
return 0;
}
}
Deck.java class:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
public class Deck implements Iterator
{
// list of cards still in the deck
private ArrayList deck = new ArrayList<>();
// list of cards being used
private ArrayList used = new ArrayList<>();
// used to shuffle the deck
Random dealer = new Random();
private ArrayList myCardList;
private int myIndex;
public Deck()
{
// builds the deck
for (int i = 0; i < 52; i++) {
deck.add(new Card(i));
}
}
public ArrayList deal(int handSize)
{
ArrayList hand = new ArrayList<>();
// do we need more cards? If so, shuffle
if (deck.size() < handSize) {
shuffle();
}
for (int i=0; i < handSize; i++) {

12. Card next = deck.remove(deck.size() - 1);
hand.add(next);
used.add(next);
}
return hand;
}
public void shuffle()
{
deck.addAll(used);
for (int i=0; i < deck.size() - 1; i++) {
int swap = dealer.nextInt(deck.size() - i) + i;
if (swap != i) {
Card tmp1 = deck.get(i);
Card tmp2 = deck.get(swap);
deck.set(i, tmp2);
deck.set(swap, tmp1);
}
}
}
// just used for testing
public static void showHand(ArrayList hand)
{
for (Card c : hand) {
System.out.printf(" %s",c);
}
System.out.println();
}
// just used for testing
public static void main(String args[])
{
Deck deck = new Deck();
deck.shuffle();

13. ArrayList hand = deck.deal(5);
showHand(hand);
deck.shuffle();
hand = deck.deal(5);
showHand(hand);
}
@Override
public boolean hasNext() {
return myIndex < myCardList.size();
}
@Override
public Object next()
{
Card card = (Card)myCardList.get(myIndex);
return card;
}
}
import edu.trident.lanigan.cpt237.cards.model.Deck;
import javafx.application.Application;
import javafx.stage.Stage;
public class MainApplication extends Application
{
@Override
public void start(Stage primaryStage) throws Exception
{
HandDisplayWindow ui = new HandDisplayWindow(primaryStage, 13);
Deck deck = new Deck();
deck.shuffle();
ui.show(deck);
}
public static void main(String[] args)
{
Application.launch(args);
}
}