java - instr - indexOf() no encontrará un tipo de objeto personalizado

java strpos

Question

El siguiente código no me da la respuesta correcta.

class Point {

    int x; int y;
    public Point(int a,int b){
        this.x=a;this.y=b;
    }
}

class A{

    public static void main(String[] args){

        ArrayList<Point> p=new ArrayList<Point>();
        p.add(new Point(3,4));
        p.add(new Point(1,2));
        System.out.println(p.indexOf(1,2));

    }
}

Esto da -1 ;

En general, si se da una lista de arrays de puntos, ¿cómo podemos encontrar el índice de un punto particular en la matriz?

Answer 1

¿Cómo podemos encontrar el índice de un punto particular en el conjunto?

ArrayList<point> p=new ArrayList<point>();
point p1 = new point(3,4));
point p2 = new point(1,2));
p.add(p1);
p.add(p2);

System.out.println(p.indexOf(p1));

El argumento para indexOf() es un Objeto. Pásalo uno de tus objetos puntuales.

Answer 2

Necesita crear un punto para pasar al método indexOf.

p.indexOf(new Point(1,2));

Pero ese cambio en sí mismo todavía devolverá -1. Consulte el documento de la API para indexOf:

public int indexOf (Objeto o)

Devuelve el índice de la primera aparición del elemento especificado en esta lista, o -1 si esta lista no contiene el elemento. Más formalmente, devuelve el índice más bajo i tal que (o == null? Get (i) == null: o.equals (get (i))), o -1 si no hay tal índice.

Está usando iguales para decidir si se encuentra una coincidencia. No ha anulado el método equals en su clase de punto, por lo que está utilizando la implementación predeterminada en java.lang.Object, que compara las referencias, y solo devuelve verdadero si las dos referencias apuntan al mismo objeto.

Anula equals y hashcode en tu clase de puntos, como:

@Override public boolean equals(Object other) {
    if (!(other instanceof point)) {
        return false;
    }
    point otherPoint = (point)other;
    return otherPoint.x == this.x && otherPoint.y == this.y;
}

@Override public int hashCode() {
    return x + y; // same values should hash to the same number
}

y de esa manera se pueden comparar dos instancias diferentes de la clase por valor.

Answer 3

indexOf requiere el objeto como entrada. Si no encuentra el objeto que está pasando, devolverá -1. Debe pasar el objeto cuya ubicación en la lista de arrays que está buscando como la entrada en la función indexOf. También debe anular hashcode e igual para su clase en este caso.

Anula hashcode y es igual en tu clase Point. Luego, una vez que crea instancias de este punto de clase (usando la nueva palabra clave) y las agrega a la lista de arreglos, puede usar la llamada indexOf en la lista de arreglos utilizando cualquiera de los objetos de punto como parámetro de la llamada de indexOf.

Punto de clase

public class Point {

        int x; 
        int y;

        public Point(int a, int b) {
        this.x=a;this.y=b;
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + x;
            result = prime * result + y;
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Point other = (Point) obj;
            if (x != other.x)
                return false;
            if (y != other.y)
                return false;
            return true;
        }       
}

Prueba de clase (lo llamó "a"):

import java.util.ArrayList;

public class Test {

     public static void main(String[] args){

            ArrayList<Point> p=new ArrayList<Point>();

            Point p1 = new Point(3,4);
            Point p2 = new Point(1,2);

            p.add(new Point(3,4));
            p.add(new Point(1,2));

            System.out.println(p.indexOf(p1));
     }

}

Answer 4

ArrayList.indexOf() no acepta dos enteros como argumento. Debe ingresar un objeto, que se supone que es un objeto Point .

Si aún desea llamar a ArrayList.indexOf(int, int) , debe crear una subclase de ArrayList , implementando indexOf(int,int) .

El siguiente código debería encontrar el objeto deseado para usted. En primer lugar, deberá anular el método equals de la clase Object en la clase Point para comparar dos puntos.

public class Point {
    private int x;
    private int y;

    @Override
    public boolean equals(Object anotherObject) {
        if (!(anotherObject instanceof Point)) {
            return false;
        }
        Point p = (Point) anotherObject;
        return (this.x == p.x && this.y == p.y);
    }
}

En segundo lugar, puede llamar a indexOf(Object) :

ArrayList<Point> p = new ArrayList<Point>();
// Create the point to find in the list.
Point findMe = new Point(1,2);
// Search the array and save the found index.
int index = p.indexOf(findMe);

PD: debes seguir las convenciones de nomenclatura de Java; las clases deben comenzar con una letra mayúscula.