Oi, sou novo aqui no GUJ (e no java) e vim com a intenção de aprender e ajudar...
Sem mais delongas, aqui vai um esboço de classe para ordenar objetos mantendo as posições deles...
A intenção é guardar ids e utilizar a propria posição como valor da id, assim encontrando os valore mais rapidos.
A classe ainda usa uma pilha para armazenar os valores que deixaram de serem usados, colocando eles para re-uso
Como, eu não entendo muito de java e não tive muito tempo pra testar a classe, ficaria feliz com opiniões e afins.
Fica a seguir a classe...
import java.io.Serializable;
import java.util.Stack;
/*
* Classe para organizar dados
* Melhor para guardar ids, n muda a posicao dos nodos quando um nodo sai ou entra...
* Pior para usar getNext getPrev, pois tem de percorrer espaços nulos
*/
public class Vetor <E> implements Serializable {
//tamArray é o tamanho do array - 1 posição, que é usada
//para referenciar o proximo array
private final static int tamArray = 64;
private E[] refPrim;
private Stack<Integer> freeNodo;
private int qtdSaltos;
private int ultimaPosLivre;
Vetor () {
refPrim = (E[]) new Object[tamArray];
freeNodo = new Stack<Integer>();
qtdSaltos = 1;
ultimaPosLivre = 0;
}
private int add(E elem, int pos){
int s = pos%(tamArray-1);
s = pos-s*(tamArray-1);
//s agora vale a posição pos
E[] arr = salta(pos);
//arr esta no array certo
if ( arr[s] != null ) {
arr[s] = elem;
}
else {
pos = -1;
}
return pos;
}
public int add(E elem) {
int pos;
//tenta usar um nodo libertado
if (freeNodo.size() > 0) {
pos = freeNodo.pop();
}
//senão usa a ultima posição livre
else {
pos = ultimaPosLivre;
ultimaPosLivre++;
}
//pos recebe -1 se o espaço estiver ocupado
pos = add(elem,pos);
return pos;
}
public E get(int pos){
int s = pos%(tamArray-1);
s = pos-s*(tamArray-1);
//s agora vale a posição pos
E[] arr = salta(pos);
return arr[s];
}
public E rem(int pos){
int s = pos%(tamArray-1);
s = pos-s*(tamArray-1);
//s agora vale a posição pos
E[] arr = salta(pos);
//guarda o valor a ser retornado
E res = arr[s];
//limpa no array o valor
arr[s] = null;
//adiciona a posição livre no stack
freeNodo.add(pos);
return res;
}
public E[] salta (int pos) {
E[] arr = refPrim;
int s = pos%(tamArray-1);
if ( s <= qtdSaltos ) {
while ( s > 0 ) {
arr = (E[]) arr[tamArray];
s--;
}
//Agora arr esta no array correto
}
else {
while ( s > qtdSaltos ) {
arr = (E[]) arr[tamArray];
s--;
}
//Agora s tem o valor de arrays que terão de ser instanciados
while ( s > 0 ) {
arr[tamArray] = (E) new Object[tamArray];
s--;
}
arr = (E[]) arr[tamArray];
//Agora arr esta no ultimo array, posição correta, e os arrays estão instanciados
}
return arr;
}
}
Té a proxima :)