Duvida Arrays.binarySearch()

Ele retorna -3 para indicar que:

1. Como -3 é um número negativo, o objeto não foi encontrado;
2. O objeto, se for inserido, deverá ser colocado na posição 3. Isso é o ponto de inserção correto.

Lembrando que binarySearch só pode ser usado em listas ordenadas.

Você precisará passar o Comparable também para o método BinarySearch:

Arrays.binarySearch(p,new Pessoa(“jack”,24), new Resort());

A busca binária deve ser feita usando o mesmo Comparable usado na ordenação.

ViniGodoy:

Ele retorna -3 para indicar que:

1. Como -3 é um número negativo, o objeto não foi encontrado;
2. O objeto, se for inserido, deverá ser colocado na posição 3. Isso é o ponto de inserção correto.

Lembrando que binarySearch só pode ser usado em listas ordenadas.

Só uma dúvida: O equals da classe pessoa está implementado corretamente, para procurar pela idade?

ViniGodoy…

Por favor. Mas pq ele nao acha esse objeto? Se eu alterar o codigo para:

Arrays.binarySearch(p,new Pessoa("carlos",20));

Ele acha,…pq ele deveria colocar o objeto na posicao 3?..ele tem 0,1,2… pela classificacao ele nao iria para a posicao 0?

Olha o codigo da Classe Pessoa…

public class Pessoa implements Comparable<Pessoa>{

	private String nome;
	private int idade;

	public Pessoa(String nome, int idade) {
		this.nome = nome;
		this.idade = idade;
	}

	public String getNome() {
		return this.nome;
	}

	public int getIdade() {
		return this.idade;

	}

	public String toString() {

		return "Nome " + getNome() + " Idade : " + getIdade() + "\n";
	}


	public int compareTo(Pessoa p){
		return this.getNome().compareTo(p.getNome());
	}


}

Eu estou usando Comparator…

Você não implementou o “equals” (embora isso não seja explicitamente descrito na documentação, ele só irá retornar um valor positivo se a classe implementar “equals” corretamente).

EDIT - falei besteira; não é preciso implementar “equals”. Só olhar o fonte do JDK.

public static <T>
    int binarySearch(List&lt? extends Comparable&lt? super T&gt&gt list, T key) {
        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            return Collections.indexedBinarySearch(list, key);
        else
            return Collections.iteratorBinarySearch(list, key);
    }

    private static ><T>
    int indexedBinarySearch(List&lt? extends Comparable&lt? super T&gt&gt list, T key)
    {
	int low = 0;
	int high = list.size()-1;

	while (low &lt= high) {
	    int mid = (low + high) &gt&gt&gt 1;
	    Comparable&lt? super T&gt midVal = list.get(mid);
	    int cmp = midVal.compareTo(key);

	    if (cmp &lt 0)
		low = mid + 1;
	    else if (cmp &gt 0)
		high = mid - 1;
	    else
		return mid; // key found
	}
	return -(low + 1);  // key not found
    }

    private static <T>
    int iteratorBinarySearch(List&lt? extends Comparable&lt? super T&gt&gt list, T key)
    {
	int low = 0;
	int high = list.size()-1;
        ListIterator&lt? extends Comparable&lt? super T&gt&gt i = list.listIterator();

        while (low &lt= high) {
            int mid = (low + high) &gt&gt&gt 1;
            Comparable&lt? super T&gt midVal = get(i, mid);
            int cmp = midVal.compareTo(key);

            if (cmp &lt 0)
                low = mid + 1;
            else if (cmp &gt 0)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found
    }

Thingol…

Mesmo assim nao entendi… desculpe a minha falta de inteligencia…

Como eu expliquei ali em cima, você deve estar usando critérios diferentes para a comparação e para a igualdade.

Além disso, quando você não deixa explicito qual comparador usar no binary search, ele vai olhar se a classe pessoa é comparable, e usar a ordem natural da classe pessoa (que deve ser por nome) para fazer a busca, ao invés de usar a ordenação feita pela segunda vez (por idade).

Isso vai mesmo deixar a busca um tanto maluca.

O segredo é usar o mesmo comparator tanto para a ordenação, quanto para o BinarySearch.

Mude o seu segundo binarySearch para:
System.out.println("\ndiego" + Arrays.binarySearch(p,new Pessoa(“diego”,15), r));

Que deve funcionar.

Perceba duas observações sobre o código:
1- A implementação de compare() da interface Comparable está implementando uma lógica de classificação alfabética por nome;
2- Na segunda chamada ao método binarySearch, o array foi classificado usando-se um Comparator, mas este não foi informado na chamada do método, o que causa resultados inconsistentes. O código seria então:

Arrays.binarySearch(p,new Pessoa("diego",15), r);

Além disso, como o Thingol mencionou, o método equals() deve ser implementado para a recuperação do objeto correto (senão será fornecida a implementação de Object, que retorna false para instancias diferentes, embora seus conteúdos sejam equivalentes).

Eu entendi… mas só pra gerar uma polêmica e sanar a minha duvida…pq que se eu alterar o codigo de :

// que retorna -3 Arrays.binarySearch(p,new Pessoa("diego",15)));
Para

// que retorna 2 Arrays.binarySearch(p,new Pessoa("jack",24));
Ambos estao usando a chamada sem passar o Camparator…