Question

第一次在这里问问。我正在做一个AVLTree泛型，Node中有一个方法给我一个Iterator，它返回一个Object数组。问题是，当我尝试使用我的一个非泛型类的对象获取该数组时，它会将此发送给我。

线程“main”java.lang.ClassCastException中的异常：[LestructuraDeDatos.NodoAVL;无法转换为[Lmundo.Categoria;

这是节点类

public class NodoAVL <T extends Comparable <T>>
{
//--------------------------------------------------------------------------------------------
//Atributos
//--------------------------------------------------------------------------------------------

private NodoAVL<T> izquierdo;

private NodoAVL<T> derecho;

private T elemento;

private String criterio;

//--------------------------------------------------------------------------------------------
//Constructor
//--------------------------------------------------------------------------------------------

public NodoAVL(T elem, String crit)
{
    elemento = elem;
    izquierdo = null;
    derecho = null;
    criterio = crit;
}

//--------------------------------------------------------------------------------------------
//Metodos
//--------------------------------------------------------------------------------------------
public NodoAVL<T> getIzquierdo() {
    return izquierdo;
}
public void setIzquierdo(NodoAVL<T> izquierdo) {
    this.izquierdo = izquierdo;
}
public NodoAVL<T> getDerecho() {
    return derecho;
}
public void setDerecho(NodoAVL<T> derecho) {
    this.derecho = derecho;
}
public String getCriterio() {
    return criterio;
}
public void setCriterio(String criterio) {
    this.criterio = criterio;
}
public boolean soyHoja() 
{
    if(izquierdo == null && derecho == null)
    {
        return true;
    }

    return false;
}
public T getElemento() {
    return elemento;
}
public void setElemento(T elemento) {
    this.elemento = elemento;
}

public void agregarElemento(T elemento, String Crit)
{
    //Buscarlo antes de agregar, no puede haber iguales en el arbol
    if(buscarElemento(Crit)==null)
    if(soyHoja())
    {
        if(elemento.compareTo(this.elemento)>0)
        {
            NodoAVL<T> nuevo = new NodoAVL<T>(elemento, Crit);
            setDerecho(nuevo);
        }else if(elemento.compareTo(this.elemento)<0)
        {
            NodoAVL<T> nuevo = new NodoAVL<T>(elemento, Crit);
            setIzquierdo(nuevo);
        }
    }else
    {
        NodoAVL<T> nuevo = new NodoAVL<T>(elemento,Crit);
        if(this.elemento.compareTo(elemento)>0 && izquierdo == null)
        {
            izquierdo = nuevo;
        }
        else if(this.elemento.compareTo(elemento)>0)
        {
            izquierdo.agregarElemento(elemento,Crit);
        }
        else if(this.elemento.compareTo(elemento)<0 && derecho == null)
        {
            derecho = nuevo;
        }
        else if( this.elemento.compareTo(elemento)<0)
        {
             derecho.agregarElemento(elemento, Crit);
        }
    }
    balanciarSubArbol();

}

public NodoAVL<T> rotarIzq(NodoAVL<T> rotar)
{
    NodoAVL<T> temp = rotar.derecho;
    rotar.setDerecho(temp.izquierdo);
    temp.setIzquierdo(rotar);
    return temp;
}

public NodoAVL<T> rotarDer(NodoAVL<T> rotar)
{
    NodoAVL<T> temp = rotar.izquierdo;
    rotar.setIzquierdo(temp.derecho);
    temp.setDerecho(rotar);
    return temp;
}

public int darBalance()
{
    if(soyHoja())
    {
        return 0;
    }
    else 
    {
        int izq = (izquierdo == null)?0:izquierdo.darAltura();
        int der = (derecho == null)? 0 :derecho.darAltura();
        return (izq - der);
    }
}
public NodoAVL<T> dobleRotacionDerIzq(NodoAVL<T> nodo)
{
    nodo.setDerecho(rotarDer(nodo.getDerecho()));
    return rotarIzq(nodo);
}

public NodoAVL<T> dobleRotacionIzqDer(NodoAVL<T> nodo)
{
    nodo.setIzquierdo(rotarIzq(nodo.getIzquierdo()));
    return rotarDer(nodo);
}

public void balanciarSubArbol()
{
    int valor = darBalance();
    if(-2==valor || valor==2)
    {
        if(valor<0 && derecho.darBalance()<0)
        {
            if(derecho.darBalance()<-2)
            {
                derecho.balanciarSubArbol();
            }else
            {
                rotarIzq(this);
            }
        }else if(valor<0 && derecho.darBalance()>0)
        {
            if(derecho.darBalance()>2)
            {
                derecho.balanciarSubArbol();
            }else
            {
                dobleRotacionDerIzq(this);
            }
        }else if(valor>0 && izquierdo.darBalance()>0)
        {
            if(izquierdo.darBalance()>2)
            {
                izquierdo.balanciarSubArbol();
            }else
            {
                rotarDer(this);
            }
        }else if(valor>0 && izquierdo.darBalance()<0)
        {
            if(izquierdo.darBalance()<-2)
            {
                izquierdo.balanciarSubArbol();
            }else
            {
                dobleRotacionIzqDer(this);
            }
        }
    }                       
}

public NodoAVL<T> eliminarElemento(T elemento)
{

    if(soyHoja() && this.elemento==elemento)
    {
        return null;
    }else if(soyHoja() && this.elemento!=elemento)
    {
        return this;
    }
    else
    {
        if(this.elemento.compareTo(elemento)==0)
        {
            if(izquierdo != null && derecho != null)
            {
                NodoAVL<T> temp =  derecho;
                izquierdo.setDerecho(temp.getIzquierdo());
                temp.setIzquierdo(izquierdo);
                return temp;
            }
            else if(izquierdo != null)
            {
                return izquierdo;
            }
            else
            {
                return derecho;
            }
        }
        else if(this.elemento.compareTo(elemento)>0)
        {
            izquierdo = izquierdo.eliminarElemento(elemento);
            return this;

        }
        else if(this.elemento.compareTo(elemento)<0)
        {
            derecho = derecho.eliminarElemento(elemento);
            return this;
        }
        balanciarSubArbol();
        return this;
    }
}

public T buscarElemento(String criterio)
{
    if(this.criterio.equalsIgnoreCase(criterio))
    {
        return this.elemento;
    }
    else
    {
        T izq = (izquierdo != null)?izquierdo.buscarElemento(criterio):null;
        T der = (derecho != null) ? derecho.buscarElemento(criterio):null;

        if(izq != null)
        {
            return izq;
        }else if(der != null)
        {
            return der;
        }
    }
    return null;
}

public IteradorAVL<T> darElementos()
{
    IteradorAVL<T> ite = new IteradorAVL<T> (this);
    return ite;

}

public int darPeso()
{
    if(soyHoja())
    {
        return 1;
    }else
    {
        int izq = (izquierdo == null)? 0: izquierdo.darPeso();
        int der = (derecho == null) ? 0:derecho.darPeso();

        return (izq+der+1);
    }
}

public int darAltura()
{
    if(soyHoja())
    {
        return 1;
    }
    else
    {
        int izq = ( izquierdo == null ) ? 0 : izquierdo.darAltura( );
        int der = ( derecho == null ) ? 0 : derecho.darAltura( );
        return(izq>der || izq == der)?izq+1:der+1;
    }
}
}

和迭代器类

public class IteradorAVL<T extends Comparable <T>> implements Iterator<T>{


//--------------------------------------------------------------------------------------------
//Atributos
//--------------------------------------------------------------------------------------------  
private NodoAVL<T> arbolitoAVL;

private Object [] elementos;

private int posActual;

private int total;

private Stack<NodoAVL> nodePath = new Stack<NodoAVL>();

//--------------------------------------------------------------------------------------------
//Constructor
//--------------------------------------------------------------------------------------------


public IteradorAVL ( NodoAVL <T> nodo)
{
    arbolitoAVL = nodo;
    posActual = 0;
    total = nodo.darPeso();
    elementos = new NodoAVL[total];
}

//--------------------------------------------------------------------------------------------
//Metodos
//--------------------------------------------------------------------------------------------

@Override
public boolean hasNext() 
{
    return(total>posActual)?true:false; 
}

@Override
public T next() {

    T siguienteT =null;
    NodoAVL<T> respuesta = arbolitoAVL;

    //Guardo el nodo actual en la lista


    //Avancce
        while (arbolitoAVL != null) {
            nodePath.push(arbolitoAVL);
            elementos[posActual] = arbolitoAVL;
            arbolitoAVL = arbolitoAVL.getIzquierdo();
            posActual++;
        }

        if (!nodePath.isEmpty()) {
            arbolitoAVL = nodePath.pop();
            posActual++;
            elementos[posActual] = arbolitoAVL;
            siguienteT = arbolitoAVL.getElemento();

            arbolitoAVL = arbolitoAVL.getDerecho();
        }
    return siguienteT;

}


@Override
public void remove() {
    // TODO Auto-generated method stub

}

public Object[] darArreglo()
{
    return elementos; 
}

Answer 1

发生ClassCastException的原因只是您试图将一个类的对象类型转换为另一个类的不兼容的对象。

示例：

Object i = Integer.valueOf(42);
String s = (String)i;            // ClassCastException thrown here.

ClassCastexception Java泛型类型

1 个答案: