Java - Problema con validación de string

 
Vista:
Imágen de perfil de jose
Val: 64
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Problema con validación de string

Publicado por jose (72 intervenciones) el 29/10/2021 19:01:07
Screenshot-from-2021-10-29-18-28-53

Hola a todos,

Tengo un problema con el siguiente código.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public boolean existeixClient(String[][] arrayDatos, String nif) {
 
		int columns = arrayDatos[0].length;
 
		boolean existe = false;
 
		for (int i=0;i < arrayDatos.length;i++) {
			//Comprobando si existe el NIF. Si existe el valor del boolean es true.
			for (int j=0;j < columns;j++) {
				String dato = arrayDatos[i][j];
				//Se deja == en vez dato.matches(nif) o dato.equals(nif) debido a que hay valores nulls
				if (dato==nif) {
					existe = true;
					break;
				}
			}
		}
 
 
		return existe;
	}

El método recoge un array y un número nif, y busca el número nif dentro del array.

El tema es que debugeando veo que lo encuentra, como podéis ver en la imagen, pero en el momento de compararlo hace como que no lo ha encontrado.

He probado con dato.equals(nif) y dato.matches(nif) pero no funciona dado que el array al estar vacío los valores son null y da error de java.lang.NullPointerException

A ver si alguien sabe el motivo.

Saludos,
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Problema con validación de string

Publicado por Santiago (25 intervenciones) el 29/10/2021 19:19:10
Hola, José:

A mí sí me funciona:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class NIF {
 
	public static void main(String[] args) {
 
		String[][] nifs = new String[2][2];
		String nif="3A";
 
		nifs[0][0]="1R";
		nifs[0][1]="2W";
		nifs[1][0]="3A";
		nifs[1][1]="4G";
 
 
		if(existeixClient(nifs, nif)) {
			System.out.println("Existe el NIF");
		}else {
			System.out.println("No existe el NIF");
		}
 
 
	}
 
	public static boolean existeixClient(String[][] arrayDatos, String nif) {
 
		int columns = arrayDatos[0].length;
 
		boolean existe = false;
 
		for (int i=0;i < arrayDatos.length;i++) {
 
			//Comprobando si existe el NIF. Si existe el valor del boolean es true.
 
			for (int j=0;j < columns;j++) {
 
				String dato = arrayDatos[i][j];
 
				//Se deja == en vez dato.matches(nif) o dato.equals(nif) debido a que hay valores nulls
 
				if (dato==nif) {
 
					existe = true;
 
					break;
 
				}
 
			}
 
		}
 
		return existe;
	}
 
}

Pero veo en tu pantallazo:

1
arrayDatos          String[44][]

como si el segundo corchete del array estuviera vacío. ¿Puede ser que no se esté pasando bien?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de jose
Val: 64
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Problema con validación de string

Publicado por jose (72 intervenciones) el 29/10/2021 19:38:47
Hola Santiago,

Se lo que me dices. No se el porque sale así.

El array lo inicializo así String[][] Clients = new String[avio.length][2];

Como ves en esta imagen los datos del DNI está añadidos en la primera fila del array y son del mismo tipo al que hay que comparar.

Screenshot-from-2021-10-29-19-35-16
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Problema con validación de string

Publicado por Kabuto (1102 intervenciones) el 29/10/2021 19:33:26
Siempre hay que comparar con equals(), de lo contrario nunca obtendremos una comparación de valores, si no una comparación de referencias


He probado a escribir yo un método algo más simplificado (aunque en esencia diría que hace lo mismo que el tuyo) y funciona sin importar que hayan valores null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class BuscaDni {
 
 
	public static void main(String[] args) {
 
		String[][] dnis = new String[][] {
			{null, "6578902A", null, "1233431Q", null},
			{"909090901G", "2091567G", "46701212R", null, null},
			{null, null, null, null, null},
			{null, "9988776T", null, "7469831J", null}
		};
 
		String buscar = "7469831J";
 
		System.out.println("Buscando: " + buscar);
 
		System.out.println(existeixClient(dnis, buscar)?"Sí existe":"No existe");
 
	}
 
	static boolean existeixClient(String[][] arrayDatos, String nif) {
 
		for (int i = 0; i < arrayDatos.length; i++)
			for (int j = 0; j < arrayDatos.length; j++)
				if (nif.equals(arrayDatos[i][j]))
					return true;
 
		return false;
	}
 
}

Esto me hace dudar de si quizás en versiones anteriores de Java, sí suponía un problema comparar con valores null, y quizás tu estés compilando para una versión antigua.
No se...
En cualquier caso, si sigues teniendo problemas comparando valores nulos, puedes evitarlo preguntando si el valor es null o no, antes de proceder a hacer la comparación.

1
2
3
4
5
6
7
8
9
static boolean existeixClient(String[][] arrayDatos, String nif) {
 
		for (int i = 0; i < arrayDatos.length; i++)
			for (int j = 0; j < arrayDatos.length; j++)
				if (arrayDatos[i][j] != null && nif.equals(arrayDatos[i][j]))
					return true;
 
		return false;
	}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de jose
Val: 64
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Problema con validación de string

Publicado por jose (72 intervenciones) el 29/10/2021 19:59:25
Hola Kabuto,

No me lo explico. Está funcionando ahora. Me cansé de estar delante del PC. Lo volví a arrancar y la aplicación funciona ahora bien.

