Jyoc java-cap04 vectores (arrays)

TemariodecursoJavaSE©IñakiMartín
4.- Arrays (Vectores)
©
Iñaki Martín
1
TEMARIO DE CURSO
PROGRAMACIÓN JAVA SE
CAPÍTULO 4
ARRAYS (VECTORES)
© Iñaki Martín
Este obra está bajo una licencia de Creative Commons Reconocimiento-NoComercial-SinObraDerivada 4.0 Internacional.

©
Iñaki Martín
Arrays: Resumen
array:Métodos_atributos int [] arr1 = new int9];
int length Devuelve el tamaño de array1 (nº de elementos)
array clone() Devuelve un array copia del actual
Array:crear
int[] array1 = new int [9] //crea array de 9 in
int[] array2 = {4,1,8,36} //crea array de 4 int
int[][] mat1 = new int [3][4]; //crea matriz 3x4
Array:recorrer
int[] array3 = {4,1,8,36};
for(int i=0;i< array3.length;i++){
System.out.println( array3[i] );
}
Matriz:recorrer
int[][] mat2={{4,1,8,36}{4,1,8,36}};
for(int f=0;f< mat2.length; f++){
for(int c=0;c< mat2[f].length; c++){
System.out.print( mat2 [f][c]) ;
}
}
Clase_Arrays:Métodos
int [] arr1 = new int9];
(nada) Arrays.sort(arr1)
Ordena arr1 (si el contenido
se puede ordenar)
array Arrays.equals(arr1,arr2)
Indica si los arrays son
iguales (contenido y orden)
String Arrays.copyOf(arr1,tam)
Devuelve una copia de arr1
de tamaño tam
String Arrays.copyOfRange(arr1,ini,fin)
Devuelve una copia de arr1
desde la posición ini
(incluido) hasta fin (excluido)
int Arrays.fill(arr1,cont)
Rellena todo el arra arr1 con
el contenido cont
String Arrays.toString(arr1)
Devuelve el array arr1 como
un String
Array:ordenar(burbuja)
// version más simple de todas
int[] datos = {4, 1, 8, 36,0,33,11,43};
for(int i=0; i<datos.length-1 ; i++){
for(int j=0; j<datos.length-1; j++){
if (datos[j] > datos[j+1]) {
int aux = datos[j+1];
datos[j+1] = datos[j];
datos[j] = aux;
}
}
}
2
// version más correcta
boolean huboCambio = true;
while (huboCambio){
huboCambio = false;
for(inti=0;i<datos.length-1;i++){
if(datos[i]>datos[i+1]){
int aux = datos[i];
datos[i] = datos[i+1];
datos[i+1] = aux;
huboCambio = true;
}
}
}

©
Iñaki Martín
๏ Hasta ahora, al crear variables de algún tipo, en la variable solo se podía guardar un único valor.
๏ Un Array (Vector en castellano) es casi una variable normal, solo que en vez de tener un solo valor, tiene
varios. Permite almacenar, con un solo nombre, muchos valores.
๏ Para distinguir entre todos esos valores, se le pone un "apellido" al nombre de la variable, que es un número,
de modo que cada número identifica a cada uno de los diferentes valores de la variable.
๏ Una idea más conceptual para entender los arrays es
imaginar al array como un tren, que tiene vagones numerados, y
que dentro de cada vagón, se almacena un contenido.
๏ Al respecto de este índice, decir que:
‣ para identificar cada “vagón”, se usa el nombre del tren, y añadido, el valor del índice entre [ ]
‣ los índices son siempre números enteros, positivos y correlativos
๏ Por lo tanto, si quisiéramos que la variable anterior tuviera 3 valores diferentes, podría hacerse escribiendo así:
๏ NOTA: En inglés se usa el término array, que se traduce en castellano como Vector (en sudamérica a veces se traduce por “Arreglo”). Nosotros en
este libro optamos por utilizar el término inglés array, no por que nos guste más, sino por ser el más utilizado también en los entornos profesionales.
Array, concepto
Concepto de array (array)
miVariableA[1] = 12; // miVariable es el tren, miVariable[0] el primer vagon, que almacena el número 12;
miVariableA[2] = 242; // miVariable es el tren, miVariable[1] el segundo vagon, que almacena el número 242;
miVariableA[3] = 78; // miVariable es el tren, miVariable[2] el tercer vagon, que almacena el número 78;
12
422
78
381
3
El array es el tren, los elementos del array son cada uno de los
vagones, que tienen un índice (número de vagón) y un contenido

©
Iñaki Martín
๏Para crear (DECLARAR) un array, hay que seguir la siguiente estructura:
๏Con esto se declara el array, esto es, se le dice a la memoria: "Memoria, crea sólo el nombre de una variable
que se llama unVector, y que es de tipo array de integer. Pero aun no lo des tamaño”. Mientras no dimensione,
el valor del array es NULL.
๏Así se declara que va a existir un array, pero no se ha construido aún, pues necesita saber cuántos elementos
va a tener (DIMENSIONAR). Esto es necesario siempre, antes de empezar a dar valores a la variable. Para
decir cuantos valores tiene el array, se puede decir después de declararlo:
que es como decirle: "Memoria, a la variable que tenias ya declarada (unVector) hazle nuevo (new)
sitio para 3 elementos de tipo int"
๏Ahora ya sí se puede ir dando el valor a cada uno de los elementos del array (ASIGNAR), igual que a cualquier
otra variable. Entre los corchetes, se pone el índice del elemento a tratar (el número del vagón del tren):
๏Siguiendo con el ejemplo del tren, el resumen de lo que se ha dicho hasta ahora sería:
Crear un array
Creación de un array
// tipo_del_array [ ] nombre_del_array ;
int [] alfa;
alfa[1] = 23;
alfa[2] = 17;
alfa = new int [3];
4
alfa -> es el TREN COMPLETO
alfa[2] -> es UN VAGON del tren, y el número 2 es el INDICE del array (el número de vagón)

©
Iñaki Martín
๏ Como con las variables normales, se puede declarar y dimensionar (crear) el array en una sola instrucción:
๏ Si se desea dar valores a los elementos del array de uno en uno se puede hacer así:
• Se puede crear el array y a la vez, darle valor a sus elementos, en este caso, no hace falta dimensionarlo,
el array toma el tamaño del número de elementos con los que se inicializa:
• Los elementos de un array se comportan como si fueran una variable normal del tipo elegido.
Esto es, un elemento de un array de int, se comporta como una variable int normal: se puede sumar, asignar…
Trabajando con arrays (I)
Trabajando con arrays
System.out.println("Valor 0 del array tabla1 es “+tabla1[0]); // imprimir por pantalla
System.out.println(tabla1[2]); // imprimir por pantalla
int numeroElegido = tabla1[2]; // asignar a una variable
int numeroduplicado = tabla1[2] * 2; // operar con el elemento
int lasNotas [] = new int [e];
lasNotas[0] = 23;
lasNotas[1] = 145;
lasNotas[2] = 6253;
int tabla1[] = {31, 62, 73, 43} ; // una manera de crear y inicializar un array
int tabla2[] = new int[] {1,2,3}; // otra manera de crear y inicializar un array
5
int tabla2[] = new int[3]; // declarar y dimensionar el array a la vez
Cuidado. Los índices del array comienzan numerándose desde 0, así
que el array tiene un tamaño de 5, pero los índices van del 0 al 4

©
Iñaki Martín
๏ Lo más interesante de los arrays es la posibilidad de emplear una variable para indicar el índice del
elemento.
๏ Modificando el valor de dicha variable (por ejemplo, mediante un bucle), podemos ir accediendo a cada
elemento del array, “recorriendo” los valores (los vagones del tren)
๏ Por ejemplo, si deseo imprimir todos los elementos de un array, seguidos, podría hacerse así:
๏ Si nos fijamos, es realmente una misma línea que se repite y que es casi igual en todos los casos... esto
huele a bucle. En este caso lo que varia es un solo número, y que además, va tomando sucesivamente los
valores 0,1,2,3,4…. vamos, lo mismo que ocurre con el índice de un bucle for… Así pues, las 5 líneas
anteriores se podrían haber resumido en :
๏ Veamos las líneas anteriores más despacio.
✴ El bucle, en su primera línea, informa de que una variable llamada k se crea y comienza teniendo valor 0
✴ lo que haya dentro del for se repetirá mientras sea cierto que k<4
✴ el valor de k se irá incrementando en cada vuelta del bucle de uno en uno.
Por lo tanto, k va a valer, sucesivamente, 0,1,2,3 ….. que son cada uno de los indices que usábamos
para escribir inicialmente el array… al escribir el elemento que tenga ese indice, escribiremos todo el array.
Trabajando con arrays (II)
String nombresDelEquipo[] = {”Juan”, “Pablo”, “Ana”, “Eva” } ;
for (int k = 0; k < 4; k++) {
System.out.println(nombres[ k ]);
}
String nombres[] = {”Juan”, “Pablo”, “Ana”, “Eva” } ;
System.out.println(nombres[0]);
6

©
Iñaki Martín
1. la variable k se pone inicialmente con valor 0
2. se entra en el bucle, pues la condición inicial se cumple, pues k<4, (k ahora es 0)
3. se ejecuta la línea del System.out..., que intenta hacer
System.out.println(nombresDelEquipo[ k ]);
pero como k=0, realmente hace
System.out.println(nombresDelEquipo[ 0 ]);
e imprime "Juan"
4. el bucle acaba, con lo que se incrementa el valor de k, que pasa a ser 1
5. se entra nuevamente en el bucle, pues la condición se cumple, pues se mira si k<4, y k =1
6. se ejecuta la línea del System.out..., que intenta hacer
System.out.println(nombresDelEquipo[ k ]);
pero como k=1, realmente hace
System.out.println(nombresDelEquipo[ 1 ]);
imprime " Pablo "
7. el bucle acaba, con lo que se incrementa el valor de k, que pasa a ser 2
8. …. y todo se repite nuevamente,
y se van imprimiendo los nombres de todos los elementos del array, con solo una línea,
¿cuando acaba el bucle? cuando no se cumpla k<4, que ocurrirá por vez primera cuando k=4,
así que k habrá valido desde 0 hasta 3, que son realmente todos los elementos del array
Trabajando con arrays (III) 7
Detalle paso a paso de la ejecución del bucle anterior String nombres[] = {”Juan”, “Pablo”, “Ana, “Eva” } ;
for (int k = 0; k < 4; k++) {
System.out.println(nombres[ k ]);
}

©
Iñaki Martín
๏Los arrays son estructuras estáticas, no se puede modificar el tamaño. Si no sabemos a priori el
tamaño que vamos a necesitar, no debemos usar arrays, sino colecciones, que se verán más adelante
๏En la declaración de un array, los corchetes pueden ir delante o detrás del nombre del array.
๏Un array de tipo int no es una variable de tipo int. Los elementos de un array int sí son variables de
tipo int
๏ Respecto al contenido de un array, desde el momento en que el array se dimensiona todos los
elementos del array son inicializados directamente con los valores por defecto de cada tipo de
dato (el valor por defecto es 0 para los tipos de número, false para boolean y ‘0000’ para char)
No importa sin la variable es de clase (global) o de método (local) o de bloque o de lo que sea. A un array, según se dimensiona, se le da valor
inicial siempre a todo su contenido.
Arrays: características
Características de los arrays
8
int[] arraydepruebas = new int [5];
arraydepruebas [0] = 5; // un elemento de un array int, es como un int
arraydepruebas = 5; // ERROR: arraydeprueba es EL ARRAY entero, el tren, no un int
int[] arraydepruebas = new int [5];
int arraydepruebas [] = new int [5];
hacen lo mismo (SOLO vale en la declaración)

©
Iñaki Martín
๏ Los Arrays, en realidad, se comportan como objetos Java, por lo que tienen atributos y métodos. Esto es, con
una variable de tipo array puede usarse el punto para acceder a acciones.
Ya hablaremos más adelante de qué son métodos y atributos, baste por ahora saber que con una variable de tipo array, se pueden efectuar
operaciones usando un punto detrás y añadiendo y unas instrucciones llamadas métodos o atributos.
๏ Pero cuidado, hablamos del ARRAY entero, no de sus elementos
๏ Estos son sus atributos y métodos:
Arrays: atributos y métodos
Metodos y atributos de objetos arrays
9
DEVUELVE ATRIBUTO DESCRIPCION
int .length operación que da como resultado el tamaño (número de elementos) del array.
DEVUELVE METODO DESCRIPCION
otro array .clone() Crea una copia de un array:
Cuidado: Esta clonación de un array es “superficial” (“shallow”), esto es, se crea un
nuevo array, pero que realmente apunta a la misma direccion de memoria que el
array original, con lo que cualquier modificacion de los elementos afecta a ambos, al
array original y al nuevo creado.
int arraydepruebas [] = new int [5];
int numElementos = arraydepruebas.length; // numElementos vale 5
int [ ] copiaDeNotas = notas.clone();

©
Iñaki Martín
๏ El uso de los arrays dentro de bucles es una de las características más potentes de cualquier lenguaje de
programación. Veamos algunos un par de ejercicios de ejemplo:
1. Enunciado: Si se tienen dos arrays, de alumnos y sus notas, mostrar por pantalla el nombre y la nota de cada alumno, y
emitir un mensaje si el alumno ha suspendido. Al final, informar de cual ha sido la media de las notas de la clase:
Arrays: ejemplos
Ejemplo de arrays
String alumnos[] = {"Jose", "Pablo", "Ernesto", "David", "Luis"};
int notas [] = { 5, 6, 3, 2, 8};
int sumaNotas = 0;
for (int i = 0; i < alumnos.length; i++) {
System.out.println("El alumno "+ alumnos[i]+" tiene de nota un "+notas[i]);
if (notas[i] < 5 ){
System.out.println(" y por lo tanto ha suspendido”)
}
sumaNotas = sumaNotas + notas[i];
}
int notaMedia = sumaNotas / notas.length ;
System.out.println("/n La nota media de la clase es de "+ notaMedia );
10
2. Enunciado: Dado un array int[] arrayDeDatos = {8,2,5,4,9,1,0,8,9,3} construir un programa que copie el arrayDeDatos en el
array llamado copiaDeDatos, pero sumando 2 a cada elemento, y que escriba el array copiaDeDatos por pantalla, esto es,
que salga :
"el elemento 1 de copiadedatos es 10”
"el elemento 2 de copiadedatos es 4"
int[] arrayDeDatos = {8,2,5,4,9,1,0,8,9,3};
int[] copiaDeDatos = new int[arrayDeDatos.length];
for (int i = 0; i < arrayDeDatos.length; i++) {
copiaDeDatos[i] = arrayDeDatos[i] + 2;
}
for (int i = 0; i < arrayDeDatos.length; i++) {
System.out.println(copiaDeDatos[i]);
}

©
Iñaki Martín
๏ El método split() no se usa con arrays, sino con la clase String, pero permite crear un “array de cadenas”,
utilizando el parámetro que se le pasa como elemento “troceador” de la cadena original.
๏ Ejemplo: si se tiene una cadena con varios nombres separados por comas, se puede crear un array con todos los
nombres, usando el modo split() y diciendo que trocee la cadena cada vez que se encuentre una coma.
๏ Igualmente, en este otro ejemplo puedo usar como separador un espacio en blanco para crear un array de cadenas
que contenga cada una de las palabras de una frase :
Arrays: creación con split()
split()
StringTokenizer
String frase = "En un lugar de la Mancha";
String [ ] palabras = frase.split(" ");
String cad = "Juan,Pedro,Luis,Pablo";
String [ ] nombres = cad.split(“,”);
11
cad[0] es “Juan"
cad[1] es “Pedro”
cad[2] es “Luis”
cad[3] es “Pablo"
Cuidado: split() usa como parámetro no un String, sino una expresión regular. Aun no se ha visto que son
expresiones regulares, pero sólo como aviso, por ahora, NO se puede usar como separador en split()
directamente un punto (“.”) ni asterisco (“*”). Algunos ejemplos más complejos son :
Para otros modelos de separadores en los elementos, acudir al final a los temas avanzados o al tema de Expresiones Regulares
cadena.split(“.”); // para usar un punto como separador
cadena.split(“”); // si no se usa separador, se separa la cadena carácter a carácter
๏ Similares efectos al método split() se puede conseguir usando la clase StringTokenizer.
Sin embargo, y citando expresamente a la API de Oracle, “StringTokenizer es una clase heredada de versiones
antiguas, que se conserva por razones de compatibilidad, aunque su uso en código nuevo está desaconsejado”

©
Iñaki Martín
๏ Los arrays unidimesionales que se han visto hasta ahora se les suele llamar “arrays” (incluso a veces,
“listas”) y usaban un solo índice para acceder a cada elemento.
๏ Pero un array en Java puede tener más de una “dimensión”, y definirse por lo tanto con más de un índice.
Los arrays bidimensionales (de dos dimensiones) suelen ser llamados “matrices” o “tablas”
๏ Una matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos representar una
matriz como una tabla de n filas y m columnas cuyos elementos son todos del mismo tipo.
Este gráfico indica las “posiciones” de los índices de cada uno de los elementos de una matriz de 4x3
๏ Un elemento de una matriz es localizado mediante las coordenadas representadas por su número de fila (el
primer índice usado) y número de columna (el segundo índice usado)
๏ Cada “casilla” de la matriz es un elemento de la matriz, y almacena un valor. El tipo del valor almacenado es
el tipo del que se haya declarado la matriz.
Arrays multidimensionales (I)
Arrays multidimensionales
12
Matriz [0] [0] Matriz [0] [1] Matriz [0] [2]
Fila 0
Fila 1
Fila 2
Fila 3
Columna 0 Columna 1 Columna 2
Nombre
array
Índice
fila
Índice
columna

©
Iñaki Martín
๏ Para declarar un array multidimensional, se hace igual que con uno de una sola dimensión, pero añadiendo
otros corchetes para la segunda dimensión
Ejemplos de declaración de matrices:
๏ El tipo de dato será el mismo para todos los elementos del array (sea uni o multidimensional)
๏ Al igual que ocurría con los arrays variables, una declaraciones no crea realmente una matriz, es necesario
dimensionarla, exponiendo el número de filas y de columnas que tendrá:
๏ También se puede dar valor inicial a los elementos a la vez que se declara la matriz:
๏ En este caso el número de filas y columna no se indica expresamente, se da con el número de elementos. El
ejemplo anterior crea una matriz de 2x4 (dos filas y cuatro columnas)
Arrays multidimensionales (II)
// <tipoDato> <nombreArray> [ ] [ ];
char puntos[ ][ ];
int plazas [ ][ ];
double [ ][ ] unaMatriz;
puntos = new char[8][12]; // matriz con 8 filas y 12 columnas
plazas = new int[10][5]; // matriz de 10 filas por 5 columnas
13
Declaración de una matriz
int tabla1[][] = { {31, 62, 73, 43} , {23, 44, 65, 19} };

©
Iñaki Martín
Arrays multidimensionales (III) 14
Más sobre matricesTemas avanzados
๏ Los arrays multimensionales pueden tener más de dos dimensiones, basta con indicar cuantas en la creación del objeto, y
trabajar en cada una de ellas como un nivel de array enlazado con la dimensión anterior;
๏ Al crear una matriz, solo es obligatorio indicar el número de filas.Otro ejemplo:
crea una matriz m de 3 filas.
๏ A cada fila se le puede definir luego un número distinto de columnas:
int arraydepruebas [] [] [] [] = new int [5] [3] [2] [4] ;
int [][] m = new int[3][];
m[0] = new int[3];
m[1] = new int[5];
m[2] = new int[2];
• Cuando se asigna una referencia de un array a otro array, ambas referencias han de tener la misma dimensión (la misma
dimensión, no el mismo número de elementos por dimensión)
int [ ] puntos;
int [ ][ ] matrizpuntos = new int [3][ ];
puntos = matrizpuntos; // ERROR, matrizpuntos es de dos dimensiones
int[ ] motas = new int [6];
puntos = motas ; // ok, motas es de una dimension
matrizpuntos[0] = motas ; // ok, matrizpuntos[0] es de una dimension
Asignaciones con arrays multidimensiónTemas avanzados

©
Iñaki Martín
๏ Un array bidimensional es realmente un array de arrays; es decir, se puede ver como un array unidimensional,
donde cada elemento no es un tipo normal (int, double), sino otro array.
๏ Por ello NO es obligatorio que cada fila de la matriz tenga el mismo tamaño.
Por ejemplo, podemos declarar e inicializar la siguiente matriz bidimensional
Arrays multidimensionales (IV)
int [ ][ ] matriz={{1,2,3,4,5},{5,6},{7,8,9,10,11,12},{13}};
// La primer fila tiene cinco elementos {1,2,3,4,5}
// La segunda fila tiene dos elementos {5,6}
// La tercera fila tiene seis elementos {7,8,9,10,11,12}
// La cuarta fila tiene un elemento {13}
15
๏ ¿Cómo saber el tamaño de cada dimensión en el caso de arrays bidimensionales?
Usemos este ejemplo:
int[][] mimatriz = new int[2][6];
int numeroDeFilas = unarrayirregular.length;
int numeroDeComlumnas = unarrayirregular[0].length;
• Tamaño de la primera dimensión (número de filas):
Como una matriz es un array de arrays, el tamaño del array es realmente el número de filas de la matriz
• Tamaño de la segunda dimensión (número de columnas):
Como una matriz es un array de arrays, matriz[0] representa a la primera fila de la matriz, matriz[1] es la segunda fila, etc
El tamaño de cada una de las filas es, por lo tanto, el número de columnas de la matriz, considerando siempre que se trate de una matriz de dos
dimensiones, y regular, esto es, en la que todas las filas tienen el mismo número de elementos). Si se trabaja con matrices irregulares, el
tamaño de cada fila de la matriz se indica con la misma instrucción, matriz [0].length; solo que cambiando el 0 por el número de cada fila, en
cada caso.
int [ ][ ] matriz = new int [4][5];
Tamaño de una matriz
Cuidado al leer arrays irregulares con un for, pues se ha de saber qué tamaño tiene cada dimensión….
int numfilas = matriz.length;
int numfilas = matriz[0].length;

©
Iñaki Martín
Recorrer una matriz
๏ Para acceder a los elementos de una matriz se indican los índices de las dos dimensiones:
๏ Para recorrer una matriz se hace con dos bucles anidados.
Un bucle va a recorrer cada fila de la matriz, y dentro de este (para cada fila), hay otro bucle que hace
referencia a cada columna de dicha fila:
Int numFilas = 4, numCols = 4;
boolean plaza [] [] = new boolean [numFilas] [numCols];
for (int fila = 0; fila < numFilas; fila++){ // Bucle de las filas
for (int col = 0; col < numCols; col++){ // Bucle de las columnas
plaza [fila] [col] = true;
}
} [0] [0] [0] [1] [0] [2] [0] [3]
[1] [0] [1] [1] [1] [2] [1] [3]
[2] [0] [2] [1] [2] [2] [2] [3]
[3] [0] [3] [1] [3] [2] [3] [3]
Recorrer una matriz
plazas [2] [3] = 234;
16

©
Iñaki Martín
Clase Arrays
๏ Java ofrece la clase Arrays, que dispone de varios métodos estáticos (ya se explicará qué significa esto) que
permiten trabajar con el array de forma completa (no con sus elementos si con el array como conjunto)
๏ Son muy útiles pues nos facilitan acciones que de otro modo habría que programar
๏ Algunos de los métodos más interesantes son;
Clase Arrays
CLASE DEVUELVE METODO DESCRIPCION
Arrays array Arrays.sort(arr1) Ordena arr1 (si el contenido se puede ordenar)
Arrays boolean Arrays.equals(arr1,arr2) Indica si los arrays son iguales (contenido y orden)
Arrays array Arrays.copyOf(arr1,tam) Devuelve una copia de arr1 de tamaño tam. La copia no es deep, sino shallow
Arrays array Arrays.copyOfRange(arr1,ini,fin) Devuelve una copia de arr1 desde la posición ini (incluido) hasta fin (excluido)
Arrays array Arrays.fill(arr1,cont) Rellena todo el array arr1 con el contenido cont
Arrays String Arrays.toString(arr1) Devuelve el array arr1 como un String
EJEMPLO PARA TODOS LOS METODOS
int []arr1 = {4,72,1,37,5,2,55,24};
int []x = {4,1,72,37,5,2,55,24};
boolean soniguales = Arrays.equals(arr1,x);
int []x = Arrays.copyOf(arr1,4);
int []x = Arrays.copyOfRange(arr1,2,4);
int []x = Arrays.fill(arr1,0);
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));
17
Normalmente existen métodos sobrecargados para permitir usar en los parámetros todo tipo de datos primitivos

