Curso java: 5 ejercicios para mejorar tus skills

El conocimiento de la programación Object-Oriented pasa por uno de los lenguajes de programación más usados del mundo, desde hace años, como es el lenguaje Java.

Aprender Java permite a un aspirante a programador informático aprender completamente el paradigma de la programación orientada a objetos, ya que el lenguaje Java es uno de los precursores de este paradigma, así como uno de los lenguajes a través de los cuales es más fácil aprenderlo.

¿Para qué sirve Java?

El lenguaje Java tiene muchas aplicaciones, incluido el desarrollo de juegos (piensa en Minecraft), creación de aplicaciones de Android, Cloud Computing e IoT (Internet of Things). Es más raro verlo aplicado a contextos como la inteligencia artificial o el desarrollo web (mediante framework).

La programación en Java ayuda mucho a un desarrollador novato a comprender la programación informática y la lógica detrás de ella. Para ello, la práctica se vuelve fundamental para aprender el lenguaje Java en sintaxis y semántica.

Para practicar, haremos 5 ejercicios de Java a resolver, de dificultad gradual, para comprender tanto los conceptos más básicos como los más avanzados de este lenguaje de programación.

1. Escribe un script en Java que lea un número entero positivo y cuenta la cantidad de dígitos en el número de input.
2. Escribe un programa en Java para convertir un objeto de tipo String en int, long, float y double.
3. Escribe un programa en Java para generar el valor de una clave específica en una construcción Map. (usar HashMap)
4. Escribe un programa en Java para ordenar un array de enteros usando el algoritmo Bubble Sort.
5. Escribe un programa en Java para imprimir todos los elementos de una ArrayList usando las posiciones (índices) de los elementos.

Hay tantas construcciones en Java que se necesita aprender, usar y aprovechar para modelar datos. La escritura es muy predominante en Java, por lo que con estos 5 ejercicios comprenderás de inmediato lo crucial que es aprender sintaxis y saber modelar no solo datos, sino también tipos de datos, convirtiéndolos y administrándolos a través de una estructura de datos.

Intenta resolver estos ejercicios sin mirar la solución (que estará presente al final del artículo).

1. La solución de este ejercicio implica un uso sólido de la statement condicional if-else-if para asegurarse de que una condición, explícita en el código Java, sea verdadera o falsa y obtener el output deseado.

 1. import java.util.Scanner;

 2. public class Exercise1 {

 3.  

 4.    public static void main(String[] args)

 5.     {

 6.         Scanner in = new Scanner(System.in);

 7.         System.out.print("Introduce en input número entero inferior a diez mil millones: ");

 8.  

 9.         if (in.hasNextLong())

10.         {

11.  

12.             long n = in.nextLong();

13.  

14.             if (n < 0)

15.             {

16.                 n *= -1;

17.             }

18.             if (n >= 10000000000L)

19.             {

20.                 System.out.println("El número es igual o más grande que 10,000,000,000!");

21.             }

22.             else

23.             {

24.                 int digits = 1;

25.                 if (n >= 10 && n < 100)

26.                 {

27.                     digits = 2;

28.                 }

29.                 else if (n >= 100 && n < 1000)

30.                 {

31.                     digits = 3;

32.                 }

33.                 else if (n >= 1000 && n < 10000)

34.                 {

35.                     digits = 4;

36.                 }

37.                 else if (n >= 10000 && n < 100000)

38.                 {

39.                     digits = 5;

40.                 }

41.                 else if (n >= 100000 && n < 1000000)

42.                 {

43.                     digits = 6;

44.                 }

45.                 else if (n >= 1000000 && n < 10000000)

46.                 {

47.                     digits = 7;

48.                 }

49.                 else if (n >= 10000000 && n < 100000000)

50.                 {

51.                     digits = 8;

52.                 }

53.                 else if (n >= 100000000 && n < 1000000000)

54.                 {

55.                     digits = 9;

56.                 }

57.                 else if (n >= 1000000000 && n < 10000000000L)

58.                 {

59.                     digits = 10;

60.                 }

61.                 System.out.println("Dígitos en el número entero: " + digits);

62.             }

63.         }

64.         else

65.         {

66.             System.out.println("El número no es un número entero");

67.         }

68.     }

69. }

70.  

2. Escribir en el lenguaje Java es muy fuerte. Saber convertir los distintos tipos de datos de forma que se adapten a tus necesidades es una práctica muy útil. String, int, float, boolean, son todos tipos de datos que deben hacerse explícitos al declarar una variable o devolver un valor de una función específica.

 1. public class Main {

 2.    public static void main(String[] args) {

 3.         String STR_TO_INT = "1323";

 4.         String STR_TO_LONG = "13625478965325";

 5.         String STR_TO_FLOAT = "25.135F";

 6.         String STR_TO_DOUBLE = "21.25478254D";

 7.         

 8.        System.out.println("Convierte String en int/Integer:");

 9.        Integer toInt1 = Integer.valueOf(STR_TO_INT);

10.        int toInt2 = Integer.parseInt(STR_TO_INT);

11.        System.out.println("\"" + STR_TO_INT + "\"" + " como int corresponde a "

12.                + toInt1 + " y como Integer corresponde a " + toInt2);

13.                 

14.        System.out.println("\n Convierte String en long/Long:");

15.        Long toLong1 = Long.valueOf(STR_TO_LONG);

16.        long toLong2 = Long.parseLong(STR_TO_LONG);

17.        System.out.println("\"" + STR_TO_LONG + "\"" + " como long corresponde a "

18.                + toLong1 + " y como Long corresponde a " + toLong2);

19.        System.out.println("\n Convierte String en float/Float:");

20.        Float toFloat1 = Float.valueOf(STR_TO_FLOAT);

21.        float toFloat2 = Float.parseFloat(STR_TO_FLOAT);

22.        System.out.println("\"" + STR_TO_FLOAT + "\"" + " como float corresponde a "

23.                + toFloat1 + " y como Float corresponde a " + toFloat2);

24.                 

25.        System.out.println("\n Convierte String en double/Double:");

26.        Double toDouble1 = Double.valueOf(STR_TO_DOUBLE);

27.        double toDouble2 = Double.parseDouble(STR_TO_DOUBLE);

28.        System.out.println("\"" + STR_TO_DOUBLE + "\"" + " como double corresponde a "

29.                + toDouble1 + " y como Double corresponde a " + toDouble2);

30.    }

31. }

32.  

3. Java tiene muchas construcciones y colecciones para administrar datos. Estos son necesarios cuando tienes que realizar tareas específicas o gestionar datos de diferente tipo a través de una única estructura. En este ejercicio puedes aprender y comprender el uso de HashMap.

 1. import java.util.*;  

 2. public class Exercise3 {  

 3.     public static void main(String args[]){  

 4.    HashMap<Integer,String> hash_map= new HashMap<Integer,String>();  

 5.    hash_map.put(1,"Red");

 6.   hash_map.put(2,"Green");

 7.   hash_map.put(3,"Black");

 8.   hash_map.put(4,"White");

 9.   hash_map.put(5,"Blue");

10.      // get value of key 3

11.    String val=(String)hash_map.get(3); 

12.    // check the value

13.    System.out.println("El valor para la clave 3 es: " + val);

14.  }

15. }

4. Bubble Sort es un algoritmo de clasificación popular. Los números guardados en una lista se escanean, se compara cualquier par de elementos adyacentes y los dos elementos se intercambian si no están ordenados. Este proceso iterativo se realiza hasta que toda la lista de datos se ordena de acuerdo con la condición explícita. Dado que Java tiene tantas colecciones, matrices y formas de crear listas de datos, la capacitación en algoritmos de clasificación es un buen hábito para familiarizarse no solo con la lógica de la programación, sino también con la escritura de código un poco más complejo.

 1. import java.util.Arrays;

 2. class BubbleSort

 3. {

 4.     void bubbleSort(int nums[])

 5.     {

 6.         int n = nums.length;

 7.         for (int i = 0; i < n-1; i++)

 8.             for (int j = 0; j < n-i-1; j++)

 9.                 if (nums[j] > nums[j+1])

10.                 {

11.                     // swap temp and nums[i]

12.                     int temp = nums[j];

13.                     nums[j] = nums[j+1];

14.                     nums[j+1] = temp;

15.                 }

16.     }

17.  

18.     // Method to test above

19.     public static void main(String args[])

20.     {

21.         BubbleSort ob = new BubbleSort();

22.         int nums[] = {7, -5, 3, 2, 1, 0, 45};

23.         System.out.println("Array originale:");

24.         System.out.println(Arrays.toString(nums));

25.         ob.bubbleSort(nums);

26.         System.out.println("Array ordinato: ");

27.         System.out.println(Arrays.toString(nums));

28.     }

29. }

5. Otra colección extremadamente útil en Java es ArrayList. La clase ArrayList corresponde a un array redimensionable, que se puede encontrar en el paquete java.util. La diferencia entre una matriz integrada y una ArrayList en el lenguaje Java es que el tamaño de un array no se puede cambiar (si se desea agregar o eliminar elementos de un array, se debe crear uno nuevo). Es básicamente un array mucho más versátil.

 1. import java.util.ArrayList;

 2.   public class Exercise5 {

 3.     public static void main(String[] args) {

 4.   ArrayList <String> c1 = new ArrayList <String> ();

 5.   c1.add("Red");

 6.   c1.add("Green");

 7.   c1.add("Black");

 8.   c1.add("White");

 9.   c1.add("Pink");

10.   System.out.println("\n ArrayList originale: " + c1);

11.   System.out.println("\n Imprime usando el índice de un elemento: ");

12.   int no_of_elements = c1.size();

13.   for (int index = 0; index < no_of_elements; index++)

14.    System.out.println(c1.get(index));

15.  }

16. }

Descuidar la práctica en la programación informática es un gran error. El uso de ejercicios de coding online representa el enfoque correcto para familiarizarse con la escritura de código, la comprensión de la sintaxis y la semántica, que obviamente cambian para cada lenguaje. Practicar en las cosas más simples, entendiendo la lógica detrás de ellas, hará menos difícil el camino para asimilar los conceptos más complejos de un lenguaje de programación o un paradigma de programación. ¿Listo/a para empezar?