Diferencias

Muestra las diferencias entre dos versiones de la página.

--- bloque3:arrays [09/01/2018 20:18] – [Dimensión de un array] Fernando Valdeón
+++ bloque3:arrays [02/03/2018 14:49] (actual) – borrado Fernando Valdeón
@@ Línea 1: / Línea 1: @@
-====== Arrays ======
-Un array es una estructura de datos **que almacena una cantidad fija de elementos de la misma clase o tipo**. Todos los datos que almacena deben ser del mismo tipo. Una vez creados siempre tienen la misma cantidad de elementos; no pueden crecer. En Java los arrays son objetos al igual que el resto de tipos de datos que veremos a partir de ahora y  funcionan algo distinta a los tipos primitivos.
-{{ :bloque3:arrays.png?300 |}}
-===== Declarar una variable =====
-Las variables de tipo array se declaran así:
-<code java>
-   tipo_de_dato[] identificador;
-   //Ejemplos
-   int[] numerosEnteros;
-   double[] numerosReales;
-   String[] listaCadenas;
-</code>
-Cuando creamos una variable de tipo array no indicamos el tamaño que almacenará, solo el tipo de los datos que contendrá. Puede almacenar cualquier tamaño de array.
-Las variables anteriores no podré usarlas hasta que no contenga la referencia a array. Las variables de tipos de datos que almacenan objetos (no tipos primitivos) se llaman __variables de referencia__.
-===== Crear un objeto array =====
-Para construir un array, igual que ocurre con casi todos los objetos, necesitamos invocar al operador **//new//**:
-<code java>
-int[] enteros = new int[4];           //array con capacidad para 4 enteros (int)
-String[] listaCadenas;
-listaCadenas = new String[200];       //array con capacidad para 200 Strings
-</code>
-También puedo crear un array en el momento de la declaración de su variable, indicando directamente los valores que contiene (luego podrán ser modificados):
-<code java>
-int[] numeros = {4, 6, -435, 65, 0};           //He construido un array de 5 enteros
-String[] nombres = {"Juan", "Pedro", "", "Maria"};   //He construido un array de 4 Strings
-</code>
-**Una vez que indico el tamaño de un array, dicho tamaño no puede ser modificado. Habría que crear otro array.**
-===== Acceder al contenido del array =====
-Accedemos a cada posición del array mediante un **índice que comienza en 0** y va hasta la longitud -1 del array.
-<code java>
-int[] enteros = new int[4];    //Array con tamaño para 4 enteros
-enteros[0] = 23;
-enteros[1] = -3;
-enteros[2] = 2;
-enteros[3] = 0;
-System.out.println("La posición 0 contiene: " + enteros[0])
-System.out.println("La posición 1 contiene: " + enteros[1])
-System.out.println("La posición 2 contiene: " + enteros[2])
-System.out.println("La posición 3 contiene: " + enteros[3])
-</code>
-Para conocer en todo momento en tamaño que tiene un array tenemos la propiedad **__length__**. Así puedo recorrerlo con un bucle **for**.
-<code java>
-//Almacenar datos desde teclado
-for(int i = 0; i < enteros.length; i++){
-  System.out.println("Introduce un número");
-  enteros[i] = input.nextInt();
-}
-//Mostrarlo por consola en una misma linea
-for(int i = 0; i < enteros.length; i++){
-   System.out.print(enteros[i] + " ");
-}
-</code>
-====== Lo más importante de los arrays ======
-El aspecto más importante de los arrays es que son **objetos** y no tipos primitivos.
-Toda variable que no es de un tipo primitivo es una **variable de referencia**.
-Solo hay 8 tipos primitivos (byte, short, int, long, float, double, boolean, char). Todo los demás son objetos.
-**Las variables de referencia no almacenan al objeto (valor) sino la referencia (dirección de memoria) de ese objeto.**
-<code java>
-//Con variables primitivas
-int num1 = 7;
-int num2;
-num2 = num1;
-num2 = 4;
-//En este punto num1 -> 7 y num2 -> 4
-//Con variables de referencia: creo 2 variables, pero solo un array
-int[] enteros1 = new int[4];
-int[] enteros2;
-enteros2 = enteros1;
-//Ambas variables tienen la misma información:
-//Y es la referencia (dirección) a un mismo array. Por ej: @F456AC
-enteros1[0] = 6;
-enteros2[0] = 9;
-//Tanto enteros1[0] como enteros2[0] guardan 9
-//enteros1 -> @F456AC y enteros2 -> @F456AC
-//Ambas variables referencian al mismo array
-//Desde ambas modifico el mismo array
-</code>
-===== Métodos con arrays =====
-Como cualquier otro tipo de datos, los métodos pueden recibir arrays como parámetros o devolverlos como valor de retorno.
-<code java>
-//Método que recibe una referencia a un array
-static void mostrarArrayEnteros(int[] array){
-   for(int i = 0; i < array.length; i++){
-      System.out.print(array[i] + " ");
-}
-//Método que devuelve una referencia a un array
-//Recibe un int que indica la cantidad de Strings que pido al usuario
-static String[] pedirCadenas(int cantidad){
-   String[] cadenas = new String[cantidad];    //Creo un array de Strings
-   Scanner input = new Scanner(System.in);
-   for(int i = 0; i < cantidad; i++){
-      System.out.println("Introduce una cadena");
-      cadenas[i] = input.nextLine();
-   }
-   input.close();
-   return cadenas;   //Devuelvo la referencia al array creado en memoria
-}
-</code>
-Si un método recibe un array y lo modifica, el array quedará modificado para __todas las variables del programa que contengan la misma referencia__.
-===== Dimensión de un array =====
-Un array puede tener todas las dimensiones que se desee. Entendemos la dimensión como el tipo de datos de la variable. Una variable de tipo int[] no puede referenciar un array de tipo int[][].
-<code java>
-int[][] = new int[2][4];     //Array con capacidad para 8 enteros (2 dimesiones)
-char[][][][] = new char[2][3][2][5];   //Array con capacidad para 2x3x4x5 caracteres (4 dimensiones)
-</code>
-Los más comunes son los arrays de **una** dimensión o de **dos** dimensiones (matrices).
-===== Arrays bidimensionales (Matrices) =====
-Las matrices son arrays que tienen 2 dimensiones. Se pueden entender imaginar las filas y las columnas:
-<code java>
-char[][] matrizCaracteres;   //Declaro la variable de referencia
-matrizCaracteres = new char[2][3];  //Creo un array indicando las dimensiones
-int[][] numeros = {{2, 4}, {5, 6}, {-7, -2}};
-</code>
-==== Acceder a las posiciones ====
-Debo utilizar tantos índices como dimensiones tenga el array:
-<code java>
-int[][] matriz = new int[2][3];    //Matriz de enteros de 2x3
-matriz[0][0] = 2;
-matriz[0][1] = 4;
-matriz[0][2] = 4;
-matriz[1][0] = 6;
-matriz[1][1] = 6;
-matriz[1][2] = 9;
-//Leyendo desde teclado
-for(int i = 0; i < matriz.length; i++){
-   for(int j = 0; j< matriz[0].length; j++){
-      System.out.println("Introduce un entero");
-      matriz[i][j] = input.nextInt();
-   }
-}
-//O mediante 2 bucles, mostrandola por filas/columnas
-for(int i = 0; i < matriz.length; i++){
-   for(int j = 0; j< matriz[0].length; j++){
-      System.out.print(matriz[i][j] + " ");
-   }
-   System.out.println();  //Salto de linea
-}
-</code>
-===== Clase Arrays =====
-Los arrays aunque son objetos no se crean a partir de una clase. Sin embargo tenemos una clase que contiene una serie de métodos estáticos que nos ayuda a trabajar con arrays.
-Para saber qué métodos nos ofrece esta clase podemos consultar la API de Java:
-https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html
-Algunos de estos métodos **estáticos** son:
-^ Método ^ Descripción ^ Parámetros que recibe ^ Tipo de datos que devuelve ^
-| boolean **equals**(array1, array2) | Indica si el contenido de ambos arrays es el mismo | Dos arrays del mismo tipo | true si son iguales, false en caso contrario |
-| String **toString**(array) | Devuelve un String con la representación del contenido del array | Un array unidimensional de cualquier tipo| Un String con la representación|
-| void **fill**(array, valor) | Rellena el array con el valor indicado | Un array de cualquier dimensión y un valor del mismo tipo | No devuelve nada |
-| tipo[] **copyOf**(array); | Devuelve otro array que es una copia del indicado | Un array unidimensional  | Un array del mismo tipo que contiene lo mismo que el indicado |
-|tipo[] **copyOfRange**(array, inicio, fin) | Devuelve otro array que es una copia del indicado desde el indice inicio hasta el índice fin | Un array unidimensional y dos enteros indicando el rango | Un array del mismo tipo que contiene una copia del rango indicado |
-| int **binarySearch**(array , valor) | Busca un valor dentro de un array del tipo de valor (El array debe estar ordenado) | Un array y un valor del mismo tipo de datos | int con la posición en la que lo encuentra, o -1 si no. |
-| void **sort**(array) | Ordena el array. Los tipos que contiene deben ser ordenables (primitivos, u objetos con compereTo() | Un array unidimensional de cualquier tipo | No devuelve nada |
-<code java>
-//Compruebo si los arrays contienen lo mismo
-if(Arrays.equals(enteros1, enteros2)){
-   System.out.println("Contienen los mismos valores");
-}
-//Copio el array enteros1 y guardo la referencia en la variable copiaEnteros
-int[] copiaEnteros = Arrays.copy(enteros1);
-//Relleno la matriz con el caracter '*'
-char[][] caracteres = new char[50][100];
-Arrays.fill(caracteres, '*');
-//Muestro por pantalla una representacion del array
-int[] numeros = {-4, 6, 0, -34};
-System.out.println(Arrays.toString(numeros));
-</code>
-----
-(c) {{date> %Y}} Fernando Valdeón