©
Iñaki Martín
Ordenar
Ordenación de arrays: método de la burbuja
int[] nums = {64, 25, 13, 24, 18, 11, 43};
int aux;
for (int i = 0; i < nums.length - 1; i++) {
for (int j = 0; j < nums.length - 1; j++) {
if (nums[j] > nums[j + 1]) {
aux = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = aux;
}
}
}
System.out.print("nArray Ordenado: ");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + " ");
}
18Ordenación por burbuja
๏ La ordenación de una colección por métodos programáticos tiene numerosísimas soluciones y algoritmos. El más
famoso (por ser de los más fáciles de implementar, aunque no es de los más eficientes) es el llamado algoritmo de la
burbuja, que explicamos a continuación (para el ejemplo vamos a usar un array, pero el mecanismo es el mismo que se puede aplicar a cualquier
colección que tenga un indice por el que acceder)
‣ El algoritmo va a usar dos bucles anidados
‣ En el bucle interior, se va ir comparando cada elemento del array (desde la posición 0 al final) con el siguiente, y se
intercambiarán si es necesario, para dejar el mayor siempre a la derecha del otro. De este modo, vamos con
sucesivos intercambios “adelantando” en el array los valores menores, y “atrasando” los mayores.
‣ Con cada vuelta interna se asegura además que el valor que se ha cogido “avanza” hacia la derecha todo lo que
puede. De hecho, tras el primer bucle interno, el valor que queda al “final” del array ha de ser seguro el mayor de
todos los valores del array.
‣ Las sucesivas vueltas exteriores tan solo aseguran que se coloque al final el segundo-mayor, el tercer-mayor, etc.
‣ El problema es que cuando ya ha ordenado parte del array vuelve a compararlo cuando no es necesario, por lo que no
es muy eficiente. i= 0 j = 0: 25 64 13 24 18 11 43
i= 0 j = 1: 25 13 64 24 18 11 43
i= 0 j = 2: 25 13 24 64 18 11 43
i= 0 j = 3: 25 13 24 18 64 11 43
i= 0 j = 4: 25 13 24 18 11 64 43
i= 0 j = 5: 25 13 24 18 11 43 64
i= 1 j = 0: 13 25 24 18 11 43 64
i= 1 j = 1: 13 24 25 18 11 43 64
i= 1 j = 2: 13 24 18 25 11 43 64
i= 1 j = 3: 13 24 18 11 25 43 64
i= 1 j = 4: 13 24 18 11 25 43 64
i= 1 j = 5: 13 24 18 11 25 43 64
i= 2 j = 0: 13 24 18 11 25 43 64
i= 2 j = 1: 13 18 24 11 25 43 64
i= 2 j = 2: 13 18 11 24 25 43 64
i= 2 j = 3: 13 18 11 24 25 43 64
i= 2 j = 4: 13 18 11 24 25 43 64
i= 2 j = 5: 13 18 11 24 25 43 64
i= 3 j = 0: 13 18 11 24 25 43 64
i= 3 j = 1: 13 11 18 24 25 43 64
i= 3 j = 2: 13 11 18 24 25 43 64
i= 3 j = 3: 13 11 18 24 25 43 64
i= 3 j = 4: 13 11 18 24 25 43 64
i= 3 j = 5: 13 11 18 24 25 43 64
i= 4 j = 0: 11 13 18 24 25 43 64
i= 4 j = 1: 11 13 18 24 25 43 64
i= 4 j = 2: 11 13 18 24 25 43 64
i= 4 j = 3: 11 13 18 24 25 43 64
i= 4 j = 4: 11 13 18 24 25 43 64
i= 4 j = 5: 11 13 18 24 25 43 64
i= 5 j = 0: 11 13 18 24 25 43 64
i= 5 j = 1: 11 13 18 24 25 43 64
i= 5 j = 2: 11 13 18 24 25 43 64
i= 5 j = 3: 11 13 18 24 25 43 64
i= 5 j = 4: 11 13 18 24 25 43 64
i= 5 j = 5: 11 13 18 24 25 43 64
Más allá de que la burbuja no sea el mejor método de ordenación de arrays, el propio algoritmo tiene a su vez muchas
variantes. La que hemos indicado es la más facil de recordar, pero aun dentro de las versiones de la burbuja, la menos eficiente.
Se marcan en
color los
intercambios
efectivos que
se han hecho
en cada una
de las vueltas
del array
interno.
Vemos que las
últimas vueltas
han sido
innecesarias…
Así se ordena
ascendentemente, para
ordenar
descendentemente
cambiar en el if el sentido
de la comparación,
cambiar el > por un <

©
Iñaki Martín
• Como ya se ha dicho, el propio algoritmo de la burbuja tiene a su vez muchas variantes. La que hemos indicado anteriormente es la más facil de
recordar, pero aun dentro de las versiones de la burbuja, la menos eficiente.
• Una versión más eficiente del anterior es cambiar la condición de fin del bucle interior, y poner nums.length - 1 - i en vez de nums.length - 1
• Otra versión diferente del método de la burbuja es la siguiente, en la que cada elemento del array se compara con todos los demás,
desplazándose según sea mayor hacia el final, intercambiando igualmente posiciones.
• En este caso, tras el primer bucle interno, el valor que queda al “principio” del array ha de ser seguro el menor de todos los valores del array, y las
sucesivas vueltas aseguran que se coloquen seguidamente en cada vuelta el segundo-menor, el tercer-menor, etc.
Ordenación de arrays: método de la burbuja mejoradoTemas avanzados
Ordenación por burbuja (avanzado)
i= 0 j = 0: 25 64 13 24 18 11 43
i= 0 j = 1: 25 13 64 24 18 11 43
i= 0 j = 2: 25 13 24 64 18 11 43
i= 0 j = 3: 25 13 24 18 64 11 43
i= 0 j = 4: 25 13 24 18 11 64 43
i= 0 j = 5: 25 13 24 18 11 43 64
i= 1 j = 0: 13 25 24 18 11 43 64
i= 1 j = 1: 13 24 25 18 11 43 64
i= 1 j = 2: 13 24 18 25 11 43 64
i= 1 j = 3: 13 24 18 11 25 43 64
i= 1 j = 4: 13 24 18 11 25 43 64
i= 2 j = 0: 13 24 18 11 25 43 64
i= 2 j = 1: 13 18 24 11 25 43 64
i= 2 j = 2: 13 18 11 24 25 43 64
i= 2 j = 3: 13 18 11 24 25 43 64
i= 3 j = 0: 13 18 11 24 25 43 64
i= 3 j = 1: 13 11 18 24 25 43 64
i= 3 j = 2: 13 11 18 24 25 43 64
i= 4 j = 0: 11 13 18 24 25 43 64
i= 4 j = 1: 11 13 18 24 25 43 64
i= 5 j = 0: 11 13 18 24 25 43 64
i= 0 j = 1: 25 64 13 24 18 11 43
i= 0 j = 2: 13 64 25 24 18 11 43
i= 0 j = 3: 13 64 25 24 18 11 43
i= 0 j = 4: 13 64 25 24 18 11 43
i= 0 j = 5: 11 64 25 24 18 13 43
i= 0 j = 6: 11 64 25 24 18 13 43
i= 1 j = 2: 11 25 64 24 18 13 43
i= 1 j = 3: 11 24 64 25 18 13 43
i= 1 j = 4: 11 18 64 25 24 13 43
i= 1 j = 5: 11 13 64 25 24 18 43
i= 1 j = 6: 11 13 64 25 24 18 43
i= 2 j = 3: 11 13 25 64 24 18 43
i= 2 j = 4: 11 13 24 64 25 18 43
i= 2 j = 5: 11 13 18 64 25 24 43
i= 2 j = 6: 11 13 18 64 25 24 43
i= 3 j = 4: 11 13 18 25 64 24 43
i= 3 j = 5: 11 13 18 24 64 25 43
i= 3 j = 6: 11 13 18 24 64 25 43
i= 4 j = 5: 11 13 18 24 25 64 43
i= 4 j = 6: 11 13 18 24 25 64 43
i= 5 j = 6: 11 13 18 24 25 43 64
19
int[] nums2 = { 64, 25, 13, 24, 18, 11, 43 };
int aux2;
for (int i = 0; i < nums2.length; i++) {
for (int j = i + 1; j < nums2.length; j++) {
if (nums2[j] < nums2[i]) {
aux2 = nums2[j];
nums2[j] = nums2[i];
nums2[i] = aux2;
}
}
}
System.out.print ("nArray Ordenado: ");
for (int i = 0; i < nums2.length; i++)
System.out.print (nums2[i] + " ");
int[] nums = {64, 25, 13, 24, 18, 11, 43};
int aux;
for (int i = 0; i < nums.length - 1; i++) {
for (int j = 0; j < nums.length - 1 - i; j++) {
if (nums[j] > nums[j + 1]) {
aux = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = aux;
}
}
}
System.out.print("nArray Ordenado: ");
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + " ");
}
Se marcan en color los
intercambios efectivos que se
han hecho
Se marcan en color los
intercambios efectivos que se
han hecho

©
Iñaki Martín
• Probablemente la versión más eficiente de todas para el método de la burbuja sea esta, donde se usa una variable boolean (una bandera) para
evaluar si hay algún cambio en las rotaciones, y si no lo hay, no seguir y dar por acabada la ordenación
• Se ahorran así vueltas del bucle innecesarias (ver en el ejemplo de la primera versión, en la impresión de la ejecución, que en las últimas 12
“vueltas” no se realiza cambio alguno, pues el array ya se encuentra ordenado)
• Este es un ejemplo de esta versión con flag de “acabado”
Ordenación de arrays: método de la burbuja mejor versiónTemas avanzados
20Ordenación por burbuja (eficiente)
int[] nums = { 64, 25, 13, 24, 18, 11, 43 };
boolean huboCambio = true;
int temp;
while (flag)
{
huboCambio = false;
for (int i = 0; i < nums.length - 1; i++)
{
if (nums[i] > nums[i + 1])
{
temp = nums[i];
nums[i] = nums[i + 1];
nums[i + 1] = temp;
huboCambio = true;
}
}
}
System.out.println ("Array Ordenado: ");
for (int i = 0; i < nums.length; i++){
System.out.print (nums[i] + " ");
}

©
Iñaki Martín
• Para ordenar una matriz se puede seguir igualmente el método de la burbuja
• Se propone aquí una solución sencilla, que puede ser mejorada según las distintas variantes de uso de este algoritmo vistas en paginas anteriores
Ordenación de matrices: método de la burbujaTemas avanzados
Ordenación por burbuja. Ordenar una matriz 21
int[][] mat = {{14,7,23,45},{33,2,11,4},{8,1,99,45}};
int n = mat.length;
int m = mat[0].length;
int t;
for( int i=0; i < n; i++){//ordena la matriz de arriba hacia abajo
for( int j=0;j< m; j++){
for(int x=0; x < n; x++){
for(int y=0; y <m; y++){
if(mat[i][j] < mat[x][y]){
t = mat[i][j];
mat[i][j] = mat[x][y];
mat[x][y] = t;
}
}
}
}
}
for( int i=0; i < n; i++){// pinta la matriz
for( int j=0;j< m; j++){
System.out.print(mat[i][j]+" ");
}
System.out.println();
}

©
Iñaki Martín
Copiando arrays 22
• Los arrays son objetos, y por lo tanto, la variable del array es una referencia, que contiene elementos, que pueden ser de diferente tipo y valor.
Por ello mismo, una copia de arrays puede ser más complicada de lo imaginado. Si tengo
Al cambiar el array2, se ha cambiado también el array1 !!
• Lo que se ha hecho es lo que se llama una shallow copy, una copia superficial.
• Lo contrario es hacer una copia que realmente sea distinta del original, lo que se llama una copia profunda (deep copy). Para ello debemos:
- Crear un nuevo array vacío
- Copiar los elementos uno a uno ( por ejemplo con un bucle)
Pero nuevamente cuidado al copiar los elementos, no estemos haciendo shallow copy de ellos mismos!!. Este ejemplo:
hace una copia del array y efectivamente, arrayCoches y arrayCopia tienen diferentes referencias (direcciones de memoria); pero no asi los
Coches que contiene, que hemos copiado con una simple asignación !!.
Un cambio en arrayCoches no afecta a arrayCopia (quitar o añadir elementos -Coches-) pero un cambio en cualquier Coche almacenado en el
arrayCoches sí afecta al mismo coche almacenado en arrayCopia.
Lo que hay que hacer, pues, es copiar también los elementos cuidando que esta copia sea realmente deep copy (usando para copiar los elementos
un constructor copia, por ejemplo)
Java ofrece dos métodos más para realizar copias de arrays, pero ambos crean realmente shallow copy, así que cuidado al usarlos:
• Arrays.copyOf(arr1, longitud) - devuelve un array copia de arr1, y longitud es el tamaño de nuevo array, que puede ser diferente del original
(si es mayor, rellena con ceros o null si son objetos) :
• System.arraycopy(varVector1, pos1, varVector2, pos2, longitud2) array1 es el array que vamos a copiar, 1 es la posición inicial desde
donde vamos a copiar, array2 es el array destino de la copia, 0 es su posición inicial y 2 el número de elementos a copiar:
Los arrays son referencias, cuidado al copiarlosTemas avanzados
int [] array1 = new int [2]; array1 [0] = 12;
int [] array2 = array1; array2 [0] = 34
Coche [] arrayCoches = new Coche [2];
Coche [] arrayCopia = new Coche [arrayCoches.length];
for (int i = 0; i < arrayCoches.length; i++){
arrayCopia[i] = arrayCoches[i];
};
int [] array2 = Arrays.copyOf( array1, 2);
int [] array2 = new int [2]; System.arraycopy( array1, 1, array2, 0 , 2) ;

