Java desde Cero – Estructura de Control de Flujo – Bucles 2

Anteriormente:

Ya hemos revisado el bucle FOR, en esta ocasión vamos revisar la estructura de control de flujo While, tal como en la introducción mencionamos los bucles While son del tipo indeterminado, y es indeterminado ya que no se sabe cuántas veces se ejecutará ya que estas estructuras responden a una condición booleana, condición que deberá ser verdadera para que la ejecución continúe y falsa para que se detenga, su estructura es de la siguiente forma:

while (condición) {
     sentencias
}

Existen algunas observaciones respecto a while, puede ser que nuestra condición sea falsa con lo cual nunca ha de ejecutarse el while, o puede ser que sea verdadera y no exista un mecanismo que cambie dicha condición con lo cual la iteración de while será infinita, dicho esto debemos de tener especial cuidado cuando definamos la condición, sobre esta última observación, ¿Dónde conviene tener un bucle infinito? pues por lo general es un recurso que se emplea mucho en el desarrollo de los videojuegos y que se ejecutan hasta un cierre del mismo, pero mientras este cierre no se ejecute conviene mucho que todas las demás funcionalidades estén en ejecución, como el estar re-dibujando constantemente el canvas, si te encuentras en una situación que amerita su implementación simplemente puedes hacer esto:

while (true) {
     sentencias
}

No hay mucho que decir, así que veamos un ejemplo para visualizar el como trabaja esta estructura de control de flujo. Supongamos que tenemos  un número al azar entre 0 y 100, y tenemos que adivinar el número, tal que nuestro programa si en caso no acertemos nos de información de si el número que hemos ingresado es muy alto o muy bajo respecto al número que estamos buscando, cuando por fin acertemos el programa nos dará una felicitación, nos dirá que número era y cuántas veces hemos intentado hasta hallar el número.

import java.util.Scanner;

public class Bucles_2 {

  public static void main(String[] args) {

    int numero_buscado=(int)(Math.random()*100);
    boolean no_acerto=true;
    Scanner entrada=new Scanner(System.in);
    //System.out.println(numero_buscado);
    System.out.println("Bienvenido al juego");
    int intentos=0;

    while(no_acerto==true) {
      System.out.println("Ingrese un número");
      int variable=entrada.nextInt();
      if(variable>numero_buscado) {
        System.out.println("El número es muy alto");
        intentos++;
      }else if(variable<numero_buscado) {
        System.out.println("El número es muy bajo");
        intentos++;
      }else {
        System.out.println("Acertaste!");
        intentos++;
        no_acerto=false;
      }
    }
    entrada.close();

    System.out.println("El número buscado era: "+numero_buscado+" y lo obtuviste con un total de "+intentos+" intentos");

}

}

Revisamos un poco lo desarrollado, de arriba hacia abajo, tal como es el flujo natural de ejecución en Java, bueno, lo primero que hemos creado es el número aleatorio, este número aleatorio lo hemos obtenido con el uso del método estático de random de la clase Math del paquete java.lang, este método nos retorna un número aleatorio entre 0 y 1 y de tipo double, para obtener el número entre 0 y 100 basta que multipliquemos el valor que nos retorna por 100, ahora bien dado que un tipo double es esencia un decimal, nosotros vamos a restringir los resultados a valores de tipo entero, para lo cual debemos de realizar una conversión o casteo y por ello hacemos uso de (int) para tales fines.

Luego creamos la condición que estará en el while, en la línea siguiente definimos que dado que el usuario ha de ingresar datos a través del teclado, necesitamos capturarlos y esto lo hacemos a través de una instancia de la clase Scanner, finalmente creamos un contador de intentos; ahora bien, empieza la iteración dado que la condición es true, se le consulta por un número al usuario, se captura el número con la instancia de Scanner y se castea a un entero con el método nextInt(), y se evalúa en los condicionales si es mayor o es menor, o si en caso de no ser alguna de ellos, podemos tener la certeza de que es el número que estamos buscando y detenemos la iteración haciendo que la variable booleana cambie a false; en todos los componentes del condicional hacemos que los intentos se le suma una unidad aún incluso si acertamos se puede contabilizar como un intento.

No olvidemos jamás de cerrar el flujo de entrada de datos, haciendo uso del método close de la clase Scanner. Finalmente hacemos impresión de los resultados y nuestro programa habrá finalizado

