SoloCodigo

Hola a todos colegas.
Escribo este post, porque me estoy preparando para mi primer examen de estructura de datos.

Tengo como objetivo crear  una estructura de datos estatica y que utilice una tecnica de acceso a los elementos directo(Osea que no sea ni LIFO ni FIFO, sino que cuando yo quiera sacar un elemento pueda sacar el que me de la gana), que organice de menor a mayor los objetos que en ella se introducen, para que luego el denominado proceso binarySearch sea posible. Les voy a mandar una clase que he recibido de mi Profesora de Belgrado en la cual ella implementa esta estructura, tengo grandes problemas entendiendo el metodo add().
Me gustaria saber que pensais sobre esta clase y tambien si existe alguna forma mas simple de hacer el metodo add() de alguna manera mas rapida que me organice inmediatamente los balores en el array con algun metodo de las libraries, o algo por el estilo...

Bueno yo ai os mando este pequeno trozo de codigo haber que pensais:
//CODIGO

public class SortedArrayList implements ISortedList {
   private Comparable[] array;
   private int counter;   
   public SortedArrayList(int size) {
      if ( size < 0 ) {
         System.err.println("Kapacitet listemorabiti pozitivan broj");
         size = 20;
      }      
      array = new Comparable[size];
      counter = 0;
   }   
   @Override
   public void add(Comparable c) {
      if ( isFull() ) {
         System.err.println("Lista je vec puna, operacija se ne moze izvrsiti");
         return;
      }
      if ( isEmpty() ) {//Ako je niz prazan ulazni argument dodijeljujese prvoj poziciji
         array[counter++] = c;
         return;//kraj!
      }      
      int index = 0;
   //Vrijednost manje od 0 dobijemo od metoda compareTo(Comparable c), kada je array[index] < od zadat argument.      
   //Dobicemo vrijednost 1 od metoda compareTo, kada zadat argument bude veci nego onaj vrijednost s kojim smo uporedili   
//Jel pozicija array[index] manja do vrijednost ulaznog argumenta? Ako da       
      while ( index < counter && array[index].compareTo(c) < 0) {
         index++;//Ako da onda uvecamo index jer treba da bude sortirano od manje do vece
      }
      for(int i = counter; i > index; i--) {
         array = array[i-1];
      }
      array[index] = c;
      counter++;
   }
   @Override
   public int exists(Comparable c) {      
      int lowerBound = 0;
      int upperBound = counter - 1;      
      while ( lowerBound <= upperBound ) {         
         int currentIndex = (lowerBound + upperBound)/2;
         if ( array[currentIndex].compareTo(c) == 0 )
            return currentIndex;
         if ( array[currentIndex].compareTo(c) < 0 )
            lowerBound = currentIndex + 1;
         else //array[currentIndex].compareTo(c) > 0
            upperBound = currentIndex - 1;         
      }      
      return -1;      
   }

   @Override
   public boolean isEmpty() {
      return counter == 0;
   }

   @Override
   public boolean isFull() {
      return counter == array.length;
   }

   @Override
   public void print() {      
      System.out.println("Prikaz elemenate niza:");
      for (int i = 0; i < counter; i++) {
         System.out.println( array );
      }
   }

   @Override
   public Comparable remove(Comparable c) {      
      if ( isEmpty() ) {
         System.err.println("Lista je prazna; operacija se ne moze izvrsiti");
         return null;
      }      
      int toRemoveIndex = exists(c);
      Comparable temp = array[toRemoveIndex];      
      for (int i = toRemoveIndex; i < counter - 1 ; i++) {
         array = array[i+1];
      }      
      counter--;
      return temp;
   }

}

He estado analizando el ejemplo, me sigue pareciendo un poquillo complicado para entenderlo, asi que he decidido intentar algo mas simple.
Mira veras:

tengo un array-->    [ ]  [ ]  [ ]  [ ]  [ ]  [ ]  length = 6

Si este array estuviese lleno, entonces no podria utilizar el metodo add() o insert() o cualquiera que intentase introducir un elemento. Hasta aki ok!

Si este array estuviese vacio, entonces el elemento introducido se colocara en la primera posicion, ya que no hay ninguna necesidad para organizar nada.

Ahora viene el problema
si tenemos esta situacion:

                               [5]  [6]  [7]  [9]  [10]  [ ] <-- Este ultimo esta vacio para que sea posible desplazar a la derecha.

Ahora que tengo que hacer, si quiero introducir el elemento [8].
Tengo que desplazar los elementos en las posiciones [9]  [10] a la derecha 1 y en la posicion 3(donde estaba inicialmente el elemento [9]) , escribir el elemento [8]

Entiendo lo que tengo que hacer en teoria, pero en la practica me lio un poco.
 Me podrias echar un cable para hacer un pequeno metodo que solucionase este problemilla?
-Tengo que buscar el elemento mayor que [8] osea([9]) y cuando lo encuentre apartir de el desplazarlo para poder a la posicion del array[3] dar el valor 8 (array[3] = 8) .

Yo he pensado algo asi:

//Imaginemos que el array es asi -->
                   private int[] array = new int[n];
                   private int pointer = -1; //Marka en que posicion nos encontramos

                  public void add(int e) {
                         
                            if(isFull()) {
                               System.out.println("No se puede introducir el array esta lleno!");
                               return;
                            }
                           
                           if(isEmpty()) {
                              array[0] = e;
                              return;
                           }

//AKI NECESITO AYUDA COMO IMPLEMENTARIA ESTA PARTE.
//TENGO UN LIO ENORME EN LA CABEZA hehe...
                         // for(int i = pointer; i >= 0; i-- ) {
                         //          if(e > array) {                        
                         //                 array[]
                                   }
                          }
                  }


Muchas gracias por tu ayuda.
Por cierto tu de donde eres?

El problema es el siguiente y es que no se como organizar el array segun voy introducioendo los argumentos:
Mira este codigo que he escrito poco despues de mi ultimo post.
Estoy intentando simplificar al maksimo para lograr entenderlo