ClassCastException异常在Java错误对象[]为String []

Question

我得到的错误：

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String; 
at Book.Organizer.Desk.RubCol.BookMainKeeper.main(BookMainKeeper.java:25) 

我不知道如何解决这个问题。任何人都可以通过告诉我我做错了什么来帮助我吗？

主要（BookMainKeeper类）：

public class BookMainKeeper { 

/** 
* @param args 
*/ 
public static void main(String[] args) { 

    BagInterface<String> shelf1 = new pileBooks<String>(); 
    BagInterface<String> shelf2 = new pileBooks<String>(); 
    BagInterface<String> shelf3 = new pileBooks<String>(); 

    shelf1.add("Java 3rd Edition"); 
    shelf1.add("Pre-Calculus 2nd Edition"); 
    shelf1.add("Lava World"); 

    String[] check = shelf2.toArray(); 

    System.out.println(shelf2.toArray()); 

}} 

pileBooks类使用BagInterface：在pileBooks类使用

public class pileBooks<T> implements BagInterface<T> { 

private final T[] bag; 
private static final int DEFAULT_CAPACITY = 25; 
private int numberOfEntries; 

/** Creates an empty bag whose initial capacity is 25. */ 
public pileBooks() 
{ 
    this(DEFAULT_CAPACITY); 
} // end default constructor 

/** Creates an empty bag having a given initial capacity. 
@param capacity the integer capacity desired */ 
public pileBooks(int capacity) 
{ 
    numberOfEntries = 0; 
    // the cast is safe because the new array contains null entries 
    @SuppressWarnings("unchecked") 
    T[] tempBag = (T[])new Object[capacity]; // unchecked cast 
    bag = tempBag; 
} // end constructor 

/**gets the current size of the bag 
* @return numberOfEntries 
*/ 
public int getCurrentSize() { 
    return numberOfEntries; 
} 

/** Sees whether this bag is full. 
    @return true if this bag is full, or false if not */ 
public boolean isFull() 
{ 
    return numberOfEntries == bag.length; 
} // end isFull 

/**It checks if the bag is empty or not 
* @return True if numberOfEntries equals 0, False if otherwise 
*/ 
public boolean isEmpty() { 
    return numberOfEntries == 0; 
} 

/** Adds a new entry to this bag. 
@param newEntry the object to be added as a new entry 
@return true if the addition is successful, or false if not */ 
public boolean add(T newEntry) 
{ 
    boolean result = true; 
    if(isFull()) 
    { 
     result = false; 
    } 
    else 
    { 
     bag[numberOfEntries]= newEntry; 
     numberOfEntries++; 
    } 
    return result; 
} // end add 

/** Removes one unspecified entry from this bag, if possible. 
    @return either the removed entry, if the removal 
      was successful, or null */ 
    public T remove() 
    { 
     T result = null; 
     if(numberOfEntries>0) 
     { 
      result = bag[numberOfEntries-1]; 
      bag[numberOfEntries - 1]=null; 
      numberOfEntries--; 
     } 
     return result; 
    } // end remove 

/** Removes one occurrence of a given entry from this bag. 
    @param anEntry the entry to be removed 
    @return true if the removal was successful, or false otherwise */ 
public boolean remove(T anEntry) 
{ 
    int index = getIndexOf(anEntry); 
    T result = removeEntry(index); 
    return anEntry.equals(result); 
} // end remove 

/** 
* Removes entry by verifying it's index 
* @param index = variable to check, if it is -1, the entry was not found 
* and it will exit, if it is 0 or higher, it means it was found in the bag 
* @return if index is -1, it returns result as null 
* if index is 0 or higher, it will put bag[index] in the variable result 
* and returns result 
*/ 
protected T removeEntry(int index) { 
    T result = null; 
    int check = numberOfEntries; 
    if(index != -1) 
    { 

     while((index < numberOfEntries) && ((check-1) != numberOfEntries)){ 



      if(index == (numberOfEntries-1)) 
      { 
       result = bag[numberOfEntries-1]; 
       bag[numberOfEntries-1] = null; 
       numberOfEntries--; 
       break; 
      } 
      else 
      { 
       result = bag[index]; 
       bag[index] = bag [numberOfEntries-1]; 
       bag[numberOfEntries-1] = null; 
       numberOfEntries--; 
       break; 
      } 
     } 
    } 
    return result; 
} 



/** 
* verfifies if anEntry is inside the bag, if it is found, it assigns 
* i to the variable index 
* @param anEntry = object to search for inside the bag 
* @return index, -1 if anEntry was not found 
* whatever is contained in variable 'i' if it is found 
*/ 
private int getIndexOf(T anEntry) { 
    int index=-1; 
    for(int i=0;i<bag.length;i++) 
    { 
     if(anEntry.equals(bag[i])) 
     { 
      index = i; 
      break; 
     } 
    } 
    return index; 
} 







/** Removes all entries from this bag. */ 
public void clear() 
{ 
    while(!isEmpty()) 
     remove(); 
} // end clear 




/** Counts the number of times a given entry appears in this bag. 
@param anEntry the entry to be counted 
@return the number of times anEntry appears in the bag */ 
public int getFrequencyOf(T anEntry) 
{ 
    int counter = 0; 
    for(int index = 0; index < numberOfEntries; index++) 
    { 
     if (anEntry.equals(bag[index])) 
     { 
      counter++; 
     } 
    } 
    return counter; 
} // end getFrequencyOf 






/** Tests whether this bag contains a given entry. 
@param anEntry the entry to locate 
@return true if this bag contains anEntry, or false otherwise */ 
public boolean contains(T anEntry) 
{ 
    boolean found = false; 
    for(int index = 0; !found && (index<numberOfEntries); index++) 
    { 
     if(anEntry.equals(bag[index])) 
     { 
      found = true; 
     } 
    } 
    return found; 
} // end contains 






/** Retrieves all entries that are in this bag. 
@return a newly allocated array of all the entries in the bag */ 
public T[] toArray() 
{ 
    //the cast is safe because the new array Contains null entries 
    @SuppressWarnings("unchecked") 
    T[] result = (T[])new Object[numberOfEntries];//unchecked cast 
    for(int index=0;index < numberOfEntries; index++) 
    { 
     result[index]=bag[index]; 
    } 
    return result; 

} // end toArray 
} 

BagInterface：

//An interface that describes the operations of a bag of objects. 
public interface BagInterface<T> { 

/** Gets the current number of entries in this bag. 
@return the integer number of entries currently in the bag */ 
public int getCurrentSize(); 

/** Sees whether this bag is full. 
@return true if the bag is full, or false if not */ 
public boolean isFull(); 

/** Sees whether this bag is empty. 
@return true if the bag is empty, or false if not */ 
public boolean isEmpty(); 

/** Adds a new entry to this bag. 
@param newEntry the object to be added as a new entry 
@ return true if the addition was successful, or false if not */ 
public boolean add(T newEntry); 

/** Removes one unspecified entry from this bag, if possible. 
@return either the removed entry, if the removal was successful, or null */ 
public T remove(); 

/** Removes one occurrence of a given entry from this bag, if possible. 
@param anEntry the entry to be removed 
@return true if the removal was successful, or false if not */ 
public boolean remove(T anEntry); 

/** Removes all entries from this bag. */ 
public void clear(); 

/** Counts the number of times a given entry appears in this bag. 
@param anEntry the entry to be counted 
@return the number of times anEntry appears in the bag */ 
public int getFrequencyOf(T anEntry); 

/** Test whether this bag contains a given entry. 
@param anEntry the entry to locate 
@return true if the bag contains anEntry, or false otherwise */ 
public boolean contains(T anEntry); 

/** Creates an array of all the entries that are in this bag. 
@return a newly allocated array of all entries in the bag */ 
public T[] toArray(); 


}// end BagInterface 

Answer 1

你可以不投Object[]到String[]就像你不能投Object至String。您可能需要返回类型T的实际阵列。

如何执行此操作？一种方法是增加数组类型的toArray参数一样

public T[] toArray(Class<T> clazz) { 
    // the cast is safe because the new array Contains null entries 
    @SuppressWarnings("unchecked") 
    T[] result = (T[]) java.lang.reflect.Array.newInstance(clazz, numberOfEntries); 

或者，如果你确信数组将只包含T类型的对象，但不是它的亚型像某种T1，T2你可以得到的类型阵列由存储单元的一个阅读它像

T[] result = (T[]) java.lang.reflect.Array.newInstance(
     bag[0].getClass(), numberOfEntries); 

，但我要说的是第一种方式比较好，因为它让你创建所需类型的数组，并消除风险，你将创造某种T1的阵列键入而不是T。

Answer 2

你应该把它保存到一个对象数组，而不是一个String数组：

Object[] check = shelf1.toArray(); 

System.out.println(check[1].toString()); 
System.out.println(check[2].toString()); 
System.out.println(check[3].toString()); 

打印：

Java 3rd Edition 
Pre-Calculus 2nd Edition 
Lava World 

check是对象的数组。 Object类是所有类的父类，包括String。它在运行时检查，这就是为什么你的代码编译，但在执行过程中得到一个错误。