©
Iñaki Martín
Casting de arrays y ejemplos de split 23
• Aunque hay casting implícito entre tipos primitivos numéricos enteros, este se mantiene para los componentes unitarios de un array, pero no para
el array como tal (como referencia).
• Una referencia de un array de short NO puede ser asignado a una referencia de array de int sin que de error:
• Considerar que el ultimo casting es de short a int, mientras que en los casos anteriores , se intentaba hacer un casting de un array_de_short a un
array_de_int, que no es lo mismo.
Casting de arraysTemas avanzados
int[] aa = new int[3];
short[] ss = new short[2];
ss = aa; // ERROR no se puede casting implicito de short a int
ss = (int) aa; // ERROR tampoco no se puede casting explicito de short a int
aa[0] = ss[0]; // ok, sin problema, se hace casting implicito
Otros ejemplos de split() con expresiones regulares avanzadasTemas avanzados
// Se puede usar split() para trocear un string caracter a caracter (aunque se sigue devolviendo String[] )
String [ ] arra1 = “linea tonta”.split(“”);
// arra1 es {“l”,”i”,”n”,”e”,”a”,” ”,”t”,”o”,”n”,”t”,”a”}
// Se puede hacer que los separadores se incluyan en los elementos, por delante de cada uno que le toque
String [ ] arra2 = “Juan-Pedro-Luis”.split(“(?=-)”);
// arra1 es {“Juan”,”-Pedro”,”,-Luis”}
// Igual que antes, pero con el separador pore detras de los elementos que le toque
String [ ] arr3 = “Juan,Pedro,Luis".split(“(?<=-)”);
// arra1 es {“Juan”,”Pedro-”,”Luis-”}

