Practica 0301

Métodos en Java

Los métodos en Java nos sirven para ejecutar instrucciones mediante unos parámetros que nosotros le damos (a veces, no es necesario incluir parámetros).

Los métodos se definen fuera del main, debemos de indicarle que es lo que queremos que  tipo de dato o referencia devuelva, ya sea un int, String, un objeto, un array, etc, después el nombre del método y por último los parámetros que utilizara el método, estos parámetros son los valores que le daremos desde el main. 

Esta es su sintaxis:

[Modificador de acceso] [Otros modificadores] Valor_retorno nombre_método (parámetros){

      instrucciones

}

Veamos un ejemplo de su definición, recuerda que lo hacemos fuera del main:

1

2

3

4

5

6

7

8

9

10

public class PruebaApp {

    public static void main(String[] args) {

    }

    public static int sumaNumeros (int num1, int num2){

    }

}

Lo de public (o private) y static, ya que lo veremos con más detalles cuando veamos la programación orientada a objetos. También hemos puesto que devuelva un int, cuando ponemos que devuelva un valor, debemos poner algún return con el tipo de valor que ponemos a devolver. En return podemos poner una fórmula o una variable. Sigamos con el ejemplo:

1

2

3

4

5

6

7

8

9

10

11

12

public class PruebaApp {

    public static void main(String[] args) {

    }

    public static int sumaNumeros (int num1, int num2){

        int resultado=num1+num2;

        return resultado;

    }

}

También podríamos escribir return num1+num2; no es estrictamente necesario colocar un return al final, aunque es lo más normal, cuando ejecuta la línea de código return, sale del método devolviendo el valor.

Ya tenemos el método, pero ahora debemos invocarlo en el main, ya que sino no serviría de nada. Para invocarlo, escribimos el nombre en el main y le pasamos los parámetros que necesite, no podemos ni quitarle ni añadirle mas de los que necesita, ya que sino dará un error en la compilación. Sigamos con el ejemplo:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

public class PruebaApp {

    public static void main(String[] args) {

        int operador1=3;

        int operador2=5;

        sumaNumeros(operador1, operador2);

    }

    public static int sumaNumeros (int num1, int num2){

        int resultado=num1+num2;

        return resultado;

    }

}

Como vemos, no es necesario que el nombre de los parámetros del método (parámetros formales)  sean iguales a los parámetros con los que invocamos el método (parámetros actuales).

Solo nos falta un detalle, almacenar el resultado del método, ya que ahora mismo no estamos haciendo nada con él. Sigamos con el ejemplo:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public class PruebaApp {

    public static void main(String[] args) {

        int operador1=3;

        int operador2=5;

        int resultado=sumaNumeros(operador1, operador2);

        System.out.println("El resultado de la suma es "+resultado);

    }

    public static int sumaNumeros (int num1, int num2){

        int resultado=num1+num2;

        return resultado;

    }

}

Antes hemos comentado que no es necesario que devuelva un tipo de valor, puede no devolver nada, esto se suele usar cuando no necesitamos manejar algún valor calculado en el método. Por ejemplo, mostrar un mensaje. Al no devolver ningún valor, no debemos poner return y no es necesario almacenar el resultado del método como hemos visto antes.

Para indicar al método que no devuelva nada, en el valor devuelto escribimos void.  Veamos un ejemplo con el ejemplo anterior:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

public class PruebaApp {

    public static void main(String[] args) {

        int operador1=3;

        int operador2=5;

        sumaNumeros(operador1, operador2);

    }

    public static void sumaNumeros (int num1, int num2){

        int resultado=num1+num2;

        System.out.println("El resultado de la suma es "+resultado);

    }

}

Por último, les quiero mostrar algo que debemos tener muy en cuenta, que nos suele pasar a todos al empezar.

Imaginemos que manejamos dentro del método una estructura condicional (como un if), si ponemos un return dentro de este if, seguramente nos salte un error, ya que debemos controlar que si no se introduce en el if debemos devolver algo.

Veamos un ejemplo, devolviendo un booleano, según sea positivo o negativo el resultado:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