Anuncios

Java desde Cero – Estructura de Control de Flujo – Bucles 1

Cuando hacemos uso de un programa existen o lo creamos podemos observar que existen operaciones que se han de repetir, por ejemplo imaginemos que nuestro programa tenga que imprimir en consola el conteo de 1 a 100, si lo hiciéramos de forma convencional tendríamos que:

System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
...

Esto resulta ineficiente, al ser una operación que es repetitiva debería poder realizarse a través de una estructura de control de flujo, y estos son los bucles, los bucles también llamados iteradores,  permiten la ejecución reiterada de una sentencia o sentencias, ahora bien, los bucles pueden ser de dos tipos, determinados o indeterminados, los determinados se definen básicamente porque conocemos cuántas veces se han de repetir las operaciones (o cuántas iteraciones se han de realizar) mientras que los indeterminados no sabemos con exactitud cuando han de finalizar ya que dependen de una condición booleana (verdadera o falsa) para continuar o finalizar su ejecución. Java posee 3 estructuras de control de flujo de ejecución que son bucles, estos son la estructura For, While y Do While, vamos realizar una revisión del bucle “For“.

La estructura de un bucle for es la siguiente:

for (inicialización; finalización; incremento) {
       sentencias
}
  • Inicialización: Es una expresión, es de donde ha de iniciar el conteo de las iteraciones, podemos utilizar una variable que ya ha sido declarada e inicializada previamente o podemos hacerlo en esta sección (por ejemplo iniciamos en que a=1).
  • Finalización: Es una expresión booleana que se evalúa su condición de verdadero o falso en cada iteración en función a sí el valor de inicialización ya alcanzó un valor final específico (por ejemplo evaluamos si a <100) y mientras no se haya alcanzado dicho valor las iteraciones han de continuar.
  • Incremento: Es invocada luego de la iteración y posterior evaluación, aquí se define la política de incremento del valor de inicialización (por ejemplo hacemos que a tenga un incremento de 1 en 1 o podemos hacer que vaya de 2 en 2).

Nuestro anterior objetivo era el conteo del 1 al 100, entonces esto en la estructura “for” se implementa de la siguiente forma:

for (int i=0;i<100;i++) {
       System.out.println(i);
}

Observemos que hemos declarado e inicializado la variable “i” en la estructura, recuerda que en java siempre debes definir el tipo de dato, un aspecto a tomar en cuenta es que  el alcance de la variable “i” solo estará circunscrito a la estructura y no existe más allá de ella, sé que aún no hemos hablado del alcance de una variable, pero por el momento piensa en el alcance como la existencia de una variable en un programa, con esto quiero decir que fuera de la estructura la variable “i” no existe y podría marcar un error si es que pretendemos hacer uso de ella. Luego definimos que su terminación será cuando “i” ya no cumpla la condición de ser menor que 100, finalmente establecemos la política de incremento que está dada por un aumento de “i” de 1 en 1.

Ahora bien, en Java la inicialización donde se define la variable, no se puede hacer por fuera, si no nosotros hiciéramos:

int i=0;
for ( i; i < 10; i++) {
   System.out.println(i);
}

Esto nos marcaría un error; para poder hacer uso de una variable que ya está definida, lo que debemos de hacer es dejar el espacio en blanco de su inicialización:

int i=0;
for ( ; i < 10; i++) {
   System.out.println(i);
}

Hecha esta salvedad, veamos un ejemplo en el que le preguntamos al usuario que se ejecute un conteo la cantidad de veces que el desee  y que el defina la política de incremento.

import java.util.Scanner;

public class Bucles_1 {

public static void main(String[] args) {
  Scanner entrada=new Scanner(System.in);

  System.out.println("¿Cuántos números desea contar?");
  int cantidad=entrada.nextInt();
  System.out.println("¿Desde dónde desea iniciar?");
  int inicio=entrada.nextInt();
  System.out.println("¿De cuánto en cuánto desea avanzar?");
  int avance=entrada.nextInt();
  entrada.close();

  for(int i=0;i<cantidad;i++) {
    System.out.println(inicio);
    inicio+=avance;
  }
  }

}

¿Qué hemos hecho?, hemos importado la clase Scanner y hemos hecho las consultas a través de la consola, cada entrada de teclado que responde a las preguntas, se almacena en las variables, nos interesa exactamente la cantidad de veces que se ha de iterar, el cómo se avance y de donde se inicie es casi por así decirlo que será implementado mediante un artilugio, luego de ello implementamos la estructura FOR hacemos que se imprima el primer valor que se ha registrado y luego hacemos que se incremente en función del avance que se ha requerido.

El bucle FOR también puede ser usado con cadenas de texto, es decir las cadenas de texto pueden ser iterados a través  de su longitud, la longitud está determinada por la cantidad de caracteres o espacios en blanco que existan dentro de las comillas que la contienen, por ejemplo: “hola” tiene una longitud de 4 ya que son 4 caracteres que la componen, para determinar la longitud de una cadena que es de la Clase String, debemos hacer uso de uno de sus métodos que se define como length. Entonces podemos implementarlo de la siguiente forma, vamos a hacer que se imprima cada uno de los caracteres de la cadena “hola”, para ello también haremos uso del método chartA(index) que nos devuelve el caracter del indice indicado, debemos saber que la cadena si bien es cierto su longitud es de 4 su índice siempre inicia desde el valor cero, es decir que el índice está yendo de 0 a 3 tal que el índice 0 es “h”, 1 es “o” y así sucesivamente, entonces:

String saludo="hola";
for(int i=0;i<saludo.length();i++) {
    System.out.println(saludo.charAt(i));
}

De este modo, hemos visto las posibilidades del uso del bucle for.

 

 

 

 

Java desde Cero -Estructura de Control de Flujo – Switch

Vamos a revisar el segundo condicional de Java, y este es Switch el cual es una estructura de selección múltiple, la siguiente figura ilustra el ejemplo perfectamente:

switch-statement-flowchart

Si lo observamos con detenimiento veremos que es una expresión de condicionales anidados o que al menos puede ser reemplazado por ellos haciendo que su eso no sea de carácter obligatorio cuando nos encontramos en una situación similar, esto provoca que su uso sea menos; sin embargo, como una estructura del lenguaje es necesario explicarlo ya que aunque pueda ser sustituida en ocasiones brinda claridad en la implementación del código. Esta estructura de control de flujo solo puede evaluar números enteros o todo aquello que se pueda llevar a un entero; es decir, no puede evaluar cadenas, sí puede evaluar caracteres y los tipos enumerados, también sufre la restricción de solo evaluar valores concretos de la expresión y no intervalos  ni expresiones compuestas.

La estructura de Switch, está compuesta por múltiples “case” que es donde se evalúa la condición, un break por cada case que detendrá el flujo por switch y retornará al flujo anterior con las sentencias ya ejecutadas dentro de la opción que ha cumplido la condición y por un default que es opcional y que se ejecutará cuando no haya opción alguna que cumpla la condición.

“Hagamos un ejemplo de su uso, por ejemplo una calculadora ( aunque solo itere una sola vez), le pediremos al usuario que ingrese una opción a través de la consola tal que si es 1 entonces será una suma, 2 será una resta, 3 multiplicación y  4 una división“.

Para la entrada de datos por teclado debemos de hacer uso de la clase Scanner y crear una instancia del mismo, luego debemos de realizar la consulta creando un menú tal como se ha propuesto, además de ello debemos de crear dos variable de tipo double (ya que nuestra división podría terminar en decimales y no se podría realizar un adecuado tratamiento de formato con los tipo int), entonces:

package clases;
import java.util.Scanner;
public class Control_switch {

public static void main(String[] args) {
  Scanner entrada= new Scanner(System.in);
  System.out.println("Ingrese una operación \n 1 -Suma \n 2 -Resta \n 3 -Multiplicación \n 4 -División");
  int opcion=entrada.nextInt();
  double a, b;
  //continua con el switch
}}

Observamos que solo hemos declarado las variables a y b mas no las hemos inicializado, recordemos que según el flujo de ejecución toda variable debe ser declarada e inicializada antes de su uso, así que debemos de asegurarnos de ello para no tener saltos de error, otro aspecto a observar es el uso de “\n” esta sintaxis produce un salto de línea, y nos resulta útil en lugar de estar usando demasiados println.

Ahora debemos de implementar la estructura switch, recordemos que la condición (que será un número entero) recorrerá cada uno de los casos hasta encajar en alguno de ellos, en todas las operaciones (suma, resta, multiplicación y división) haremos uso de la instancia de Scanner para solicitar el ingreso de datos y almacenarlos en las variables a y b respectivamente; y al momento de la impresión es donde hemos de ejecutar la operación que se haya elegido; sin embargo, existe un detalle con la opción de división, en la división nosotros vamos a restringir que la salida del resultado sea a dos decimales, ya que podríamos tener un periódico puro o un número bastante inmenso en la parte decimal y no sería elegante, para poder redondear la salida del dato debemos darle formato, entonces debemos de usar el método printf que ya hemos visto anteriormente, entonces tenemos:

switch (opcion) {
  case 1:
     System.out.println("Ingrese el primer número");
     a=entrada.nextInt();
     System.out.println("Ingrese el segundo número");
     b=entrada.nextInt();
     System.out.println("La suma es: "+(a+b));
     break;
 case 2:
     System.out.println("Ingrese el primer número");
     a=entrada.nextInt();
     System.out.println("Ingrese el segundo número");
     b=entrada.nextInt();
     System.out.println("La resta es: "+(a-b));
     break;
  case 3:
     System.out.println("Ingrese el primer número");
     a=entrada.nextInt();
     System.out.println("Ingrese el segundo número");
     b=entrada.nextInt();
     System.out.println("La multiplicación es: "+(a+b));
     break;
  case 4:
     System.out.println("Ingrese el primer número");
     a=entrada.nextInt();
     System.out.println("Ingrese el segundo número");
     b=entrada.nextInt();
     System.out.print("La división es: ");;
     System.out.printf("%1.2f",(a/b));
     break;
  default:
     System.out.println("No ha elegido alguna de las opciones válidas");
     break;
}
entrada.close();

Luego de finalizada las operaciones no olvidemos en cerrar el flujo de datos, nota en la división que hemos dado el formato adecuado a dos decimales, pero para que todo aparezca en una sola línea hemos usado print sin el salto de línea.

Java desde Cero – Estructuras de Control de Flujo – Condicionales

Para hacer referencia a las estructuras de control hay que entender como se ejecuta un programa, el como se ejecuta un programa es conocido como el flujo de ejecución, el cual básicamente es el orden de como se ejecuta nuestro programa, y ese orden por defecto es ir de arriba hacia abajo y secuencial una sentencia a otra; sin embargo, existen estructuras que pueden alterar ese flujo a través de saltos en función del cumplimiento de una condición, condiciones o la repetición de una instrucción o instrucciones una cantidad determinada o indeterminada de veces en función de una condición (estas dos últimas son conocidas como bucles), ahora bien el cumplimiento o no de la condición altera el flujo de ejecución del programa dadas las instrucciones que se implementen en función de cada condición.

Las estructuras de control de flujo de ejecución más básicas son los condicionales “Sí .. entonces” de la lógica proposicional del tipo condicional material que en programación se implementan con la palabra reservada “if“, podemos decir:

v_f_1

 

Es decir, si se cumple la condición se ejecuta y sino la sentencia que contiene no se ejecuta, tanto si se ejecuta o no existe un cambio en el flujo de ejecución, la estructura básica del condicional “if” es la siguiente:

if(condición) {
   sentencias
}

Los condicionales if pueden ser anidados, es decir que puede incluirse otro condicionales if dentro de un condicional if:

if(condicion1) {
      if(condicion2) {
            if(condición3) {
                       ...
            }
    }
}

La condición puede ser una o varias y se expresan a través de los operadores, por ejemplo podríamos decir que un usuario para acceder a una beca debe ser mayor de 18 años y menor que 40 años, ahora la concatenación (conjunción) de las condiciones se realiza con la palabra reservada “&&” por ejemplo sea x la edad implicará que ambas deban ser verdad, entonces:

if(x>=18 && x<=40) {
       System.out.println("Accede a la beca");
}

La disyunción, se expresa con la palabra reservada “||” e implicará que al menos una de las condiciones sea verdadera, por ejemplo sea x una variable que representa un día de la semana tal que si es viernes, sábado o domingo es considerado como el fin de semana:

if(x=="viernes" || x=="sábado" || x=="domingo") {
        System.out.println("Es fin de semana");
}

Un condicional “if” puede ir acompañado (es decir que no es obligatorio) de la instrucción “else” que es el sino, por ejemplo:

if(edad>=18) {
     System.out.println("Eres mayor de edad");
}else {
     System.out.println("No eres mayor edad");
}

