Actividad de Aprendizaje Estructura de Datos Unidad 2

Ejercicios Propuestos - Unidad II
Investigar y presentar en un documento de Word las siguientes preguntas:
1. Cuales son y para que se utilizan los Métodos definidos por Vector
2. Uso de Array de caracteres y cadenas de texto (String y StringBuffer).
Mencione además con que métodos puede trabajar cada una.
3. ¿Cómo Copiar y Comparar Arreglos en Java?
4. Uso de la Clase arrays del API de Java
5. Uso de los métodos arraycopy, Equals, copyof, fill.
6. ¿Cómo Recorrer Arreglos en Java?
7. Uso del Bucle for-each para recorrido de arreglos y colecciones.
8. Nota: Para responder completamente a los 5 puntos, a estos debe agregar

ejemplos prácticos en código java.
Realizar los siguientes ejercicios utilizando como lenguaje JAVA:
1. Utilizando un arrays, escribir un programa que visualice un cuadro mágico de

orden impar n, comprendido entre 3 y 11. El usuario debe elegir el valor de n.
“Un cuadrado mágico se compone de números enteros comprendidos entre 1 y
n. La suma de los números que figuran en cada fila, columna y diagonal son
iguales”.
Ejemplo:
8 1 6
3 5 7
4 9 2
Un método de generación consiste en situar el número 1 en el centro de la

primera fila, el número siguiente en la casilla situada por encima y a la derecha
de la última es la primera. En el caso de que el número generado caiga en una
casilla ocupada, se elige la casilla que se encuentre debajo del número que
acaba de ser situado.
2. Se dispone de N temperaturas almacenadas en un array. Se desea calcular su

media y obtener el número de temperaturas mayores o iguales que la media.
3. Leer una matriz de 3 por 3 elementos y calcular la suma de cada una de sus
filas y columnas, dejando dichos resultados en dos vectores, uno de la suma
de las filas y otro de las columnas.
4. Leer las notas de 15 estudiantes en un arreglo y ordenarlo con el fin imprimirlo
de forma Descendente.
5. Se tiene un vector que va a contener como elementos, donde cada elemento
es un registro: Código del Vendedor, Nombre, Salario básico, Valor Venta,
salario neto de 10 empleados.
Se debe imprimir por cada empleado:
 Código del vendedor
 Comisión.
La comisión se calcula así:
 Si Valor Venta oscila entre 250 y 300 la Comisión = 20% Valor Venta
 Si Valor Venta oscila entre 301 y 450 la Comisión = 25% Valor Venta
 Si Valor Venta >450 la Comisión = 30% Salario Básico
Se debe imprimir al final de todo el proceso:
 Total pagado en comisión por cada rango
 Total pagado en neto.
6. Realizar un programa que solicite al usuario desde un vector crear una lista de
números por teclado luego imprimir el vector de forma ordenada con el Método
de Burbuja (Descendentemente).
7. En un Vector se almacenan las calificaciones finales de N alumnos. Realizar un

programa que calcule e imprima:
o El promedio general del grupo
o Número de alumnos aprobados y número de alumnos reprobados
o Porcentaje de alumnos aprobados y porcentaje de alumnos reprobados.
o Número de alumnos cuya calificación fue mayor o igual a 4.
8. En una matriz de 5 Filas X 4 Columnas, calcule la suma de las filas y de las

columnas, dejando los resultados en dos vectores, uno con la sumas de las
filas y el otro con las suma de las columnas, imprima los dos vectores
resultantes.
9. Suponga que se tiene la siguiente matriz de números:
Calcule e Imprima, cuantos “ceros” aparecen en cada renglón de la matriz.
10. Llenar una matriz de 3x3 e Imprima su traspuesta (la traspuesta se consigue
intercambiando filas por columnas y viceversa).
Muchos Éxitos…
Respuestas
1.CLASE VECTOR
Vamos a continuar el estudio de la interface List del api de Java, pero esta vez nos
centraremos en la implementación de esta interface a través de la clase Vector.
También veremos las características más importantes de esta nueva
implementación y haremos un ejemplo a modo de ejercicio.
VECTOR
La clase Vector, al igual que ArrayList o LinkedList, también implementa a List,

pero de un modo especial. Este modo especial es sincronizado, lo que permite
que se pueda usar en entornos concurrentes (es decir, en varios procesos que se
ejecutan al mismo tiempo y hacen uso posiblemente de los mismos recursos).
Esta además es la principal característica que la diferencia de otras clases
estudiadas anteriormente como ArrayList.
Se recomienda que si no es necesario se use ArrayList en vez de Vector. Por

tanto, solo utilizaremos la clase Vector si tenemos previstas circunstancias
especiales como procesos concurrentes.
Vamos a ver las principales características de esta clase, que además es muy
parecida a ArrayList.
Un objeto de tipo Vector contiene elementos que pueden ser accedidos por un
índice y puede aumentar o disminuir su tamaño dinámicamente en tiempo de
ejecución.
EJEMPLO USO CLASE VECTOR
Vamos a realizar un ejemplo de uso sobre la clase Vector, donde añadiremos

elementos, eliminaremos elementos y consultaremos la capacidad del vector. Para
ello también usaremos la clase Persona que hemos venido utilizando en
ocasiones anteriores durante el curso:
/* Ejemplo Interface List, clase Vector aprenderaprogramar.com */
public class Persona{
private int idPersona; private String nombre; private int altura;
public Persona(int idPersona, String nombre, int altura) {

this.idPersona = idPersona; this.nombre = nombre; this.altura =
altura;}
@Override
public String toString() {
return "Persona-> ID: "+idPersona+" Nombre: "+nombre+" Altura:

"+altura+"\n";
Vamos a escribir ahora el siguiente código con el que vamos a trabajar:
/* Ejemplo Interface List, clase Vector aprenderaprogramar.com */
import java.util.Vector;
public class Programa {
public static void main(String arg[]) {
Vector<Persona> v = new Vector<Persona>();
System.out.println("La capacidad inicial del vector es: "+v.capacity());
int i = 0;
while (i<15) {
v.add(new Persona(i,"Persona"+i,i));
i++; }
System.out.println("La capacidad actual del vector es: "+v.capacity());
v.trimToSize();
v.ensureCapacity(50);
2. Java cuenta con múltiples tipos de datos para trabajar con cadenas de
caracteres. El más conocido de ellos es String, pero también tenemos a nuestra
disposición otros como StringBuilder y StringBuffer. Para elegir el más adecuado
en cada caso hemos de conocer las diferencias entre ellos. Es un conocimiento
que nos será útil para mejorar el rendimiento de nuestras aplicaciones y que,
además, podría ayudarnos a responder cuestiones en una entrevista de trabajo en
la que se soliciten conocimientos sobre Java.
¿Por qué existen varios tipos de datos para la misma categoría de información?
Lo primero que habríamos de preguntarnos es la razón por la que existen
múltiples tipos de datos en Java para operar sobre una misma categoría de
información: las cadenas de caracteres.
Como se apuntaba en el artículo Cadenas compactas en Java 9 que

publicábamos hace unas semanas, una fracción importante de toda la información
con la que trabajan las aplicaciones son cadenas de caracteres. Por ello es
importante que el trabajo con las mismas sea lo más eficiente posible. Es la razón
por la que en la clase String el atributo encargado de almacenar los caracteres, tal
y como se aprecia en la siguiente imagen correspondiente a la cabecera del
módulo String.java, se declare como final. Esto implica que su contenido, una vez
asignado, ya no podrá modificarse. Por esto se dice que el tipo String de Java es
inmutable.
Definición de la clase String
No hemos de olvidar que Java es un lenguaje muy usado para el desarrollo de

aplicaciones de servidor, en las que es habitual la creación de múltiples hilos
(threads) de ejecución a fin de paralelizar el trabajo y aprovechar las actuales
configuraciones multi-procesador y multi-núcleo. En este contexto, un tipo
inmutable aporta indudables ventajas. Las operaciones sobre String no precisan
de mecanismos de sincronización para el acceso simultáneo desde múltiples hilos,
lo cual permite trabajar con ellas con un buen rendimiento. La sincronización
implica, en general, la serialización de las operaciones, afectando de manera
importante al rendimiento con que es posible llevarlas a cabo.
Todas las ventajas suelen tener asociada una contrapartida y, en este caso
concreto, la desventaja surge al manipular el contenido de una cadena. Dado que
el tipo String es inmutable (no podemos modificar su contenido), cualquier
operación de modificación sobre una variable de este tipo, como puede ser
concatenar una cadena a otra o usar métodos como toUpperCase(), replace() o
similares, implica la creación de un nuevo objeto String como resultado. Por
ejemplo:
String saludo = "Hola"; // Creamos la cadena con un contenido
saludo = saludo + " mundo"; // y le agregamos después una subcadena

Cuando en la segunda línea extendemos el contenido original de la variable
saludo, lo que ocurre es que se libera el objeto String original, el creado en la
primera sentencia, y se crea otro nuevo para alojar el resultado de la operación.
Por otra parte, las literales de cadena de caracteres, como "Hola" y " mundo" en el
anterior ejemplo, se almacenan en un espacio específico conocido como constant
string pool. Esto facilita la reutilización de estas literales, reduciendo la cantidad de
memoria total en caso de que aparezcan múltiples veces en el código del
programa. Además se emplea una estrategia de asignación de memoria estática,
en lugar de dinámica, mejorando así la velocidad de ejecución.
Java está presente en más de 15.000.000.000 de dispositivos. Una razón de peso

para dominar Java. ¿Te ayudamos? »
Obviamente, el hecho de se liberen y creen nuevos objetos String cada vez que se
cambia su contenido influye también en el rendimiento de los programas. El
recolector de basura de Java tendrá más trabajo. No obstante, la decisión de
hacer inmutable el tipo String parte de análisis realizados sobre aplicaciones en
los que se observa que en una gran proporción de los casos su contenido no es
modificado, por lo que los beneficios obtenidos son, en general, superiores a los
inconvenientes.
Cadenas de caracteres mutables: los tipos StringBuilder y StringBuffer

Dado que en una aplicación puede surgir la necesidad de alterar de manera
frecuente el contenido de una cadena de caracteres, Java nos ofrece tipos de
datos específicos para operar sobre ellas. Las cadenas de caracteres mutables,
representadas por los tipos StringBuilder y StringBuffer, se comportan como
cualquier otro tipo de dato por referencia en Java: se asigna memoria
dinámicamente según es necesario. No se hace uso del constant string pool y el
contenido puede modificarse sin necesidad de liberar y crear nuevos objetos. Por
ejemplo:
StringBuilder saludo = new StringBuilder("Hola");
saludo.append(" mundo");
En este caso, al agregar la segunda cadena a la primera, sencillamente se
actualiza el contenido inicial de la variable saludo, de tipo StringBuilder, en lugar
de liberarse el objeto original y crearse otro nuevo. En general, un programa que
vaya a modificar con cierta frecuencia el contenido de una o más cadenas de
caracteres obtendrá mejor rendimiento de esta forma que con el tipo String
original.
Como apuntaba antes, habitualmente cada ventaja conlleva algún tipo de
inconveniente. La flexibilidad de los tipos StringBuilder y StringBuffer también tiene
su contrapartida. Al contar con un contenido mutable, StringBuilder no es un tipo
de dato seguro para aplicaciones con múltiples hilos de ejecución. Si dos hilos
acceden simultáneamente para cambiar algo en la cadena, el resultado puede ser
totalmente inesperado.
¿Qué hacer si necesitamos trabajar con cadenas de caracteres mutables en un

entorno multi-hilo? Usar el tipo StringBuffer en lugar de StringBuilder. Ambos son
prácticamente idénticos en cuanto a funcionalidad se refiere, pero internamente la
implementación de todos los métodos que alteran la cadena está sincronizada en
el caso de StringBuffer. Es decir, este último tipo es seguro (thread-safe) para
múltiples hilos, mientras que StringBuilder no lo es. Esta seguridad se obtiene a
costa del rendimiento, ya que la sincronización provoca que las operaciones sobre
cadenas con StringBuffer sean más lentas que con StringBuilder o que con String.
Cuando el compilador se ocupa de optimizar por nosotros

A la vista de lo explicado hasta ahora, podríamos pensar en recurrir a los tipos de
cadenas mutables exclusivamente en aquellos casos en que vamos a llevar a
cabo reiteradas operaciones de modificación, como puede ser la concatenación de
un conjunto de resultados generados en un bucle. Por ejemplo:
String resultado = "Cuadrados\n";
for(int i = 1; i <= 100; i++)

resultado = resultado + "El cuadrado de " + i + " es " + i*i + "\n";
En el anterior bucle, dado que está utilizándose una variable de tipo String como
destinataria, se liberaría el objeto actual y se crearía otro nuevo en cada ciclo.
Esto, con un número de iteraciones grande, conlleva mucho trabajo de asignación
y recolección de objetos, por lo que convendría optimizar cambiando String por
StringBuilder.
El compilador de Java es suficientemente inteligente como para identificar estos

casos de forma automática, llevando a cabo la sustitución indicada en el bucle y,
una vez finalizado este, convirtiendo el resultado a String y guardándolo en la
variable original. La conclusión a la que podemos llegar es que, en general,
usaremos el tipo String salvo en casos muy concretos, cuando vayan a efectuarse
muchos cambios sobre la cadena y estos no puedan ser identificados y
optimizados por el compilador de Java.
3. COPIAR ARRAYS Y COMPARAR ARRAYS. IDENTIDAD E IGUALDAD
Al trabajar con arrays de tipos primitivos o de objetos se nos puede plantear la

necesidad de copiar arrays. La copia de arrays está permitida pero conviene ser
cauto cuando realicemos procesos de este tipo. Recordar que un array es un
objeto (aunque sea especial) y por tanto la variable que lo nombra en realidad
contiene un puntero al objeto, no el objeto en sí mismo.
Al hacer una operación del tipo array1 = array2, el puntero de array1 apunta al
mismo objeto que array2 mientras que el objeto al que apuntaba array1 queda
inaccesible. A partir de ese momento existe identidad entre los arrays y la
comparación usando == nos devolverá true. A través de código, vamos a
plantearnos distintas situaciones y a comentar cuáles son los resultados.
EJERCICIO EJEMPLO RESUELTO 1. COPIAR ESTABLECIENDO UNA

RELACIÓN DE IDENTIDAD ENTRE ARRAYS (aplicable a arrays de tipos
primitivos y a arrays de objetos)
//Test de copia de arrays aprenderaprogramar.com
public class TestCopiaArrays {
public static void main (String [ ] Args) {
int [ ] miArray1 = {2, -4, 3, -7};
for (int i=0; i<miArray1.length; i++) {
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");
System.out.println("");
int [ ] otroArray = {1, 2, 4, 8};
for (int i=0; i<otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");}
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
otroArray = miArray1; //otroArray pasa a ser el mismo objeto que miArray1
} //Cierre del main
} //Cierre de la clase
Trata de predecir tú mismo el resultado y compáralo con el que ofrecemos.

Resultado:
miArray1[0]= 2; miArray1[1]= -4; miArray1[2]= 3; miArray1[3]= -7;
otroArray[0]= 1; otroArray[1]= 2; otroArray[2]= 4; otroArray[3]= 8;
¿Son el mismo objeto? ... false
otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7;
¿Son el mismo objeto? ... true
EJERCICIO EJEMPLO RESUELTO 2. INTENTO DE COMPARAR ARRAYS

(RELACIÓN DE IGUALDAD)
Supongamos que queremos comparar la igualdad entre dos arrays. Una idea
(mala idea) podría ser aplicar el método equals directamente sobre el array. Un
código de prueba podría ser este:
//Test uso incorrecto de equals aprenderaprogramar.com
public class TestUsoIncorrectoEquals {
int [ ] miArray1 = {2, -4, 3, -7};
for (int i=0; i < miArray1.length; i++) {
System.out.println();
int [ ] otroArray = {2, -4, 3, -7};

for (int i=0; i < otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " +

(miArray1.equals(otroArray) ) );
for (int i=0; i<otroArray.length; i++) { System.out.print ("otroArray[" + i +"]= " +

otroArray[i]+"; "); }

(miArray1.equals(otroArray) ) );
} //Cierre del main

Resultado:
otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7; ¿Son el mismo

objeto? ... false
¿Tienen el mismo contenido (relación de igualdad)? ... false

objeto? ... true
¿Tienen el mismo contenido (relación de igualdad)? ... true
Con este ejemplo comprobamos que el método equals aplicado directamente

sobre arrays no funciona ya que en el primer caso teniendo el mismo contenido
nos dice que la relación de igualdad es falsa. ¿Por qué? Porque ya dijimos en su
momento que los arrays son unos objetos especiales que no tienen una clase que
los implemente. Si no tienen clase, no tienen métodos (al menos directamente), y
el método que se aplica es el usado por defecto por Java con resultados
imprevisibles o no deseados. La solución para comparar arrays es usar otra clase
que permite realizar operaciones con arrays. Esta clase es la clase Arrays. Una
vez más la terminología Java nos puede inducir a confusión: hablamos de array
como colección de tipos primitivos u objetos, y al mismo tiempo Arrays (con
mayúsculas) es el nombre de una clase Java que sirve para manipular arrays.
4 y 5 LA CLASE ARRAYS DEL API DE JAVA. EQUALS, COPYOF, FILL.

En la documentación de la clase Arrays del API de Java podemos encontrar, entre
otras cosas, lo siguiente:
Esta clase contiene varios métodos para manipular arrays (por ejemplo para
ordenar un array o buscar un valor u objeto dentro de él) y para comparar arrays.
Dado que pertenece al package util, para poder usar esta clase habremos de
incluir en cabecera import java.util.Arrays; o bien import java.util.*;. Al igual que los
arrays son unos objetos que hemos dicho son especiales (al carecer de métodos),
podemos decir que la clase Arrays es una clase un tanto especial por cuanto
carece de constructor. Digamos que directamente al cargar la clase con la
sentencia import correspondiente automáticamente se crea un objeto denominado
Arrays que nos permite realizar manipulaciones con uno o varios arrays (p. ej.
ordenar un array, comparar dos arrays, etc.). Dicho objeto podemos utilizarlo
directamente: no es necesario declararlo ni crearlo, eso es automático en Java, y
por eso decimos que esta clase es una clase especial. La clase Arrays tiene
muchos métodos, entre ellos varios métodos equals (sobrecarga del método) que
hacen que equals sea aplicable tanto a arrays de los distintos tipos primitivos
como a arrays de objetos. En concreto el método aplicable a arrays de enteros
primitivos es:
static boolean equals (int[ ] a,int[ ] a2)
Devuelve true si los dos arrays especificados tienen relación de igualdad

entre sí.

Vamos a aplicar este método para comparar el contenido de dos arrays de enteros
(relación de igualdad). La aplicación al resto de tipos primitivos y objetos es
análoga. La sintaxis en general es: Arrays.equals (nombreArray1, nombreArray2).

EJERCICIO EJEMPLO RESUELTO 3. COMPARAR ARRAYS (RELACIÓN DE
IGUALDAD) USANDO LA CLASE ARRAYS
import java.util.Arrays;
//Test comparar arrays relación de igualdad aprenderaprogramar.com
public class TestCompararArrays {
int [ ] miArray1 = {2, -4, 3, -7};
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");}
System.out.println ("");
int [ ] otroArray = {2, -4, 3, -7};
Arrays.equals(miArray1, otroArray) );
for (int i=0; i<otroArray.length; i++) { System.out.print ("otroArray[" + i +"]= " + otroArray[i]+";
"); }
} //Cierre del main

Resultado:
objeto? ... false
objeto? ... true

El resultado ahora sí es correcto, porque hemos usado correctamente la clase
Arrays para realizar la comparación entre dos arrays.

EJERCICIO EJEMPLO RESUELTO 4. COPIAR CONTENIDOS ENTRE ARRAYS
SIN ESTABLECER RELACIÓN DE IDENTIDAD ( “manual”, aplicable a tipos
primitivos y a objetos).
Antes vimos cómo asignar el contenido de un array a otro haciendo que la variable
apunte al mismo objeto. Vamos a ver ahora cómo copiar el contenido entre dos
arrays pero manteniendo que cada variable denominadora del array apunte a un
objeto diferente:
//Test copia arrays con igualdad sin identidad aprenderaprogramar.com
public class TestCopiaConIgualdadSinIdentidad {
int [ ] miArray1 = {2, -4, 3, -7};
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");}
System.out.println();

int [ ] otroArray = {1, 2, 4, 8};


//Realizamos una asignación elemento a elemento
otroArray[i] = miArray1[i];}

} //Cierre del main

Resultado:
otroArray[0]= 1; otroArray[1]= 2; otroArray[2]= 4; otroArray[3]= 8; ¿Son el mismo objeto? ...
false
objeto? ... false

EJERCICIO EJEMPLO RESUELTO 5. COPIAR CONTENIDOS ENTRE ARRAYS
SIN ESTABLECER RELACIÓN DE IDENTIDAD (Usando el método copyOf de
la clase Arrays, aplicable a tipos primitivos y a objetos).
El método copyOf de la clase Arrays nos permite:
a) Copiar un array manteniendo el número de elementos.
b) Copiar un array agrandando el número de elementos que tiene, quedando los
nuevos elementos rellenos con valores cero o nulos.
c) Copiar un array empequeñeciendo el número de elementos que tiene; los
elementos que no caben en el nuevo array, dado que tiene menor capacidad, se
pierden (el array queda truncado).

copyOf es un método sobrecargado. En el caso de arrays de enteros su signatura
es la siguiente:
static int[ ] copyOf (int[ ] original, int newLength)
Copia el array especificado, truncando o rellenando con ceros (si fuera

necesario) de manera que la copia tenga el tamaño especificado.

Para el resto de tipos primitivos su sintaxis es análoga: Arrays.copyOf
(nombreDelArray, n) siendo n un entero que define la nueva longitud del array (n
puede ser mayor, menor o igual que la longitud del array original). El código de
ejemplo sería este (usamos el copyOf sin variar la longitud del array):
//Test uso de copyOf método clase Arrays aprenderaprogramar.com
public class TestUso_copyOf_1 {
int [ ] miArray1 = { 2, -4, 3, -7 };
}
System.out.println ("");
int [ ] otroArray = { 1, 2, 4, 8 };
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");
}

//Copiamos el array utilizando el método copyOf de la clase Arrays
otroArray = Arrays.copyOf(miArray1, miArray1.length);

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

} //Cierre del main

Resultado:
otroArray[0]= 1; otroArray[1]= 2; otroArray[2]= 4; otroArray[3]= 8; ¿Son el mismo objeto? ...
false
objeto? ... false

Hemos comprobado que el método copyOf de la clase Arrays realiza una copia
elemento a elemento entre los contenidos de dos arrays pero no hace que los
punteros apunten al mismo objeto. Prueba a variar la longitud que se le pasa como
parámetro al método copyOf, por ejemplo:
otroArray = Arrays.copyOf(miArray1, miArray1.length+2); //Resto del código igual
otroArray = Arrays.copyOf(miArray1, miArray1.length-2); //Resto del código igual

Comprueba que los resultados son el alargamiento del array y su relleno con
ceros, o el acortamiento con pérdida de los datos (truncamiento) que no caben
debido al recorte de la longitud. En el caso de alargamiento o expansión del array
cuando se trata de un array que no sea de enteros, si son tipos numéricos se
rellenan los excedentes con ceros, si son booleanos se rellenan los excedentes
con false, si son char se rellenan de caracteres vacío, y si son objeto se rellenan
los excedentes con null.

RELLENAR UN ARRAY CON UN VALOR U OBJETO. MÉTODO FILL DE LA
CLASE ARRAYS
La clase Arrays tiene un método, denominado fill, sobrecargado, que permite
rellenar un array con un determinado valor u objeto. En el caso de arrays de
enteros la signatura es:
static void fill (int[ ] a, int val)
Asigna el valor entero especificado a cada elemento del array de enteros
indicado.

En general la sintaxis será: Arrays.fill (nombreDelArray, valor con el que se
rellena). El valor con el que se rellena depende del tipo del array. Por ejemplo, si
es un array de tipo booleano, tendremos que rellenarlo bien con true o bien con
false, no podremos rellenarlo con un tipo que no sea coherente. Ejemplos de uso:
Arrays.fill (resultado, ‘9’); Como rellenamos con un carácter, resultado habrá de
ser un array de caracteres, ya que en caso contrario no habría coincidencia de
tipos.
Arrays.fill (permitido, true); Como rellenamos con un true, resultado será un array
de booleanos. De otra manera, no habría coincidencia de tipos. Ejemplo de
código:
public class TestMetodoFillArrays {
public static void main (String [ ] Args) { //main cuerpo del programa ejemplo
aprenderaprogramar.com
int [ ] miArray = new int[10];
Arrays.fill(miArray, 33);
for (int tmp: miArray) { System.out.print (tmp + ","); } //Recorrido del array
con un for each
} } //Cierre del main y de la clase

Ejecuta el código y comprueba que el resultado es:
33,33,33,33,33,33,33,33,33,33,. Es decir, el array queda relleno en todos sus
elementos con 33.
En caso de que el array tenga contenidos previos al aplicarle el fill, todos sus
elementos quedarán reemplazados por el elemento de relleno. No obstante, hay
otro método que permite especificar los índices de relleno de modo que se pueda
preservar parte del contenido previo del array:
static void fill (int[ ] a, int fromIndex, int toIndex, int val)
Asigna el valor entero especificado a cada elemento del rango indicado para el
array especificado.
6. El arreglo es la más fundamental de la estructura de datos en las ciencias de la

computación. Este tipo de datos simplemente asigna un bloque de memoria a un
número predeterminado de objetos, y permite que el programador acceda a cada
objeto de acuerdo a su lugar en la línea. En Java, también es posible declarar
arreglos con múltiples dimensiones. Un arreglo de dos dimensiones sería,
conceptualmente, una cuadrícula de objetos, con cada uno de éstos accesible por
su fila y columna en la cuadrícula.
Paso 1
Abre el Ambiente de Desarrollo Integrado de Java Netbeans (IDE, por sus siglas
en inglés).
Paso 2
Haz clic en "Archivo" y "Crear nueva clase". Nombra la clase
"TwoDimensionalArray" cuando se te indique.
Paso 3
Pega el siguiente código dentro de los corchetes del método "main", para definir
un arreglo de dos dimensiones:
int matriz[][] = {{1,2,3},{3,2,1}};
Paso 4
Pega lo siguiente en la próxima línea para acceder a la primera columna, segunda
fila del arreglo:
int firstColSecRow = matriz[1][0];
Recuerda que Java empieza a contar desde "0", de modo que la primera columna
es la "0", y la segunda fila es la columna "1".
Paso 5
Pega lo siguiente en la próxima línea para recorrer el arreglo entero:
for(int x = 0; x < matrix.length; x++) { for (int y = 0; y < matrix[x].length; y++) { int
currentCell = matrix[x][y]; } }
7. Una de las cosas que incorporó Java 5 fue el bucle for-each en Java. Esta
estructura nos permite recorrer una Colección o un array de elementos de una
forma sencilla. Evitando el uso de Iteradores o de un bucle for normal.
De la forma tradicional podríamos recorrer un array de la siguiente forma:
String a[] = {"Avila", "Burgos", "León", "Palencia", "Salamanca", "Segovia", "Soria",

"Valladolid", "Zamora"};
for (int x=0;x<a.length;x++)

System.out.println(a[x]);
En este caso nos estamos apoyando en el tamaño del array, con la propiedad
length y en una variable contador, la cual vamos incrementando hasta que llegue a
el tamaño del array.
Para recorrer una Colección, una lista en este caso, podríamos hacerlo con un
Iterador de la siguiente forma:
List<String> list = new ArrayList<String>();
// Añadimos elementos
list.add("Victor");
list.add("Amaya");
list.add("Julio");
// Obtenemos un Iterador y recorremos la lista.

ListIterator<String> iter = list.listIterator(list.size());
while (iter.hasPrevious())
System.out.println(iter.previous());
Para la colección hemos creado un Iterador que nos permite recorrer los
elementos de la colección.
El bucle for-each en Javanos permite realizar estas mismas operaciones de una

forma muy sencilla. La estructura del bucle for-each sería de la siguiente forma:
for (TipoBase variable: ArrayDeTiposBase) {..}

Así, para recorrer un array, tendríamos lo siguiente:
String array[] = {"Avila", "Burgos", "León", "Palencia", "Salamanca", "Segovia",

"Soria", "Valladolid", "Zamora"};
for (String elemento: array)

System.out.println(elemento);
Y para la colección, esto otro:
List<String> list = new ArrayList<String>();
// Añadimos elementos
list.add("Victor");
list.add("Amaya");
list.add("Julio");
for (String nombre: list)

System.out.println(nombre);
Bibliografía
https://www.aprenderaprogramar.com/index.php?
option=com_content&view=article&id=606:la-clase-vector-del-api-java-metodos-
trimtosize-y-ensurecapacity-ejemplo-y-ejercicios-resueltos-
cu00922c&catid=58&Itemid=180
https://www.campusmvp.es/recursos/post/cadenas-mutables-e-inmutables-en-
java-cuando-usar-string-stringbuilder-y-stringbuffer.aspx
option=com_content&view=article&id=641:copiar-y-comparar-arrays-en-java-
conceptos-identidad-e-igualdad-ejercicios-resueltos-ejemplos-
cu00675b&catid=68&Itemid=188
option=com_content&view=article&id=642:clase-arrays-del-api-java-metodos-
equals-comparar-copyof-copiar-fill-rellenar-ejemplos-
cu00676b&catid=68&Itemid=188
https://techlandia.com/recorrer-arreglos-dimensiones-java-como_254131/
http://lineadecodigo.com/java/bucle-for-each-en-java/

Actividad de Aprendizaje Estructura de Datos Unidad 2

Cargado por

Copyright:

Formatos disponibles

Actividad de Aprendizaje Estructura de Datos Unidad 2

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Actividad de Aprendizaje Estructura de Datos Unidad 2

Cargado por

Copyright:

Formatos disponibles

Ejercicios Propuestos - Unidad II

Investigar y presentar en un documento de Word las siguientes preguntas:

8. Nota: Para responder completamente a los 5 puntos, a estos debe agregar

Realizar los siguientes ejercicios utilizando como lenguaje JAVA:

1. Utilizando un arrays, escribir un programa que visualice un cuadro mágico de

Un método de generación consiste en situar el número 1 en el centro de la

2. Se dispone de N temperaturas almacenadas en un array. Se desea calcular su

7. En un Vector se almacenan las calificaciones finales de N alumnos. Realizar un

8. En una matriz de 5 Filas X 4 Columnas, calcule la suma de las filas y de las

9. Suponga que se tiene la siguiente matriz de números:

Calcule e Imprima, cuantos “ceros” aparecen en cada renglón de la matriz.

La clase Vector, al igual que ArrayList o LinkedList, también implementa a List,

Se recomienda que si no es necesario se use ArrayList en vez de Vector. Por

EJEMPLO USO CLASE VECTOR

Vamos a realizar un ejemplo de uso sobre la clase Vector, donde añadiremos

/* Ejemplo Interface List, clase Vector aprenderaprogramar.com */

public class Persona{

private int idPersona; private String nombre; private int altura;

public Persona(int idPersona, String nombre, int altura) {

public String toString() {

return "Persona-> ID: "+idPersona+" Nombre: "+nombre+" Altura:

Vamos a escribir ahora el siguiente código con el que vamos a trabajar:

/* Ejemplo Interface List, clase Vector aprenderaprogramar.com */

public class Programa {

public static void main(String arg[]) {

Vector<Persona> v = new Vector<Persona>();

System.out.println("La capacidad inicial del vector es: "+v.capacity());

System.out.println("La capacidad actual del vector es: "+v.capacity());

System.out.println("La capacidad actual del vector es: "+v.capacity());

Como se apuntaba en el artículo Cadenas compactas en Java 9 que

Definición de la clase String

No hemos de olvidar que Java es un lenguaje muy usado para el desarrollo de

String saludo = "Hola"; // Creamos la cadena con un contenido

saludo = saludo + " mundo"; // y le agregamos después una subcadena

Java está presente en más de 15.000.000.000 de dispositivos. Una razón de peso

Cadenas de caracteres mutables: los tipos StringBuilder y StringBuffer

StringBuilder saludo = new StringBuilder("Hola");

¿Qué hacer si necesitamos trabajar con cadenas de caracteres mutables en un

Cuando el compilador se ocupa de optimizar por nosotros

String resultado = "Cuadrados\n";

for(int i = 1; i <= 100; i++)

El compilador de Java es suficientemente inteligente como para identificar estos

3. COPIAR ARRAYS Y COMPARAR ARRAYS. IDENTIDAD E IGUALDAD

Al trabajar con arrays de tipos primitivos o de objetos se nos puede plantear la

EJERCICIO EJEMPLO RESUELTO 1. COPIAR ESTABLECIENDO UNA

//Test de copia de arrays aprenderaprogramar.com

public class TestCopiaArrays {

public static void main (String [ ] Args) {

int [ ] miArray1 = {2, -4, 3, -7};

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

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

int [ ] otroArray = {1, 2, 4, 8};

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

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

System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );

otroArray = miArray1; //otroArray pasa a ser el mismo objeto que miArray1

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

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

} //Cierre del main