如何将列表类型转换为双精度数组或整数数组？

Question

So I want to sort a deck of cards. The constructor DeckOfCards sets up and shuffles a deck of cards. But the cards are stored in a list of type List where Card type belongs to Card class. After calling DeckOfCards I should ask the user what kind of sorting algorithm should be used to sort the deck of cards. I have just included Insertion sort at the end for example. But the insertionsort function takes in a double array. So I need to convert List list to a double array. How can I do it?

Code:

import java.util.List;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

// class to represent a Card in a deck of cards
class Card 
{    
public static enum Face { Ace, Deuce, Three, Four, Five, Six,
  Seven, Eight, Nine, Ten, Jack, Queen, King  };
public static enum Suit { Clubs, Diamonds, Hearts, Spades };

private final Face face; // face of card
private final Suit suit; // suit of card

// two-argument constructor
public Card( Face cardFace, Suit cardSuit ) 
{   
   face = cardFace; // initialize face of card
   suit = cardSuit; // initialize suit of card
} // end two-argument Card constructor

// return face of the card
public Face getFace() 
{ 
  return face; 
} // end method getFace

// return suit of Card
public Suit getSuit() 
{ 
  return suit; 
} // end method getSuit

// return String representation of Card
public String toString()
{
   return String.format( "%s of %s", face, suit );
} // end method toString
} // end class Card

// class DeckOfCards declaration
public class DeckOfCards 
{
private List<Card> list; // declare List that will store Cards

// set up deck of Cards and shuffle
public DeckOfCards()
{
  Card[] deck = new Card[ 52 ];
  int count = 0; // number of cards

  // populate deck with Card objects
  for ( Card.Suit suit : Card.Suit.values() )  
  {
     for ( Card.Face face : Card.Face.values() )   
     {
        deck[ count ] = new Card( face, suit );
        count++;
     } // end for
  } // end for

  list = Arrays.asList( deck ); // get List
  Collections.shuffle( list );  // shuffle deck
} // end DeckOfCards constructor

// output deck
public void printCards()
{
  // display 52 cards in two columns
  for ( int i = 0; i < list.size(); i++ )
     System.out.printf( "%-20s%s", list.get( i ),
        ( ( i + 1 ) % 2 == 0 ) ? "\n" : "" );
} // end method printCards

public static void main( String args[] )
{
  DeckOfCards cards = new DeckOfCards();
  cards.printCards();
  //add code here to take input from user and sort
  int a;
  System.out.println("\nSort the deck of cards");
  System.out.println("\nEnter your choice: \n1.Selection Sort \n2.Insertion Sort 
\n3.Merge       Sort\n");
  //take input
  Scanner reader = new Scanner(System.in);
  a=reader.nextInt();
  switch(a)
  {
    case 1:
        //call Selection sort
        break;
    case 2:
        //call Insertion sort
        break;
    case 3:
        //call Merge sort
        break;
  }
 } // end main  

//Insertion sort

} // end class DeckOfCards
public class InsertionSort {
/** The method for sorting the numbers */
public static void insertionSort(double[] list) {
for (int i = 1; i < list.length; i++) {
  /** insert list[i] into a sorted sublist list[0..i-1] so that
       list[0..i] is sorted. */
  double currentElement = list[i];
  int k;
  for (k = i - 1; k >= 0 && list[k] > currentElement; k--) {
    list[k + 1] = list[k];
  }

  // Insert the current element into list[k+1]
  list[k + 1] = currentElement;
}
}
}

Answer 1

If you wanted to convert a list of Card objects, ie List<Card> list you could easily change it to a Card array (ie Card[] ) using a method provided by List itself called toArray

However, you have some confusion in what you're asking. You are expecting that a method that expects an array of double suddenly magically knows how to treat objects of type Card . How can a Card suddenly behave like a double precision number?

You should change the method insertionSort() first (which you probably copied from somewhere without trying to understand what its doing) to take a Card[] array first, and then modify what its doing internally so that the comparison happens on the properties of the Card object rather than the double primitive.

On the other hand, you might be interested to know that Java already provides sorting functions through the Arrays class. You can have a look at the function Arrays.sort() . However you still need to implement the Comparable interface so that Java knows how to sort the array, it doesn't know how your Card objects should be sorted (by face? by suit? in which order? Java doesn't know how to play cards), so you need to make your Card objects implement Comparable and have a compareTo() method which helps Java decide which Card instance comes before which. You can use the same approach if you still want to implement the sorting yourself and change the method insertionSort() to take an array of Comparable items and inside it you call compareTo() to know which item comes before what.

Answer 2

If I understood right, you want to sort your Cards with different algorithms. And your implementation of algorithms accept only double array.

Two question you need to think about:

• The rule of Card comparison, eg Heart Ace > Diamonds Ace?

• if all sortings are comparison sort algorithm?

If the answer of the 2nd question is: YES

I suggest you stopping thinking about converting Card Array type to double array. Instead, making your all algorithm implementation more generic, for example, accept Comparable[] arr array, or even Card[] arr . Then make your Card class implement Comparable interface. Implement your card comparison rule in compareTo(Card c) method.