Lo dejado con .equals como debería estar. Pero funciona con matches e ==.

informática !!!!!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Problema con validación de string

Publicado por Kabuto (1102 intervenciones) el 29/10/2021 23:09:23
Con el == , a veces PARECE que funciona, pero solo lo parece y depende del origen de los datos.

Por ejemplo, este código.

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
 
        String cadena1 = "hola";
        String cadena2 = "hola";
 
        if (cadena1 == cadena2)
            System.out.println("Verdadero");
        else
            System.out.println("Falso");
    }

En pantalla saldrá el resultado: Verdadero
Y podemos pensar que se debe a que ambos String tienen el mismo valor.
Pero no es ese el motivo.

Ahí lo que ocurre es que ambos String están apuntando a la MISMA constante. En Java, cuando en el código ponemos una cadena entre las comillas, aunque no lo parezca estamos creando una constante.
Y eso es lo que comprueba el operador ==, si dos referencias están apuntando a un mismo valor. Cosa que es diferente de si dos referencias, tienen el mismo valor.

Ahora bien, si lo cambiamos por este código, donde sus valores van a tener otro origen. Esta vez lo recibirán por teclado:
1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe una palabra: ");
        String cadena1 = teclado.nextLine();
        System.out.print("Escribe la misma palabra: ");
        String cadena2 = teclado.nextLine();
 
        if (cadena1 == cadena2)
            System.out.println("Verdadero");
        else
            System.out.println("Falso");
    }

Aunque escribamos exactamente la misma cadena para ambos String, al comparar con == nos dirá que NO SON IGUALES
1
2
3
4
5
Escribe una palabra:
hola
Escribe la misma palabra:
hola
Falso

Bueno, en realidad lo que nos está diciendo, es que están apuntando a distintos valores.
Los valores en realidad, son iguales (o más correcto decir, equivalentes), pero son DOS objetos distintos porque se han originado en dos procesos distintos.
Cada entrada de datos, con teclado.nextLine(), han producido objetos distintos, cada uno con su propia dirección de memoria.

En el ejemplo anterior, los datos provenían de una misma constante, ubicada en una única dirección de memoria, así que teníamos dos referencias a esa misma dirección.
Eso es lo que comprueba el operador ==

En cambio equals(), sí hace una comparación de los valores para juzgar si hay una equivalencia

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe una palabra: ");
        String cadena1 = teclado.nextLine();
        System.out.print("Escribe la misma palabra: ");
        String cadena2 = teclado.nextLine();
 
        System.out.println("\nComparando con ==");
 
        if (cadena1 == cadena2)
            System.out.println("Verdadero");
        else
            System.out.println("Falso");
 
        System.out.println("\nComparando con equals()");
 
        if (cadena1.equals(cadena2))
            System.out.println("Verdadero");
        else
            System.out.println("Falso");
    }

En pantalla veremos que cada forma de comparar, da un resultado distinto, y solo equals() está acertando:

1
2
3
4
5
6
7
8
9
10
Escribe una palabra:
hola
Escribe la misma palabra:
hola
 
Comparando con ==
Falso
 
Comparando con equals()
Verdadero

Así que siempre que comparemos objetos, de cualquier clase, debemos usar equals()

Aquí hay que añadir que para la clase String, Integer, Double,... y todas o la mayoría de clases que vienen ya predefinidas en Java, el método equals() funciona porque alguien ha sobreescrito este método con el código necesario para que funcione y los String sepan como han de compararse para decidir si son equivalentes o no.

En el caso de que estemos usando clases nuestras, escritas por nosotros, las típicas clase Persona, Alumno, Coche, Perro,... y cualquier otra que sea de nuestra propia creación, el método equals() NO funcionará, si previamente no lo sobreescribimos nosotros para enseñarle a nuestra clase como ha de compararse para decidir su equivalencia.
A una Persona le diremos que son iguales si tienen el mismo DNI (aunque no coincidan sus atributos nombre y apellidos), a un Coche le diremos que son iguales si tienen la misma matricula o el mismo nº de chasis (aunque su atributo color o nº de asientos difieran), dos Perros serán iguales si tienen el mismo chip identificador(aunque su atributo raza o color de pelo sean distintos), etc...
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de jose
Val: 64
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Problema con validación de string

Publicado por jose (72 intervenciones) el 30/10/2021 00:27:22
Hola Kabuto,

Menos mal que hay alguien en los foros que ilustra. El profe que tengo de programación no contesta ni al foro interno ni a los correos.

Muchas gracias de nuevo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Problema con validación de string

Publicado por Tom (1774 intervenciones) el 30/10/2021 13:15:46
Creo que lo he contado alguna vez más. No es ninguna magia negra que el operador == funcione con strings, si son strings "estáticas" creadas en los fuentes.
Esto es porque la clase String mantiene un "caché" de objetos, de modo que antes de crear un nuevo objeto String se busca en este cache para ver si se puede usar la referencia de otro ya creado.
Por eso == aunque compare referencias funciona, porque realmente los dos objetos que comparas pueden ser el mismo.
Estará mejor explicado por Internet, seguramente.

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#intern()
https://www.geeksforgeeks.org/interning-of-string/

Pero, en resumen, si haces esto en tu código:

String s0 = new String("Pepito");
String s1 = new String("Pepito");

s0 y s1 son el mismo objeto, y funciona ==
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar