Ejercicio CU00657B equals y condicionales if else if java

[Jorge lopez]

 Este ejercicio fue un verdadero dolor de cabeza, hasta que me di cuenta que existía "equals" 

Código: [Seleccionar]

import java.util.Scanner;
public class DetallesDeEntradaDeDatos{
    public static void main(String []args){
        System.out.println(" Hola!");
        System.out.println("");//Buscando un espacio entre la linea de saludo y la linea que pide la entrada.
        System.out.println("Por favor introduce un texto");
        String entradaTeclado = "";
        Scanner entradaEscaner = new Scanner(System.in);
        entradaTeclado = entradaEscaner.nextLine();
        int numeroCaracteres = entradaTeclado.length();
        if(numeroCaracteres < 5 && entradaTeclado.substring(0,1).equals ("A") || numeroCaracteres < 5 && entradaTeclado.substring(0,1).equals ("a"))
        {System.out.println("El texto introducido consta de menos de 5 caracteres y comienza con la letra \"" + entradaTeclado.substring(0,1) + "\".");}
        else if(numeroCaracteres < 5)
        {System.out.println("El texto introducido consta de menos de 5 caracteres y no comienza con la letra \"" + "a" + "\".");}
        else if(numeroCaracteres >=5 && numeroCaracteres <=15 && entradaTeclado.substring(0,1).equals("A") ||
        numeroCaracteres >=5 && numeroCaracteres <=15 && entradaTeclado.substring(0,1).equals("a"))
        {System.out.println("El texto introducido consta de entre 5 y 15 caracteres y comienza con la letra \"" + entradaTeclado.substring(0,1) + "\".");}
        else if(numeroCaracteres >=5 && numeroCaracteres <=15)
        {System.out.println("El texto introducido consta de entre 5 y 15 caracteres y no comienza con la letra \"" + "a" + "\".");}
        else if(numeroCaracteres >= 16 && entradaTeclado.substring(0,1).equals ("A") || numeroCaracteres >= 16 && entradaTeclado.substring(0,1).equals ("a"))
        {System.out.println("El texto introducido consta de entre 5 y 15 caracteres y comienza con la letra \"" + entradaTeclado.substring(0,1) + "\".");}
        else if(numeroCaracteres >=16)
        {System.out.println("El texto introducido consta de mas de 15 caracteres y no comienza con la letra \"" + "a" + "\".");}
        else{}
    }
}
Salu2!

[Zikem10]

Una Duda porque cuando se supone que usamos "equals" que estuve revisando y es un metodo de comparacion pero mi duda es no se supone que este metodo lo estaria comparando  con " entradaTeclado " porque se supone que al  usar el metodo
 substring  no deberias de declarar una Variable que contuviera "entradaTeclado.substring(0,1)" y ya despues si hacer el "equals".

Esta es la parte del ejercicio
if(numeroCaracteres < 5 && entradaTeclado.substring(0,1).equals ("A") || numeroCaracteres < 5 && entradaTeclado.substring(0,1).equals ("a"))

[javi in the sky]

Hola, no entiendo bien la pregunta. Pega el código completo para poder ver cuál es el error. Para usar el método equals tienes que invocarlo sobre un objeto String, y sobre ese objeto String puedes invocar el método substring.

saludos

[Jorge lopez]

 Hola Zikem10, la pregunta no esta muy clara, pero intentare responder.

Una Duda porque cuando se supone que usamos "equals" que estuve revisando y es un metodo de comparacion pero mi duda es no se supone que este metodo lo estaria comparando  con " entradaTeclado " porque se supone que al  usar el metodo
 substring  no deberias de declarar una Variable que contuviera "entradaTeclado.substring(0,1)" y ya despues si hacer el "equals".

entradaTeclado(); es un método y equals(); es otro método, no puedes comparar estos dos métodos entre si,  para poder realizar una comparación utilizando estos dos métodos necesitas un segundo factor a comparar, donde entradaTeclado(); es el  "primer factor" y x(); seria el segundo factor y donde el método equals(); es quien compara estos dos factores, la sintaxis seria la siguiente:

Código: [Seleccionar]

if(entradaTeclado().equals(x())){...;}

Analicemos el siguiente código a modo de ejemplo:
public class Ejemplo

Código: [Seleccionar]

public class Ejemplo
{
 public Ejemplo()//Constructor de la clase
 {
  //nada que declarar 
 }
   
 public String primerFactor()//metodo que devuelve un objeto
 {
  return "a";
 }
 
 public String segundoFactor()//metodo que devuelve un objeto
 {
  return "a";
 }
 
 public boolean compararObjetos()//metodo que compara dos objetos y devuelve true en caso de estos dos objetos ser idénticos o false en caso contrario
 {
  if(primerFactor().equals(segundoFactor()))
  {
    return true;
  }else{return false;}
 }
}Una traducción de la condición a evaluar en el metodo compararObjetos(); seria: Si el objeto devuelto por el método primerFactor, es idéntico al objeto devuelto por el método segundoFactor, entonces devuelve true y en caso contrario devuelve false. Si ejecutas el método compararObjetos() tal y como esta, notaras que devolverá true, prueba a cambiar uno de los valores de retorno de cualquiera de los dos primeros métodos y ejecuta nuevamente el método compararObjetos. Aun el método compararObjetos() devuelve el mismo resultado?

porque se supone que al  usar el metodo
 substring  no deberias de declarar una Variable que contuviera "entradaTeclado.substring(0,1)" y ya después si hacer el "equals".

Esta es la parte del ejercicio
if(numeroCaracteres < 5 && entradaTeclado.substring(0,1).equals ("A") || numeroCaracteres < 5 && entradaTeclado.substring(0,1).equals ("a"))

Si, yo podria declarar lo siguiente: String A = entradaTeclado.substring(0,1);

if(numeroCaracteres < 5 && A.equals ("A") || numeroCaracteres < 5 && A.equals ("a")){...;} pero debemos optar siempre por la simplificación al momento de programar, para que declarar la variable A, si puedo hacer la comparación directamente entre proceso (entradaTeclado.substring(0,1)) y objeto ("a") o objeto ("A"). A fin de cuentas el método equals no toma en cuenta ni el nombre del método a comparar ni el proceso que realice siempre y cuando este devuelva un objeto tipo String. Declarar una variable como A, en lo personal y segun correcciones en algunos de mis ejercicios seria algo así como: darle vueltas al asunto. Es mas practico y aceptable siempre que se pueda ir directo al asunto y así simplificar el código. Recuerda que los dos primeros métodos devuelven cada uno un String y que un String es un objeto, y que equals es un método para comparar igualdad entre objetos tipo String, teniendo en cuenta que la igualdad de un objeto es algo distinto a la identidad de un objeto.
Espero que encuentres algo útil en este comentario.
Saludos. 

[toni_apr]

Hola Zikem10
Leo tu mensaje, y creo entender que tu duda es:
¿Porque se utiliza esa sintaxis (forma de escribir dentro del if) en lugar de otra tal vez una con más variables intermedias?.
Si es esa tu duda. Pues si, todo se pude simplificar, subdividir, complicar, compactar... como tu quieras.
Es decir, todo lo que hagas es válido, si funciona claro.
Lo que si puedo decirte, es que en este lenguaje es común ver código con métodos enganchados (conectados) con un punto. Cada método hace una parte del trabajo y cuando lo termina se lo pasa al siguiente método hasta completar toda la cadena.
Seguramente la práctica te permitirá cogerle el tranquillo a esta forma de programar.

A continuación hago una transcripción del código al lenguaje que usamos nosotros.

  if ( numeroCaracteres < 5 && entradaTeclado.substring(0,1).equals ("A"))
| A |               B                  | C  |            D          |          E          |          F        |

A =  Si ocurre lo siguiente
    B = cantidad de caracteres es menor que cinco
C = Y además
    D = Lo que has escrito por teclado
    E = Coges la primera letra
    F = Compara si es igual a la letra 'A' mayúscula

A continuación una frase
ABCDEF
que traducida es:

Si ocurre lo siguiente: Que las letras pulsadas son menos de cinco, y que además resulta que de todo lo que has escrito, coges la primera letra y la comparas con la A mayúscula, y resulta que coincide, pues toda esta parrafada es cierta.

Espero que esto pueda servirte. Saludos.

[dongo]

Hola, bueno, creo que te puedo aportar alguna cosilla mas:

A ver lo de concatenar unos métodos con otros, es muy común, claro esta que siempre se puede hacer lo que tu dices:

porque se supone que al  usar el metodo
 substring  no deberias de declarar una Variable que contuviera "entradaTeclado.substring(0,1)" y ya despues si hacer el "equals".

Pero ten en cuenta que al hacer eso estas creando una variable nueva, lo que conlleva a la necesidad de asignar una nueva posición de memoria, lo que hace que el programa deba ejecutar mas instrucciones y lo que lleva a un mayor tiempo de ejecución.

Mientras que si lo haces con métodos encadenados el programa ganará en eficiencia además de que te ahorrarás bastante código.

Cuando encadenar y cuando crear variables intermedias.

Bueno, imagínate que la cadena que nos devuelve  "entradaTeclado.substring(0,1)"  vamos a necesitarla 1000 veces, entonces si te convendría crear una variable intermedia, pero si te fijas en este programita solo hacemos uso de ella 2 veces con lo cual es mas ligero los métodos concatenados asi: "entradaTeclado.substring(0,1).equals("a");"

Poco a poco te iras acostumbrando a esto de concatenar métodos, te darás cuenta que si tienes un método A que devuelve una cadena y un método B que se invoca con un objeto de tipo cadena, podrás concatenarlos de esta forma A().B()

Veamos con un ejemplo simple:

Código: [Seleccionar]

public class Prueba {
    public static void main (String[ ] Args) {
        String s1="pepe";
        String s2="PePe";
        System.out.println(s1.substring(0, 2).toLowerCase().equals(s2.substring(0, 2).toLowerCase()));
    }
}
 

Simplemente tenemos dos cadenas y se imprime por pantalla el resultado de esta instrucción: " s1.substring(0, 2).toLowerCase().equals(s2.substring(0, 2).toLowerCase()) "

donde s1 es "pepe" y s2 es "PePe"

Esa instrucción se ejecuta de izquierda a derecha y es el punto el que delimita cada instrucción, veamoslo paso a paso:

Instrucción 1: s1 --> Simplemente es el valor de la cadena s1 es decir "pepe"
Instrucción 2: substring(0,2) --> Pues nos devolverá la cadena "pe"
Instrucción 3: toLowerCase() --> Este método nos convierte a minúsculas lo que tenga a su izquierda, que en este caso es "pe"
Instrucción 4: equals(s2.substring(0, 2).toLowerCase()) --> En este caso compararía el "pe" que teníamos a la izquierda con lo que está entre paréntesis.

En este punto, java mantendría la cadena "pe" almacenada y empezaría a evaluar lo que esta dentro del paréntesis: " s2.substring(0, 2).toLowerCase() " que si empezamos a leer de izquierda:

s2 --> tiene la cadena "PePe"
substring(0, 2) --> sería "Pe"
toLowerCase() --> seria "pe"

Por tanto se mostraría en pantalla el valor: true

Ahora veamos como sería si lo hiciéramos almacenando en variables intermedias los valores de cada instrucción:

Código: [Seleccionar]

public class Prueba {
    public static void main (String[ ] Args) {
        String s1="pepe";
        String s2="PePe";
        String subS1=s1.substring(0, 2);
        String lowerSubS1=subS1.toLowerCase();
        String subS2=s2.substring(0,2);
        String lowerSubS2=subS2.toLowerCase();
       
        System.out.println(lowerSubS1.equals(lowerSubS2));
    }
}

 Si te fijas hemos tenido que crear 4 variables auxiliares lo que podíamos realizar en una sola linea. Y esta es de las simples, jeje hay veces que hay que concatenar 6 o 7 métodos en cadena. Que claro esta que siempre podemos hacerlo por pasos pero como ves es mas rápido y eficiente de esta manera.

La clave esta en que lo que devuelve el método de la izquierda, debe ser lo que invoca al método de la derecha.

Bueno espero al menos haberte podido aclarar alguna cosilla, aunque es lo de siempre con la practica y el tiempo te irás a costumbrando a realizar este tipo de sentencias.

Un saludo!


 

[Zikem10]

Muchas Gracias si me sirvio las explicaciones me quedo ya claro con la de toni_apr
,Sniper y Dongo, al estar invocando los metodos y concatenarlos y el tip que me diste

"La clave esta en que lo que devuelve el método de la izquierda, debe ser lo que invoca al método de la derecha"

este resumio todo.

[Alex Rodríguez]

Solución de toni_apr (hemos reorganizado el post para no mezclar temas)

----------------------
A continuación la clase MainConEntradaPorTeclado del ejercicio CU00657B

Esta clase sin atributos pide una entrada por teclado y con dos decisiones condicionales muestra unas observaciones sobre la entrada introducida.

A continuación va el código. Saludos.

Código: [Seleccionar]

import java.util.Scanner;
/**
 * Detalles de la clase.
 *
 * @author (Toni)
 * @version (0)
 */
public class MainConEntradaPorTeclado {

    // Atributos de la clase MainConEntradaPorTeclado
    // sin atributos
    /**
     * Constructor para objetos de la clase MainConEntradaPorTeclado
     */
    public MainConEntradaPorTeclado() {
        // Inicializa atributos
        // nada

    } // Fin del constructor MainConEntradaPorTeclado

    // Siguen los setters para los atributos de la clase MainConEntradaPorTeclado

    // Ahora los getters para los atributos de la clase MainConEntradaPorTeclado

    // Y seguidamente, procedimientos y funciones varios.
    public static void main (String [] args) {
        String entradaTeclado = "";
        Scanner entradaEscaner = new Scanner(System.in);
        int longitudEntrada = 0;
       
        System.out.println ("Este programa necesita que introduzca una entrada por teclado.\n" +
            "\tProceda, por favor.");
        entradaTeclado = entradaEscaner.nextLine();
        String respuesta = "La cadena introducida:\n\t\"" + entradaTeclado + "\"";
        longitudEntrada = entradaTeclado.length();

        if (longitudEntrada < 5) {
            respuesta = respuesta + "\nTiene menos de 5 caracteres.";
        } else if (longitudEntrada >= 5 && longitudEntrada <= 15) {
            respuesta = respuesta + "\nTiene entre 5 y 15 caracteres.";
        } else {
            respuesta = respuesta + "\nTiene más de 15 caracteres.";
        } // fin del if

        if (entradaTeclado.substring(0,1).equals("a") || entradaTeclado.substring(0,1).equals("A")) {
            respuesta = respuesta + "\nY empieza por 'A', o 'a'.";
        } else {
            respuesta = respuesta + "\nY no empieza por 'A', o 'a'.";
        } // fin del if
        System.out.println (respuesta);
    } // fin del main
} // Fin de la clase MainConEntradaPorTeclado