public class PruebaApp {

    public static void main(String[] args) {

        int operador1=3;

        int operador2=5;

        if (sumaNumeros(operador1, operador2)){

            System.out.println("El resultado es mayor que 0");

        }else{

            System.out.println("El resultado es menor que 0");

        }

    }

    public static boolean sumaNumeros (int num1, int num2){

        int resultado=num1+num2;

        if (resultado>=0){

            return true;

        }else{

            return false;

        }

    }

}

Podemos tener tantos métodos como queramos, lo más recomendable es usar métodos en acciones que repitamos mucho y queramos automatizar.

Practica 0302

 

Los arrays son colecciones de datos que agrupan una serie de variables del mismo tipo.

Cuando creamos un array se reserva automáticamente memoria, al iniciar un array debemos indicar su tipo y tamaño, este tamaño no puede variar durante la ejecución. El tamaño debe ser un número entero positivo.

Para crear un array usamos new, veamos su sintaxis para definirlo:

Tipo_dato nombre_array[ ]=new tipo_dato[tamaño];

Veamos un ejemplo:

public class PruebaApp {

            public static void main(String[] args) {

                        //Definimos un array con 10 posiciones

                        int num[]=new int[10];

            }

}

También podemos asignar directamente sus valores, indicándolo entre llaves, los valores irán separados por comas. Por ejemplo:

Tipo_dato nombre_array[]={valor1, valor2, valor3 };

public class PruebaApp {

            public static void main(String[] args) {

                        //Definimos un array con 5 posiciones

                        int num[]={5, 6, 5, 2, 3};

            }

}

Al tener un array creado, se rellenan por defecto, por ejemplo, si es un array de int se rellenan con 0, si es un array de String se rellenan con null, ya que String es una clase en realidad.

Para acceder a una posición, debemos indicar la posición mediante un numero entero entre corchetes. Veamos un ejemplo:

public class PruebaApp {

            public static void main(String[] args) {

                        //Definimos un array con 10 posiciones

                        int num[]=new int [10];

                        num[0]=5;

                        num[1]=9;

                        System.out.println(num[0]);

                        System.out.println(num[1]);

            }

}

Un array empieza en 0 y acaba en la posición tamaño-1, por ejemplo, si creamos un array de 10 posiciones, las posiciones irán del 0 al 9. Si colocamos una posición fuera de este rango, nos aparecerá el error ArrayIndexOutOfBoundsException.

Para recorrer un array usamos un bucle, donde lo único que variaremos sera la posición.

Veamos un ejemplo de rellenar un array de 10 posiciones con múltiplos de 5.

public class PruebaApp {

            public static void main(String[] args) {

                        //Definimos un array con 10 posiciones

                        int num[]=new int [10];

                        //Recorremos el array

                        //array.lenght indica la longitud del array, en este caso, devuelve 10

                        for (int i=0, multiplo=5;i<num.length;i++, multiplo+=5){

                                     num[i]=multiplo;

                                     System.out.println(num[i]);

                        }

            }

}

Como vemos en el ejemplo anterior, para saber la longitud del array usamos el atributo lenght.

 

Practica 0303

Programa que lee por teclado la nota de los alumnos de una clase y calcula la nota media del grupo. También muestra los alumnos con notas superiores a la media. El número de alumnos se lee por teclado.

Este programa utiliza un array de elementos de tipo double que contendrá las notas de los alumnos. 

El tamaño del array será el número de alumnos de la clase, por lo tanto primero se pedirá por teclado el número de alumnos y a continuación se creará el array.

Se realizan 3 recorridos sobre el array, el primero para asignar a cada elemento las notas introducidas por teclado, el segundo para sumarlas y calcular la media y el tercero para mostrar los alumnos con notas superiores a la media.

import java.util.*;

public class MediaDeLaClase {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int numAlum, i;

        double suma = 0, media;

        //Lectura del número de alumnos. Debe ser un valor positivo

        do {

            System.out.print("Número de alumnos de la clase: ");

            numAlum = sc.nextInt();

        } while (numAlum <= 0);

        //se crea un array llamado notas de numAlumn elementos de tipo double

        double[] notas = new double[numAlum]; 

       

        // Entrada de datos. Se lee la nota de cada alummo y se guarda

        // en cada elemento del array

        for (i = 0; i < notas.length; i++) {

            System.out.print("Alumno " + (i + 1) + " Nota final: ");

            notas[i] = sc.nextDouble();

        }

        // Sumar todas las notas

        for (i = 0; i < notas.length; i++) {

            suma = suma + notas[i];

        }

        // Calcular la media

        media = suma / notas.length;

        // Mostrar la media

        System.out.printf("Nota media del curso: %.2f %n", media);

        // Mostrar los valores superiores a la media

        System.out.println("Listado de notas superiores a la media: ");

        for (i = 0; i < notas.length; i++) {

            if (notas[i] > media) {

                System.out.println("Alumno numero " + (i + 1)+ " Nota final: " + notas[i]);

            }

        }

    }

}

P0304

Programa que crea un array de 20 elementos llamado Pares y guarde los 20 primeros números pares. Mostrar por pantalla el contenido del array creado. 

P0305

Programa Java que guarda en un array 10 números enteros que se leen por teclado. A continuación se recorre el array y calcula cuántos números son positivos, cuántos negativos y cuántos ceros.

 // Contar el número de elementos positivos, negativos y ceros de un array de 10 elementos.

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int[] numeros = new int[10];

        int pos = 0, neg = 0, cero = 0; //contadores

        int i;

       
//Leemos los valores por teclado y los guardamos en el array

        System.out.println("Lectura de los elementos del array: ");

        for (i = 0; i < numeros.length; i++) {

            System.out.print("numeros[" + i + "]= ");

            numeros[i] = sc.nextInt();

        }

        //se recorre el array para contar positivos, negativos y ceros

        for (i = 0; i < numeros.length; i++) {

            if (numeros[i] > 0) {

                pos++;

            } else if (numeros[i] < 0) {

                neg++;

            } else {

                cero++;

            }

        }

        //mostrar resultados

        System.out.println("Positivos: " + pos);

        System.out.println("Negativos: " + neg);

        System.out.println("Ceros: " + cero);

    }

}

P0306

Programa Java que llene un array con 10 números enteros que se leen por teclado. A continuación calcula y muestra la media de los valores positivos y la de los valores negativos del array.

P0307

Programa Java para leer la altura de N personas y calcular la altura media. Calcular cuántas personas tienen una altura superior a la media y cuántas tienen una altura inferior a la media. El valor de N se pide por teclado y debe ser entero positivo.

/*

 * Leer la altura de N personas y calcular la altura media

 * Mostra cuántos hay superiores a la media.

 */

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int i, N;

        int contMas = 0, contMenos = 0;

        double media = 0;

        //Leer el número de personas

        Do

{

                   System.out.print("Número de personas: ");

                   N = sc.nextInt();

          }while(N<=0);

        //Se crea el array de tamaño N

        double[] alto = new double[N];

        //Leer alturas

        System.out.println("Lectura de la altura de las personas: ");

        for (i = 0; i < N; i++)

{

            System.out.print("persona " + (i+1) + " = ");

            alto[i] = sc.nextDouble();

            media = media + alto[i]; //se suma la estatura leída para calcular la media

          }

        //Calcular la media

        media = media / N;

        //recorremos el array para ver cuantos hay más altos

        //que la media y cuantos más bajos

        for (i = 0; i < alto.length; i++) {

            if (alto[i] > media){ //si la estatura es mayor que la media

                contMas++;

            } else if (alto[i] < media){ //si es menor

                contMenos++;

            }

        }

        //Mostrar resultados

        System.out.println("Estatura media: " + media);

        System.out.println("Personas con estatura superior a la media: " + contMas);

        System.out.println("Personas con estatura inferior a la media: " + contMenos);

    }

}

P0308

Ejercicios Arrays Java. Leer nombre y sueldo de 20 empleados y mostrar el que más gana

Programa Java que lea el nombre y el sueldo de 20 empleados y muestre el nombre y el sueldo del empleado que más gana.

Para hacerlo utilizaremos dos arrays:

Un array de String para los nombres de los empleados

Un array de tipo double para los sueldos de cada empleado.

Al mismo tiempo que leemos los datos de los empleados iremos comprobando cuál es el que tiene el mayor sueldo. Para ello tomamos el sueldo del primer empleado que se lee como mayor sueldo y después vamos comprobando el resto de sueldos. Cuando encontramos alguno mayor que el mayor actual este sueldo se convierte en el nuevo mayor.

En general para calcular el mayor de una serie de números tomamos el primero como mayor y después comparamos el resto de números.

P0309: Llenar un array con números aleatorios

En esta entrada vamos a escribir un método Java que llene un array de enteros con números aleatorios.

Los números aleatorios deberán estar comprendidos entre dos límites (desde,  hasta) ambos incluidos.

El método recibe como parámetros los valores desde, hasta y el tamaño del array.
El método devuelve mediante return el array de enteros creado.

Para obtener números enteros aleatorios usaremos el método nextInt() de la clase Random.
Para que los números aleatorios obtenidos estén dentro de los limites utilizaremos el método nextInt() de la siguiente fórma: nextInt(hasta - desde + 1) + desde

public static int [] llenarArrayAleatorio(int desde, int hasta, int tam){

        int[] numeros = new int[tam];

        Random rnd = new Random();

        for (int i = 0; i < numeros.length; i++) {

            numeros[i] = rnd.nextInt(hasta - desde + 1) + desde;

        }

        return numeros;       

}

Si los números no se pueden repetir debemos complicar un poco más el código.
En este caso cada vez que se obtiene un número aleatorio se debe comprobar si ya está en el array.

Para hacer este trabajo vamos a escribir un método llamado comprobarSiContiene. A este método se le envía el array, la posición del elemento actual y el número aleatorio a insertar y devuelve true si el número ya existe en el array. En ese caso se vuelve a sacar otro número aleatorio.

public static int[] llenarArrayAleatorio(int desde, int hasta, int tam) {

        int[] numeros = new int[tam];

        Random rnd = new Random();

        int n;

        for (int i = 0; i < numeros.length; i++) {

            do {

                n = rnd.nextInt(hasta - desde + 1) + desde;

            } while (comprobarSiContiene(numeros, i, n));

            numeros[i] = n;

        }

        return numeros;

}

public static boolean comprobarSiContiene(int[] numeros, int indice, int valor) {

        for (int i = 0; i < indice; i++) {

            if (numeros[i] == valor) {

                return true;

            }

        }

        return false;

}

Esta sería la solución para aquellos que están empezando a programar. Pero en este caso nos podemos ahorrar trabajo utilizando la API de Java. En concreto utilizando un ArrayList y el método shuffle de Collections.

La idea es llenar un ArrayList con todos los números comprendidos entre los límites desde/hasta. A continuación se llama al método shuffle para desordenarlos y después se pasan al array de enteros los tam primeros elementos, donde tam es el tamaño del array a devolver.

El método utilizando el ArrayList y Collections.shuffle quedaría así:

private static int[] llenarArrayAleatorio(int desde, int hasta, int tam) {

        ArrayList<Integer> array = new ArrayList<Integer>();

        for (int i = desde; i <= hasta; i++) {

            array.add(i);

        }

        Collections.shuffle(array);

        int [] numeros = new int[tam];

        for(int i = 0; i<numeros.length; i++){

            numeros[i]=array.get(i);

        }

        return numeros;

}

P0310

Ejemplo de ArrayList en Java

Ejemplo de uso de un ArrayList:

Programa Java que pida por teclado las alturas de N alumnos de una clase y las guarde en un ArrayList de tipo Double. A continuación el programa calculará cuantos alumnos hay más altos que la media y cuantos más bajos.

Para resolverlo vamos a utilizar 4 métodos además del método main:

Método numeroAlumnos(): este método pide por teclado el número de alumnos de la clase y devuelve dicho número al programa principal.

Método leerAlturas(): pide por teclado las alturas de los N alumnos y las almacena en el ArrayList. Este método recibe como parámetros el ArrayList inicialmente vacío y el número de alumnos a leer.

Método calcularMedias(): calcula y devuelve la media de los alumnos de la clase. Este método recibe como parámetro el ArrayList con las alturas de todos los alumnos.

Método mostrarResultados(): muestra por pantalla todas las alturas y calcula y muestra el número de alumnos con altura superior e inferior a la media. Recibe como parámetros el ArrayList con las alturas de todos los alumnos y la media calculada anteriormente.

Solución:

import java.util.ArrayList;

import java.util.Scanner;

public class Main {

   public static void main(String[] args) {

      //creamos el ArrayList que contendrá la altura de los alumnos

      ArrayList<Double> altura = new ArrayList();

      int N;

      double media;

      //obtenemos el número de alumnos de la clase

      N = numeroAlumnos();

      //leemos la altura de los N alumnos

      leerAlturas(altura, N);

      //calculamos la media

      media = calcularMedia(altura);

      //mostramos los resultados

      mostrarResultados(altura, media);

   }

   //Método para pedir por teclado el número de alumnos de la clase

   public static int numeroAlumnos() {

      Scanner sc = new Scanner(System.in);

      int n;

      do {

            System.out.print("Introduce número de alumnos: ");

            n = sc.nextInt();

      } while (n < 1);

      return n;

   }

   //Este método recibe el ArrayList y el número de alumnos de la clase

   //Pide por teclado la altura de todos los alumnos y las guarda en el ArrayList

   public static void leerAlturas(ArrayList<Double> a, int n) {

      Scanner sc = new Scanner(System.in);

      int i;

      double alto;

      for (i = 1; i <= n; i++) {

           do {

                 System.out.print("Alumno " + i + " altura: ");

                 alto = sc.nextDouble();

           } while (alto <= 0);

           a.add(alto); //añade la altura al final del ArrayList

      }

  }

   //Este método recibe el ArrayList con todas las alturas

   //calcula y devuelve la media

   public static double calcularMedia(ArrayList<Double> a) {

      double media = 0;

      for (Double d : a) {

            media = media + d;

      }

      return media / a.size();

   }

   //Muestra la altura de todos los alumnos, la media y calcula y muestra

   //cuantos alumnos hay con altura superior a la media

   //y cuántos con altura inferior

   public static void mostrarResultados(ArrayList<Double> a, double media) {

      int superior = 0, inferior = 0;

      System.out.println("alturas introducidas: ");

      System.out.println(a);

      for (Double d : a) {

            if (d > media)

                superior++;

            else if (d < media)

                       inferior++;

      }

      System.out.printf("Media: %.2f %n", media);

      System.out.println("Hay " + superior + " alumnos más altos que la media");

      System.out.println("Hay " + inferior + " alumnos más bajos que la media");

   }

}

P0311

Rotar un ArrayList en Java

Método para desplazar todos los componentes de un Array un lugar a la derecha. El último elemento pasará a la primera posición.

Ejemplo, si el Array original contiene los siguientes valores:

15

22

4

56

71

10

2

Se realizarán los siguientes desplazamientos:

https://1.bp.blogspot.com/-DQXMbQz0SAM/VrUMDzTdrvI/AAAAAAAAAfU/nCKCXJiXvqs/s1600/ArrayList-desplazar-derecha-componentes.jpg

De forma que el contenido final de Array sea este:

2

15

22

4

56

71

10

En este caso el contenedor será un ArrayList. El método recibirá un ArrayList de tipo Integer con una serie de valores numéricos y devolverá el mismo ArrayList con sus elementos desplazados una posición a la derecha. Los desplazamientos se realizarán sobre el mismo array. No se puede utilizar un array auxiliar para reailzar el proceso.

Solución:

Vamos a resolverlo de dos maneras. La primera será el método que podríamos llamar clásico para rotar las componentes de un array que consiste en  guardar el último elemento del array en una variable auxiliar, a continuación desplazar todos los elementos una posición a la derecha desde el final hasta el principio del array y por último asignar al primer elemento el valor guardado en el auxiliar.