SpoiledVegetablesDeck

java.lang.Object
- studentCode.SpoiledVegetablesDeck<T>

```
public class SpoiledVegetablesDeck<T extends Critiqueable>
extends java.lang.Object
```
A data structure class that stores deep copies of any Critiqueable items that are sent to be critiqued. By having deep copies, the player's Critiqueable item does not get permanently altered in their personal library, only in this playing of the game.

A SpoiledVegetablesDeck object has a list of Critiqueable items held in an ArrayList object. It cannot be used to hold anything that doesn't implement the Critiqueable interface.

Constructor Summary

Constructors
Constructor and Description

SpoiledVegetablesDeck()
Standard constructor.

Constructors
Constructor and Description
`SpoiledVegetablesDeck()` Standard constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(T newItem)` Adds an item to the SpoiledVegetablesDeck in a very special way.
`Critiqueable[][]`	`export2Darray()` The method will return a ragged 2D structure using the Java array.
`java.util.ArrayList<java.util.ArrayList<Critiqueable>>`	`export2Darraylist()` The method will return a ragged 2D structure using the ArrayList data type - it will have references to deep copies of the Critiqueable items currently stored in the SpoiledVegetablesDeck.
`void`	`freshenUp(int fanGain)` Goes through each item in the SpoiledVegetablesDeck and adds the specified number of fans to every Critiqueable item it contains.
`void`	`rottenDown(int fanLoss)` Goes through each item in the SpoiledVegetablesDeck and deducts the specified number of fans from every Critiqueable item it contains.
`void`	`shuffle()` Shuffles the contents of the deck in the way described here.
`T`	`solitaireCritique()` The method is meant to allow the next two Critiqueable items to be critiqued against each other, and for the winner to be returned.
`void`	`sweepDeck()` Removes any Critiqueable item currently in the critique deck that have fewer than three fans left.
`java.lang.String`	`toString()` The method will return a String object containing a representation of the Critiqueable items currently held in the SpoiledVegetablesDeck, shown in order from "front to back" of the ArrayList holding the references.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - SpoiledVegetablesDeck
```
public SpoiledVegetablesDeck()
```
    Standard constructor. It needs to initialize the ArrayList object and do any other setup that you deem necessary for this class object.
- Method Detail
  - add
```
public void add(T newItem)
```
    Adds an item to the SpoiledVegetablesDeck in a very special way. The structure is double-ended; this means that the "side" to which objects are added alternates with every other item added. If things are added in the order 1,2,3,4,5 then the SpoiledVegetablesDeck would grow as the following:
       1
       2,1
       2,1,3
       4,2,1,3
       4,2,1,3,5
    It is your job to determine a good way to ensure this alternation. You can add an instance field to the class if needed in making this method work correctly.
    
    Parameters:
    
    newItem - refers to a Critiqueable item to be added to this SpoiledVegetablesDeck
  - freshenUp
```
public void freshenUp(int fanGain)
```
    Goes through each item in the SpoiledVegetablesDeck and adds the specified number of fans to every Critiqueable item it contains.
    
    Parameters:
    
    fanGain - the value to add to the number of fans
  - rottenDown
```
public void rottenDown(int fanLoss)
```
    Goes through each item in the SpoiledVegetablesDeck and deducts the specified number of fans from every Critiqueable item it contains.
    
    Parameters:
    
    fanLoss - the value to deduct from the number of fans
  - sweepDeck
```
public void sweepDeck()
```
    Removes any Critiqueable item currently in the critique deck that have fewer than three fans left.
  - shuffle
```
public void shuffle()
```
    Shuffles the contents of the deck in the way described here. The deck will be divided into two "packets" (we will call them the top half and the bottom half). The shuffled SpoiledVegetablesDeck will consist of the first card from the bottom packet, followed by the first card from the top packet, followed by the second card from the bottom packet, followed by the second card from the top packet, etc. Important: If there are an odd number of cards, the bottom packet should have one more card than the top packet and as a special situation that last card in the bottom packet should be made the first card in the shuffled deck. Remember that the top of the deck is considered to be the front of the ArrayList.
  - solitaireCritique
```
public T solitaireCritique()
```
    The method is meant to allow the next two Critiqueable items to be critiqued against each other, and for the winner to be returned.
    
    If there are no Critiqueable items in the structure, returns null.
    If there is only one Critiqueable item in the structure, it is removed and declared the winner
    Otherwise, there is a series of events that takes place. The following presents the events and the order in which the events must take place:
    1. One Critiqueable item is removed from each end of the structure and they will later be critiqued.
    2. The SpoiledVegetablesDeck is cleared of any Critiqueable items who no longer have enough fans to stay in the game.
    3. Use the freshenUp method to make it so that each Critiqueable item still in the SpoiledVegetablesDeck gets one new fan.
    4. All Critiqueable items remaining in the SpoiledVegetablesDeck have their fan counts reduced by the following rules:
    * If they have media hype of more than 100, they lose 10 fans.
    * Otherwise, if they have media hype of more than 50, they lose 5 fans.
    * Otherwise, they lose 1 fan.
    5. The winner in solitaire critiques between the two Critiqueable items removed in the first step above are determined in by two-step process; (a) if they have different media hype values, the one with the higher value wins but if they have the same media hype values then (b) the one with the larger number of fans wins. If they have the same media hype values and the same number of fans, then whichever of the two Critiqueable items came from the front of the deck wins.
    
    NOTE: The @SuppressWarnings("unchecked") indicator is to inform the compiler that even though we don't test to make sure the cast to T is valid, we are sure of our logic.
    
    Returns:
    
    reference to the winning Critiqueable item
  - export2Darray
```
public Critiqueable[][] export2Darray()
```
    The method will return a ragged 2D structure using the Java array. It will have references to deep copies of the Critiqueable items currently stored in the SpoiledVegetablesDeck. The 2D structure will have one row for each single-digit media hype value and then a row for all with higher media values followed by a row with the lower media values (the items with negative media hype). Within each row the order will be based on the "front to back" order of them in the deck's single-dimensional structure. NOTE: To build the ragged 2D structure, you'll need to read through the list of Critiqueable items once to determine how big each row will need to be and then another time to populate the ragged structure with the references to the copies of the Critiqueable items.
    
    Returns:
    
    reference to a ragged 2D structure using the java array
  - export2Darraylist
```
public java.util.ArrayList<java.util.ArrayList<Critiqueable>> export2Darraylist()
```
    The method will return a ragged 2D structure using the ArrayList data type - it will have references to deep copies of the Critiqueable items currently stored in the SpoiledVegetablesDeck. The 2D structure will have one row for each single-digit media hype value (0 through 9) and then a row for all with higher media values followed by a row with the lower media values (the items with negative media hype). Within each row the order will be based on the "front to back" order of them in the deck's single-dimensional structure. NOTE: To build this ragged 2D structure, you should only need to go through the deck once!
    
    Returns:
    
    reference to a ragged 2D structure using ArrayLists
  - toString
```
public java.lang.String toString()
```
    The method will return a String object containing a representation of the Critiqueable items currently held in the SpoiledVegetablesDeck, shown in order from "front to back" of the ArrayList holding the references.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    String representing the SpoiledVegetablesDeck

Class SpoiledVegetablesDeck<T extends Critiqueable>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SpoiledVegetablesDeck

Method Detail

add

freshenUp

rottenDown

sweepDeck

shuffle

solitaireCritique

export2Darray

export2Darraylist

toString