Vamos a realizar un ejemplo en el que un usuario ingrese su edad y la edad se evalúe si es adolescente, joven, maduro o anciano en función de unos intervalos, recordemos que la entrada de datos lo hacemos a través de la clase Scanner que ya hemos tratado en un anterior post, entonces:

Scanner entrada=new Scanner(System.in);
System.out.println("Ingrese su edad");
int edad=entrada.nextInt();

if(edad<18) {
    System.out.println("Eres un adolescente");
}
if(edad>=18 && edad<40) {
   System.out.println("Eres Joven");
}
if(edad>=40 && edad<65) {
   System.out.println("Eres maduro");
}
if(edad>=65) {
   System.out.println("Eres un anciano");
}
entrada.close();

Sin embargo este tipo de estructura resulta un poco compleja ya que se debe definir las cotas tanto superior o inferior, además que aprovechamos el flujo de ejecución hasta que encaje dentro de alguna de las condiciones; sin embargo, podemos simplificar usando la palabra reservada “else if” de la siguiente forma:

 Scanner entrada= new Scanner(System.in);
if(edad<18) {System.out.println("Eres adolescente");}
else if (edad<40) {System.out.println("Eres joven");}
else if(edad<65) {System.out.println("Eres maduro");}
else {System.out.println("Eres un anciano");}
entrada.close();

Vemos que lo que ocurre es, si es menor que 18 entra en el primer condicional, si en caso de ser mayor que 18 evaluará la segunda condición que si es menor que 40 y si no evaluará si es menor que 65 y que implícitamente ya se comprobó que es mayor que 40 y así sucesivamente hasta quedar solo la última opción  “else“.

Bueno, esto ha sido lo más básico de los condicionales if que podemos tratar

 

 

Java desde Cero – Entrada y Salida de Datos – Formato de Resultados

Cuando queremos sacar información hacia la consola es común hacer uso de la instrucción:

System.out.println("Lo que queremos que salga");

Sin embargo, si deseamos ingresar datos a través de la consola hacia nuestra aplicación debemos de usar la clase Scanner el cual pertenece al paquete java.util. La clase Scanner posee tres métodos importantes: nextLine, nextInt, nextDouble (en la API puedes encontrar muchos más; sin embargo, podría decirse que estos son los más usados); otra alternativa sencilla es usar la clase JOptionPane y su método showInputDialog (este método es estático, lo cual básicamente indica que el nombre de la clase siempre debe ir por delante de la llamada al método y se verá más adelante). Si deseamos hacer uso de la clase Scanner debemos de importar el paquete útil; sin embargo, existen 2 formas en que podemos realizar esto, podemos importar todo el paquete dentro de los cuales se encuentra la clase Scanner o simplemente importar la clase, yo recomendaría que para un uso más eficiente se importe lo estrictamente necesario aun cuando en nuestros tiempos los espacios en memoria son lo suficientemente grandes, esto obedece más a una cuestión de eficiencia y buena práctica que a la funcionalidad ya que ambas formas funcionarán, entonces te dejo las dos formas:

import java.util.Scanner;
import java.util.*;

Hecha la importación debemos de crear una instancia de la clase, recordemos que java es un lenguaje orientado a objetos, entonces los objetos son tipos de datos referenciados lo que significa que si tenemos una clase el poder usarla requiere que se creen representaciones a las que llamamos instancias que hacen uso de las propiedades y métodos de dicha clase (sé que puede leerse un poco complicado pero a medida que avancemos podremos tener un mejor entendimiento del mismo); la clase Scanner tiene sobrecarga de constructores; es decir, que se puede crear una instancia de distintas formas en función de los parámetros que esta pueda requerir, dentro de los constructores nos interesa la forma en que podemos crear una instancia de clase que tenga como parámetro un flujo de entrada, y esto se obtiene con:

Scanner(InputStream source)

Un flujo de entrada lo obtenemos con la instrucción:

System.in

De la clase System del paquete lang (el paquete por defecto de java y que en consecuencia no requiere ser importado), el cual la entrada de flujo estándar que está abierta y lista para suministrar datos, típicamente este flujo corresponde a las entradas de teclado, entonces en nuestro código usamos:

Scanner entrada= new Scanner(System.in);

Podemos notar el uso de la palabra reservado new, la cual es parte de la sintaxis en la construcción de una instancia de una clase, es decir que siempre que hemos de crear una instancia de cualquier clase hemos de usar dicha palabra reservada.

Cuando tenemos ya la instancia creada vemos que es capaz de realizar un paro del flujo de ejecución a la espera del ingreso de un dato a través de la consola; sin embargo, el usuario no se dará por enterado sino es que se lo anunciamos,  por ejemplo:

Scanner entrada= new Scanner(System.in);
System.out.println("Ingrese un número");
int numero=entrada.nextInt();
System.out.println(numero);

Como puede observarse hemos creado la instancia de la clase y hemos impreso una solicitud que es el que el usuario ingrese un número, hasta que el usuario no presione la tecla ENTER la consola estará a la espera de la entrada de datos (a través del teclado), pero no solo basta con eso ya que por defecto nos retorna un token, debemos de hacer una conversión de ese token a un tipo de dato como una cadena, un entero o un flotante, es ahí que entran a tallar los métodos que hemos mencionado líneas arriba, en nuestro hemos convertido a un número entero a través del método nextInt (puede ser nextLine o nextDouble) lo hemos almacenado en una variable de tipo entero llamada “número”  y luego realizamos una impresión en consola; ahora veamos un ejemplo un poco más complejo:

public static void main(String[] args) {
     Scanner entrada= new Scanner(System.in);
     System.out.println("Ingresa tu nombre");
     String nombre=entrada.nextLine();
     System.out.println("Ahora ingresa tu edad por favor");
     int numero=entrada.nextInt();
     System.out.println("Tu nombre es: "+nombre+" y tu edad es de: "+numero + " años");
     entrada.close();
}  

Observamos que lo nuevo es el uso del método close, este método nos permite cerrar el flujo de entrada de datos, es decir cierra el Scanner, es propio y como buena práctica cerrar todo cuando ya hemos dejado de hacer uso de algún input, hecha esta observación debemos de obtener algo como esto:

e_s_1.png

Ahora bien las salidas pueden seguir diferentes tipos de formatos, imaginemos que tenemos una variable y queremos dividirla entre 3 e imprimir el resultado:

double x=1000.0;
System.out.println(x/3);
//resultado 333.3333333333333

Nosotros podemos dar un formato a la salida de datos, para ello debemos de usar el método printf de la clase PrintStream que se obtiene a través de la clase System y el campo out (al igual que in de entrada out de salida de flujo de datos), este método tiene sobrecarga, pero el que nos interesa es:

printf(String format,Object ... args);

Los tipos de formato los podemos obtener de Format string syntax, entonces por ejemplo si de nuestra división de x quisiéramos que solo se imprima a dos decimales debemos hacer lo siguiente:

System.out.printf("%1.2f", x/3); // resultado 333,33

Puedes experimentar con muchas de los formatos existentes, pero ello ya te lo dejo a tu criterio. Saludos.

Java desde Cero Manejo de Cadenas

En la anterior entrega hablamos un poco sobre las cadenas de textos, mencionamos que si bien es cierto que son del tipo referenciado, es decir una clase, su inicialización se realizaba como un tipo primitivo y aunque en la práctica pareciera que lo son, conceptualmente no lo es, ya que como toda clase lo que se realiza es instanciar un objeto de la clase, y el hecho de ser una clase es que contiene un conjunto de métodos y propiedades, cuando nos referimos a cadenas debe entenderse al conjunto de caracteres como palabras o frases, es cierto que en otros lenguajes las cadenas son tratadas de forma primitiva pero en Java son clases y al ser clases tienen un conjunto de métodos los cuáles podemos observar en la API. La clase String pertenece al paquete java.lang, y este paquete es el paquete importado por defecto en los ficheros de código java.

¿Cuáles son los métodos más usados dentro de la clase String?

  • length(): devuelve la longitud de una cadena de caracteres, es decir de cuantas letras está constituida la palabra contabilizando incluso los espacios en blanco.
  • charAt():devuelve el carácter de la posición que le indiquemos dentro de una cadena.
  • substring(x,y): devuelve una subcadena dentro de la cadena, siendo X el carácter a partir del cual se extrae e Y el número de caracteres que se quieren extraer.
  • equals(cadena): devuelve true si dos cadenas son iguales y distingue entre mayúsculas y minúsculas.
  • equalsIgnoreCase: Similar a la anterior pero sin distinción de mayúsculas.

