pesquisa:
- Não modifico Ttipo e faço a busca usando Collections.binarySearch criando um Comparator para especificar como quero buscar:
public static void main(String args[]) {
// declara uma lista de Ttipo
List<Ttipo> list = new ArrayList<Ttipo>();
// preenche a lista
list.add(new Ttipo("qrs", 7));
list.add(new Ttipo("tuv", 1));
list.add(new Ttipo("xz", 3));
// pesquisa por um objeto key. Repare que o objeto key não é o 'xz'
// que eu tenho adicionado, ele tem numero 0 e o 'xz' da lista tem
// numero 3. Para pesquisar vou usar Collections.binarySearch, mas antes
// vou criar um Comparator que é a 'regra' de como vai ser comparado os
// registros na busca (no caso pelo nome) e ordeno a lista de
// acordo com esse Comparator utilizando Collections.sort para que o
// binarySearch funcione perfeitamente.
Ttipo key = new Ttipo("xz", 0);
Comparator<Ttipo> c = new Comparator<Ttipo>() {
public int compare(Ttipo o1, Ttipo o2) {
return o1.nome.compareTo(o2.nome);
}
};
Collections.sort(list, c);
int i = Collections.binarySearch(list, key, c);
System.out.println(list.get(i).numero);
}
- altero Ttipo sobrescrevendo equals e hashCode para o atributo nome. Com isso estou dizendo que dois Ttipo que tiverem nome igual, serão o mesmo registro idependente da idade. Implementando esses dois, vc esta dizendo o que identifica o objeto, o que é levado em consideração para saber se dois objetos são iguais… Cuidado, parece mais facil, simples e tal, mas sobrescrever equals tem que ser bem pensado
class Ttipo {
String nome;
int numero;
public Ttipo(String nome, int numero) {
this.numero = numero;
this.nome = nome;
}
@Override
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = PRIME * result + ((nome == null) ? 0 : nome.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Ttipo other = (Ttipo) obj;
if (nome == null) {
if (other.nome != null)
return false;
} else if (!nome.equals(other.nome))
return false;
return true;
}
}
public static void main(String args[]) {
// declara uma lista de Ttipo
List<Ttipo> list = new ArrayList<Ttipo>();
// preenche a lista
list.add(new Ttipo("qrs", 7));
list.add(new Ttipo("tuv", 1));
list.add(new Ttipo("xz", 3));
Ttipo key = new Ttipo("xz", 0);
int i = list.indexOf(key);
System.out.println(list.get(i).numero);
}
- Implemento Comparable para Ttipo, isso me poupa o trabalho de criar um Comparator, é como criar um Comparator padrão para a classe… mas a logica da busca é a mesma que o 1)
class Ttipo implements Comparable<Ttipo>{
String nome;
int numero;
public Ttipo(String nome, int numero) {
this.numero = numero;
this.nome = nome;
}
public int compareTo(Ttipo o) {
return nome.compareTo(o.nome);
}
}
public static void main(String args[]) {
// declara uma lista de Ttipo
List<Ttipo> list = new ArrayList<Ttipo>();
// preenche a lista
list.add(new Ttipo("qrs", 7));
list.add(new Ttipo("tuv", 1));
list.add(new Ttipo("xz", 3));
Ttipo key = new Ttipo("xz", 0);
Collections.sort(list);
int i = Collections.binarySearch(list, key);
System.out.println(list.get(i).numero);
}
Esses acho que são os métodos mais comuns, não existe o mais certo ou mais errado, cada um pode ser usado em um contexto diferente, cabe a vc saber. O que posso te dizer é que no segundo caso vc tem que saber muito bem o que esta fazendo ja que vc esta alterando a identificação do registro, no terceiro, como vc altera a classe, pode afetar varias partes do sistema que usa ela. O primeiro caso, caso vc não quer influenciar em nada no sistema (com exceção da ordenação da lista) é o mais aconselhado acho.
Não deve existir só essas formas de fazer busca em lista, mas são as que lembrei agora heheh
Remover:
Quanto a exclusão, é só chamar o método remove passando o registro (que esta na lista) para ser excluido ou então a posição na lista:
//supondo que ja fez a busca e que i seja a posição
list.remove(i);
//ou
Ttipo paraDeletar = list.get(i);
list.remove(paraDeletar);
