[quote=smd]Interface:
public boolean removeElement(K element);
public void add(K element) throws SetException;
public boolean contains(K element);
public boolean pertence(K element);
public K getElmentAt(int index);
public boolean eguals (IntSet<K> set);
public boolean empty();
public boolean subSet(IntSet<K> set);
public boolean subSet(K set);
public boolean subSetProper(IntSet<K> set);
public IntSet<K> diference(IntSet<K> set) throws SetException ;
public IntSet<K> diference(K element) throws SetException ;
public int getCardinality();
public int size();
public Iterator<K> getIterator();
public Object clone() throws CloneNotSupportedException;
public IntSet<K> union(IntSet<K> set) throws SetException;
public IntSet<K> union(K element) throws SetException;
public IntSet<K> intersection(IntSet<K> set) throws SetException;
[/quote]
Partindo dessa interface, eu criaria uma implementação baseada em um LinkedHashSet, porque ele tem duas características fundamentais para o problema: oferece as operações de conjunto (contém, não contém, união, intersecção, etc) de forma eficiente e armazena os elementos em ordem de inserção.
Essa implementação seria basicamente um decorator, que adapta as operações nativas do Set para a interface desejada.
// Só um rascunho, nao ligue para os erros de compilacao.
class IntSet<K> {
private LinkedHashSet<K> innerset;
public boolean removeElement(K element) {
innerset.remove(element);
}
public boolean contains(K elem) {
return innerset.contains(elem);
}
public boolean contains(IntSet<K> set) {
return innerset.containsAll(set);
}
public boolean subSet(IntSet<K> set) {
return set.containsAll(innerset);
}
public IntSet<K> union(IntSet<K> set) throws SetException {
LinkedHashSet u = new LinkedHashSet(innerset); // Copia o conjunto atual
u.addAll(set); // Adiciona o segundo conjunto
return new IntSet<K>(u); // Retorna um novo conjunto com a união.
}
// assim por diante, implementando todas as operações
}
O problema ficaria por conta do getElementAt(index). Uma implementação possível seria fazer esse método iterar pelos elementos até chegar ao desejado. Essa iteração seria transparente para a classe que está usando o conjunto.
// Também só um rascunho, nao sei se compila e nao tem tratamento de range invalido.
K getElmentAt(int index) {
int i = 0;
Iterator iter = innerset.iterator();
while (i < index) {
i++;
iter.next();
}
return iter.next();
}
Como dá para ver, esse processo não é muito otimizado, mas é o preço a pagar para ter eficiência nas operações de busca. Dependendo do caso não é nada de outro mundo, a própria LinkedList faz algo parecido quando vc pede um elemento pelo index. Vale a pena testar e ver se atende às necessidades.
[color=blue]Obs 1:
Tem algumas dessas operações que acho que não fazem sentido, dê uma conferida… subSet, diference e union não se aplicam a elementos, apenas a outro conjunto.[/color]
[color=red]Obs 2:
Gostaria de ver outras opiniões a respeito, se dá para melhorar tudo isso. Vou ficar de olho no tópico!
[/color]