我收到错误：
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)
我不知道如何解决这个问题。可以通过告诉我我做错了什么来帮助我吗？
Main（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());
}}
使用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
}
在PileBooks类中使用的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
答案 0 :(得分：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的风险。< / p>
答案 1 :(得分：0)
您应该将其保存到Object数组中，而不是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。它在运行时检查，这就是你的代码编译的原因，但在执行过程中会出错。