Tengo la siguiente condición:
if (csm.getStatusName() != "CIEX"){
....
}
Quiero saber como puedo hacer una condición en la que el numero de CIEX no sea superior a 2, es decir, que en la pantalla no me muestre mas de 2 estados CIEX.
Con esa condición lo que hago es con el .getStatusName recojo el estado de un paciente, y quiero hacer que ese mismo paciente no tenga 2 pruebas abiertas con el mismo estado.
Que no pueda haber 2 estados iguales por pantalla.
Saludos.
Bien. para ponerlo simple. Tal y como han comentado ya, tu error es que comparas dos String con el operador ==, mientras que deberías hacer la comparación con el método equals de la clase Object, que compara si dos objetos son iguales.
Lo que deberías hacer, por tanto, es recorrer la lista de pruebas del paciente y utilizar un contador que va aumentando con cada prueba con un estado igual (método equals) a la cadena de caracteres deseada, para más tarde comprobar si dicho contador es igual a 2 con el operador igual ==.
int contador = 0;
for (Prueba p : paciente.getPruebas())
if (p.getEstado().equals("CIEX")) contador++;
if (contador == 2)
System.err.println("Situación no permitida");
Te explico un poco el por qué de tu error.
En Java, una variable puede contener un valor de tipo primitivo o bien apuntar a un objeto, de ahí la orientación a objetos. Además, para no perder orientación a objetos, existen las clases envoltura de tipos primitivos (como Integer para int).
int entero = 31; // la variable "entero" contiene el valor 31
Objeto obj = new Objeto(); // "obj" apunta a un objeto de la clase Objeto (hipotética)
Esto ocurre porque cuando creamos un objeto, a dicho objeto se le asigna un identificador de objeto (OID), que es el valor que se almacena en la variable que va a apuntar al objeto creado, y es un valor numérico entero.
Objeto obj = new Objeto(); // se asigna el OID del objeto creado a la variable obj
Por otro lado, el operador == compara los valores numéricos que contienen dos variables.
int entero1 = 31; // se asigna el valor 31 a la variable entero1
int entero2 = 31; // se asigna el valor 31 a la variable entero2
if (entero1 == entero2) // se compara los valores de las variables (¿31 es igual a 31?)
System.out.println("Iguales"); // la igualdad se cumple (31 sí es igual a 31)
Ahora bien, existe un método en la clase Object de la que heredan todas las clases, que se llama equals. Su implementación por defecto es comparar los OID de dos objetos.
// variables que pueden apuntar a objetos de la clase Object (real)
Object objeto1, objeto2;
// Creamos dos objetos y asignamos sus OID a las variables
objeto1 = new Object(); // OID A (50 por ejemplo)
objeto2 = new Object(); // OID B (51 por ejemplo)
// ahora los comparamos
if (objeto1.equals(objeto2)) // En este caso, se aplica el operador ==
System.out.println("Iguales"); // Si los OID de los objetos coinciden
else System.out.println("Diferentes"); // Si los OID no coinciden
Ahora, como ejemplo, vamos a suponer que al crear el objeto "obj", la máquina virtual de Java (JVM) asigna el OID 31 al objeto creado.
int entero = 31; // se asigna el valor 31 a la variable entero
Objeto obj = new Objeto(); // se asigna el OID 31 a la variable obj
if (entero == obj) // se compara el valor entero 31 con el OID 31
// Error: 31 es igual a 31, pero un entero no es igual a un objeto
System.out.println("Iguales");
No debería compararse un valor entero con un OID, salvo que manejemos OIDs a pelo (raro raro).
Finalmente, las clases que heredan el método equals de Object (todas, directa o indirectamente), pueden redefinir su comportamiento para que no compare OIDs, sino el contenido del objeto apuntado por el OID.
public class MiClase {
private String atributo;
public MiClase(String s) {
atributo = s;
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false; // objeto no ha sido creado, no es igual a this
if (obj == this) return true; // OIDs coinciden: mismo objeto
if (obj.getClass() != getClass()) return false; // objetos de clase distinta son distintos
MiClase otro = (MiClase) obj; // casting
return atributo.equals(obj.atributo); // se compara el valor del atributo
}
}
Ahora, el operador == y el método equals para objetos de MiClase son distintos. El correcto a utilizar es equals.
MiClase objeto1 = new MiClase("Objeto"); // OID: A; atributo: Objeto
MiClase objeto2 = new MiClase("Objeto"); // OID: B; atributo: Objeto
// objeto1 == objeto2 devuelve false (¡Error!) porque A != B
// objeto1.equals(objeto2) devuelve true (¡Correcto!) porque el atributo es igual
Comprobemos todos los casos.
MiClase miObjeto = new MiClase("Mi Objeto"); // OID A (MiClase)
miObjeto.equals(null); // Devuelve false (primer caso: nulo)
miObjeto.equals(miObjeto) // Devuelve true (segundo caso: identidad)
Coche miCoche = new MiCoche(); // OID B (MiCoche)
miObjeto.equals(miCoche); // Devuelve false (tercer caso: distinta clase)
MiObjeto contenido = new MiObjeto("Mi Objeto"); // OID B (MiClase)
miObjeto.equals(contenido); // Devuelve true (cuarto caso: contenido)
miObjeto.equals(new MiClase("Objeto2")); // Devuelve false (cuarto caso)
Cabe destacar que String no es un tipo primitivo, sino una clase. Por lo que las variables de tipo String no contienen valores, sino OIDs que apuntan a objetos.
String s = "Hola"; // s apunta a un objeto que contiene la cadena "Hola"
Y como apunte final, los literales cadena se compilan como un solo objeto.
String s = "Hola"; // s = OID A
String t = "Hola"; // t = OID A
Que sería lo mismo que:
String h = "Hola"; // h = OID A
String s = h; // s = h = OID A
String t = h; // t = h = OID A
Entonces, ¿como se consigue que s y t apunten a objetos distintos (tengan OIDs diferentes)?
String h = "Hola"; // h = OID A; contenido: Hola
String s = h; // s = h = OID A; contenido: Hola
String t = new String(h); // t = OID B; contenido: Hola
String u = new String("Hola"); // u = OID C; contenido: Hola
Los objetos apuntados por s y t son distintos, pero su contenido es el mismo, por lo que se considera que son iguales por contenido (en la mayoría de casos el OID no importa, lo que importa para una igualdad es el contenido de los objetos).
