Problemas com Casting (eu acho)

valores.put(info[temp])

//para guardar os elementos que forem moda (independente de quantos forem);
  Vector<Object> modas = new Vector<Object>();

  //para guardar temporariamente os dados da lista
  Vector<Object> dados = new Vector<Object>();

  //copiei do seu código: posição do primeiro elemento
  int temp = uso;

  //para guardar a maior quantidade
  int maior = -1;

  //transfere os dados do array para o vector dados
  enquanto prox[temp] != OMEGA
  faça
    adicione ao vector dados o elemento na posição temp;
    faça temp apontar para o proximo elemento;
  fim

  //loop que percorre todo o vector de dados
  enquanto o vetor de dados nao for vazio
  faça

    //pega o primeiro elemento do vector
    Object atual = primeiro elemento do vector

    //para guardar a quantidade de vezes que o elemento atual aparece
    int qtd = 0;


     enquanto houver ocorrência do atual em dados
     faça
       retire a ocorrência de atual em dados
       qtd++
     fim


    /*se o contador for maior do que a maior quantidade anterior (variável maior),
      é porque os anteriores não eram de fato moda.
    */

    se qtd > maior
    faça
      remova os outros elementos de modas;
      inclua em modas o elemento atual;
      maior = qtd;
    fim
   

    /* se o contador for igual à maior quantidade anterior (variável maior),
       então o elemento atual é mais uma moda. Nesse caso
    */
    se qtd == maior
    faça
      inclua no vector modas o elemento atual;
    fim
  fim

//para guardar os elementos que forem moda (independente de quantos forem);
  Vector<Object> modas = new Vector<Object>();

  //para guardar temporariamente os dados da lista
  Vector<Object> dados = new Vector<Object>();

  //copiei do seu código: posição do primeiro elemento
  int temp = uso;

  //para guardar a maior quantidade
  int maior = -1;

  //transfere os dados do array para o vector dados
  while (prox[temp] != OMEGA){
    dados.add(info[temp]);
    temp = prox[temp];
  }

  //loop que percorre todo o vector de dados
  for (dados.size() != 0){

    //pega o primeiro elemento do vector
    Object atual = dados.firstElement();

    //para guardar a quantidade de vezes que o elemento atual aparece
    int qtd = 0;

    //enquanto o existir alguma ocorrência do objeto no vector
      remova-o do vector e incremente o contador
    while (dados.removeElement(atual))
      qtd++;


    /*se o contador for maior do que a maior quantidade anterior (variável maior),
      é porque os anteriores não eram de fato moda. Nesse caso:
        remova as outros elementos do vector modas;
        inclua no vector de modas o elemento atual;
        atribua à variável maior a quantidade do elemento atual;
    */
    if (qtd > maior){
      maior = qtd;
      modas.removeAll();
      modas.add(atual);
    }

    /* se o contador for igual à maior quantidade anterior (variável maior),
       então o elemento atual é mais uma moda. Nesse caso:
         inclua no vector modas o elemento atual;
    */
    if (qtd == maior)
      modas.add(atual);
  }

  //Aqui você já terá no vector modas todos os elementos que são moda.

<blockquote>cannot find symbol

symbol  : method removeAll()

location: class java.util.Vector<java.lang.Object>

modas.removeAll();

^

1 error

public class LLSLCursor {

// membros atributos (constantes e variáveis) da classe

   public  final int MAXLIST = 20; // máximo de células nas listas
   private final int MAXLINE =  5; // máximo elementos da LLSL por linha
   private final int OMEGA = -1;   // constante para finalizar lista
  
   private Object info[];     // array para info de cada célula
   private int prox[];        // array para prox (aponta para próxima célula)
   private int livre = 0;     // primeira posição livre do array na lista
   private int uso = 0;       // primeira posição ocupada do array na lista
  
// membros métodos (ou serviços) da classe

/*
#############################################################################
###   Implementa Operadores Básicos que caracterizam LLSL como um TAD    ###
#############################################################################
*/
/****************************************************************************
* Construtores para incializar os objetos quando instanciados.              *
****************************************************************************/
public LLSLCursor() { // construtor default para inicializar a lista
 livre = 0;                          // posição do primeiro elemento na lista livre
 uso = OMEGA;                        // posição do primeiro elemento na lista em uso
 info = new Object[MAXLIST];         // aloca array para os elementos da lista
 prox = new int[MAXLIST];            // aloca array para os elos (links) da lista
 for (int i=0; i < (MAXLIST-1); i++) // iteração para formar os links da lista livre 
      prox[i] = i + 1;               // elemento atual aponta para o próximo  
 prox[MAXLIST-1] = OMEGA;            // último elemento não possui próximo 
} // construtor

/****************************************************************************
* Inicializa (ou cria) a LLSL com n células, tornando-a vazia.              *
****************************************************************************/
public void InicializaLLSL() {    
 livre = 0;                          // posição do primeiro elemento na lista livre
 uso = OMEGA;                        // posição do primeiro elemento na lista em uso
 for (int i=0; i < (MAXLIST-1); i++) // iteração para formar os links da lista livre 
      prox[i] = i + 1;               // elemento atual aponta para o próximo  
 prox[MAXLIST-1] = OMEGA;            // último elemento não possui próximo 
} // InicializaLLSL
}//LLSL

modas.removeAll();

modas.removeAllElements();

return modas

return modas.subList(0, modas.size())