Si tuviéramos el siguiente caso:

String frase="Hoy es un buen día para morir";
System.out.println(frase.length); // 29
System.out.println(frase.charAt(2)); // y
System.out.println(frase.substring(10,18); //buen día
String nombre1="henry";
String nombre2="Henry";
System.out.println(nombre1.equals(nombre2)); //false
System.out.println(nombre1.equalsIgnoreCase(nombre2)); //true

Esos son los valores que observaríamos desde consola

Concatenado

Una de los usos de java es la concatenación de cadenas a través del operador suma, si nosotros hacemos:

String nombre="Henry";
System.out.println("hola "+nombre); // Hola Henry

Se va imprimir el mensaje que se muestra,  otro detalle es que no importa si nombre no es un String, al imprimirse todo se ha de parsear a una cadena de texto, esto quiere decir que java no es altamente tipificado como en otros lenguajes como python donde primero debes de parsear la variable a un String.

Uso especial de caracteres

También conocidas como secuencias de escape, están formadas por una barra inversa seguida de una letra o de una combinación de dígitos. Una secuencia de escape siempre representa un solo carácter aunque se escriba con dos o más caracteres. Algunas de las secuencias más comunes:

j1

Java desde Cero – Tipos de Datos y Constantes

Tipos de Datos

Para tratar los tipos de datos es necesario entender el concepto de variable, una variable es un espacio en la memoria del ordenador donde se almacenará un valor que podrá cambiar durante la ejecución del programa y esto será vital durante el desarrollo del programa puesto que al crear un programa surge la necesidad de guardar datos temporalmente para su uso en un futuro.

variable-in-java

¿Cómo se crean las variables en java?, pues lo primero es que se debe indicar el tipo de dato de la variable, a este acto se le denomina declarar la variable, luego de ello debemos de asignarle un valor y a este acto se le denomina inicializar la variable, podemos nosotros declarar e inicializar una variable durante todo el flujo del programa; sin embargo, una variable jamás puede ser inicializada sin antes haber sido declarada y no se podrá hacer uso de ella mientras no se haya hecho esos dos pasos. Entonces una variable requiere que se indique el tipo de dato y al indicar el tipo de dato este se almacena en la memoria RAM, es decir que se reserva un espacio en la memoria y la memoria es muy limitada, es cuando entonces la dimensión que le otorguemos a la variable a través del tipo de dato podría afectar su rendimiento acorde a la complejidad que represente nuestro programa, entonces ¿Qué tipos de datos se manejan en java?, podríamos agrupar las tipos de datos en dos grandes segmentos, los tipos primitivos y los tipos referenciados (estos últimos son los relacionados a los objetos y dentro de ellos tenemos a las clases, interfaces y arreglos), dejando por el momento de lado los referenciados, nos hemos de enfocar temporalmente en los primitivos que  en la siguiente tabla se pueden observar:

tipos1

Pero, ¿Qué sucede con la cadena de caracteres?, aunque mencionamos que no lo íbamos a tocar, nos vemos en la obligación para el manejo de caracteres, un String no es un tipo de dato primitivo sino uno referenciado, exactamente un objeto, es por ello que en lugar de inicializar un dato lo que estamos haciendo es crear una instancia de la clase String, y aunque cuando inicializamos una cadena estamos creando un objeto, su inicialización no se diferencia de un tipo de dato primitivo (este tratamiento se dio por el constante uso que se hacia de el), por lo tanto son objetos que disponen de métodos que nos permiten operar sobre la información almacenada en la cadena, era necesario hacer esta aclaración por la formalidad que requiere este tipo de dato.

Las Constantes en Java

Una constante es un espacio en la memoria del ordenador donde se almacenará un valor que no podrá cambiar durante la ejecución del programa. La razón de su existencia obedece al uso recursivo de un dato con un mismo valor  durante varios procesos del programa. Una constante en java se crea utilizando la palabra reservada final, luego se especifica el tipo de dato y el nombre de la constante.

Convenciones

Las variables siguen la siguiente convención, todas las variables inician con minúscula, si son palabras compuestas como: int diablosSenorita la segunda palabra ha de iniciar con mayúsculas a esto se le denomina CamelCase.

En el siguiente gráfico podemos ver ejemplos de los tipos de datos y las constantes:

tipos2