©
Iñaki Martín
• Si se ejecuta un split sin indicar una expresión regular, se divide el string en todos y cada uno de los caracteres de la cadena
• Ejemplo:
• Sin embargo, antes de Java8, esta misma ejecución daba como resultado un valor más, vacío, al principio del array
• Se debe tener cuidado por tanto si se desea realizar una aplicación que mantenga la compatibilidad con Java/ usando split
con cadenas sin usar una expresión regular
• Eso si, en cualquiera de las versiones (Java 7 o superiores) un split sin expresión regular, aplicado a una cadena vacía, da
como respuesta un array con un elemento, un elemento vacío
método split() : cambios en Java 8Temas avanzados
split() en versiones Java anteriores a 8
String s = "qwerty";
String [ ] sol = s.split("");
System.out.println(sol.length);
for (int i = 0; i < sol.length; i++) {
System.out.print("."+sol[i]+".");
}
// - RESULTADO:
// 6
// .q..w..e..r..t..y.
// - RESULTADO:
// 7
// ...q..w..e..r..t..y.
String s = "";
String [ ] sol = s.split("");
System.out.println(sol.length);
for (int i = 0; i < sol.length; i++) {
System.out.print("."+sol[i]+".");
}
// - RESULTADO:
// 1
// ..
24

Jyoc java-cap04 vectores (arrays)

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Similar a Jyoc java-cap04 vectores (arrays)

Similar a Jyoc java-cap04 vectores (arrays) (20)

Más de Jyoc X

Más de Jyoc X (19)

Último

Último (20)

Jyoc java-cap04 vectores (arrays)