PRG – Q5 Break Continue Array

Programación JAVA
[Capte la atención del lector con una descripción breve atractiva. Esta
descripción es un resumen breve del documento. Cuando esté listo para
agregar contenido, haga clic aquí y empiece a escribir.]
[Subtítulo del
documento]
Contenido
Break y Continue ........................................................................................................................... 2
Sentencia sin etiqueta (Unlabeled) ........................................................................................... 3
Sentencia con etiqueta (Labeled).............................................................................................. 3
Array (Vectores) ............................................................................................................................ 6
DECLARACIÓN DE ARRAYS ........................................................................................................ 6
ASIGNACIÓN DE ARRAYS ........................................................................................................... 6
Array Bidimensional .................................................................................................................. 8
Copying Arrays .......................................................................................................................... 9
Break y Continue
Las palabras reservadas break y continue, se utilizan en Java para detener
completamente un bucle (break) o detener únicamente la iteración actual y saltar a la
siguiente (continue). Normalmente si usamos break o continue, lo haremos dentro de
una sentencia if, que indicará cuándo debemos detener el bucle al cumplirse o no una
determinada condición.
La gran diferencia entre ambos es que, break, detiene la ejecución del bucle y salta a la
primera línea del programa tras el bucle y continue, detiene la iteración actual y pasa a
la siguiente iteración del bucle sin salir de él (a menos, que el propio bucle haya llegado
al límite de sus iteraciones).
NOTA: La sentencia continue debe estar siempre incluida dentro de un bucle, sino
recibiréis un error de compilación. Mientras que la sentencia break, podemos
encontrarla dentro de un bucle o en una sentencia switch. (Aunque esta regla no la
aplicamos a los break con etiqueta, ahora lo veremos)
La sentencia continue provoca que únicamente la iteración actual del bucle más interno
detenga su ejecución y que comience inmediatamente la siguiente iteración si el bucle
todavía no ha terminado. Por ejemplo:
for (int i = 0; i < 10; i++) {
System.out.println("Dentro del bucle");
continue;
System.out.println("Nunca lo escribira");
}
Cada vez que el programa alcance la sentencia continue, saltará a una nueva iteración
del bucle y por tanto la última sentencia System.out.println nunca llegará a escribirse. El
resultado del programa será escribir 10 veces “Dentro del bucle”.
Sin embargo, la sentencia break provoca que el programa detenga la ejecución del bucle
más interno y continúe la ejecución desde la primera línea de código que se encuentre
tras el bucle. Por ejemplo:
for (int i = 0; i < 10; i++) {
System.out.println("Dentro del bucle");
break;
System.out.println("Nunca lo escribira");
}
System.out.println("Tras el bucle");
Cuando el programa alcance la sentencia break, detendrá la ejecución del bucle y saldrá
de él. Por tanto el resultado de la ejecución del programa será:
"Dentro del Bucle"
"Tras el bucle"
El bucle for, sólo ejecuta una iteración y después termina, continuando el programa
desde la primera línea tras el bucle.
Las sentencias break y continue pueden llevar asociada una etiqueta (Labeled) o no
(Unlabeled). Vamos a ver ambos casos:
Sentencia sin etiqueta (Unlabeled)
Este es el uso más común que solemos hacer de las etiquetas break y continue. Los
ejemplos que hemos visto hasta ahora son ejemplos claros de sentencias sin etiqueta.
Veamos un par de ejemplos más:
Break:
boolean problema = true;
while (true) {
if (problema) {
System.out.println("There was a problem");
break;
}
}
// Siguiente línea de código
Continue:
while (!EOF) {
//leemos un campo de un fichero
if (wrongField) {
continue;
// vamos al siguiente campo
}
// procesamos el campo
}
Sentencia con etiqueta (Labeled)
Hay muchas sentencias en un programa en Java que pueden ser etiquetadas, pero su uso
más común es con los bucles for y while, asociadas a break y continue. Una etiqueta
debe ir colocada justo antes del bucle al que va etiquetando y se forma con un
identificador válido seguido de dos puntos (:).
Hay que tener muy clara la diferencia entre usar sentencias break y continue con
etiquetas a usar sentencias break y continue sin etiquetar. El uso de las sentencias break
y continue con etiquetas, será necesario cuando tengamos varios bucles anidados y
necesitemos indicar cuál es el bucle anidado que debe continuar su ejecución tras
romper el flujo normal de ejecución del programa. Por ejemplo:
bucle1:
for (int i = 0; i < 10; i++) {
System.out.println("Bucle i. i = "+i);
for (int j = 0; j < 10; j++) {
System.out.println("Bucle j. j = "+j);
for (int k = 0; k < 10; k++) {
System.out.println("Bucle k. k = "+k);
break bucle1;
}
}
}
En esta ocasión la salida del programa sería:
"Bucle i. i = 0"
"Bucle j. j = 0"
"Bucle k. k = 0"
El programa comienza la ejecución en el primer bucle for. Ejecuta la primera iteración y
entra en el bucle for anidado de “j”. Realiza la primera iteración y entra en el bucle for
anidado de “k”. Aquí nuevamente ejecuta la primera iteración y se encuentra con una
sentencia break. (Recordad que break, detiene la ejecución del bucle y provoca que el
programa continúe desde la primera línea depués del bucle). Pero en este caso es una
sentencia break con etiqueta, por tanto, continuará con la primera línea tras el bucle que
está indicado por la etiqueta. Y en esta ocasión es el bucle for de “i”; de esta forma, al
ejecutar esta sentencia break, provocamos el que programa deje de ejecutar el resto de
iteraciones de los tres bucles for anidados.
Veamos un ejemplo con una sentencia continue.
fuera:
for (int i=0; i<5; i++) {
for (int j=0; j<5; j++) {
System.out.println("Dentro");
continue fuera;
} // fin del bucle anidado
System.out.println("fuera"); // nunca lo escribe
}
System.out.println("Fuera del bucle");
La salida que obtenemos tras la ejecución del código anterior es:
Dentro
Dentro
Dentro
Dentro
Dentro
Fuera del bucle
Veamos porqué.
Después de que se ejecute la sentencia continue, el flujo de ejecución continúa
ejecutando la siguiente iteración del bucle for identificado por la etiqueta, hasta que éste
alcance la condición de parada. Finalmente, cuando la condición de parada del bucle se
alcanza, el bucle termina y se escribirá “Fuera del Bucle”. Si en lugar de poner una
sentencia continue, hubieramos puesto un break, el resultado hubiera sido:
Dentro
Fuera del bucle
NOTA: Las sentencias break y continue con etiquetas, deben estar dentro del bucle que
tiene la misma etiqueta, de otra forma, el codigo no compilará.
Ejercicio. (Entregar)
Realizar un programa que dado un entero por pantalla devuelva un listado de los
numero primos desde el cero hasta el dato introducido, usar bucles y break o continue.
Array (Vectores)
En este tema veremos el uso de los arrays o
vectores. Los arrays consisten en realizar una
carga con varios datos a una misma variable, es
decir, si quisiéramos almacenar las notas de n alumnos debería ser dinámico y
usaríamos los arrays independientemente para cada alumno pero con una misma
variable.
Empecemos a ver un poco sobre la forma de uso de los arrays
DECLARACIÓN DE ARRAYS
int[] ArrayEnteros = new int[50];
float[] ArrayReales = new float[50];
boolean[] Valo r = new boolean[50];
String[] CadenaMultiple = new String[50];
Primero identificamos con los primeros corchetes que es un tipo array, luego al
asignarle el valor new <tipo>[<Longitud>] estamos especificando cuantos datos va a
poder recibir nuestro array
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
//this form is discouraged
float anArrayOfFloats[];
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
Ejemplo:
//create an array of integers
anArray = new int[10];
ASIGNACIÓN DE ARRAYS
anArray[0] = 100; // initialize first
element
anArray[1] = 200; // initialize second
element
anArray[2] = 300; // and so forth
Para asignar generalmente
usaremos
los
bucles
aunque no es algo obligatoria ya que se pueden asignar los valores según los
necesitemos. Como ejemplo haremos la asignación de todas las variables declaradas
mediante un bucle for
int i;
for(i=0;i<50;i++){
ArrayEnteros[i]=i;
ArrayReales[i]=i;
Valor[i]=true;
CadenaMultiple[i]="Cadena";}
El “i” dentro de los corchetes indica la posición de memoria donde se almacenará el
valor que se le pase, en este caso “i” empieza desde “0” tal como los arrays que siempre
empieza su posición de memoria desde 0 aunque podríamos hacer que recauda sus
valores desde otra posición. Como vemos el bucle va desde “0” hasta “49” lo cual
consta de 50 vueltas y llena a todos los arrays con los datos que les pasemos, si
llegaríamos a la vuelta “51” surgiría un error de desbordamiento de memoria ya que los
arrays lo declaramos sólo hasta 50 espacios de memoria
IMPRESIÓN DE ARRAYS
Para imprimir los valores de un array se usa la misma lógica de cuando lo almacenamos,
lo cual se puede apreciar seguidamente
Supongamos que queremos imprimir el ArrayEnteros pero sólo queremos los 7
primeros valores, lo haríamos de la siguiente forma
for(i=0;i<7;i++){
System.out.println(ArrayEnteros[i]);}
Resultado
0
1
2
3
4
5
6
Como podemos ver imprime sólo los 7 primeros valores, así podríamos imprimir los
valores de las posiciones de memoria que deseemos
Ejercicio EjArray01: (Entregar)
Realizar un programa que cree muestre los primeros 100 números por pantalla. Este programa
debe de estar realizado exclusivamente con Arrays, tipo de dato donde se almacenara
previamente los datos.
Array Bidimensional
En Java es posible crear arrays con más de una dimensión, pasando de la idea de lista, vector o
matriz de una sola fila a la idea de matriz de m x n elementos, estructuras tridimensionales,
tetradimensionales, etc. La sintaxis será:
Tipo_de_variable[ ][ ] ….. [ ] Nombre_del_array = new Tipo_de_variable[dimensión1]
[dimensión2]….[dimensiónN];
/* Ejemplo declaración - aprenderaprogramar.com */
int[][] matriz = new int[3][2];
El número de elementos sería: 3 x 2 = 6,
dónde 3 es el número de filas y 2 es el
número de columnas.
O alternativamente
int[][] matriz;
matriz = new int[3][2];
Ahora procedemos a cargar la matriz con
valores:
matriz[0][0]
matriz[0][1]
matriz[1][0]
matriz[1][1]
matriz[2][0]
matriz[2][1]
=
=
=
=
=
=
1;
2;
3;
4;
5;
6;
class MultiDimArrayDemo {
public static void main(String[] args) {
String[][] names = {
{"Mr. ", "Mrs. ", "Ms. "},
{"Smith", "Jones"}
};
// Mr. Smith
System.out.println(names[0][0] + names[1][0]);
// Ms. Jones
System.out.println(names[0][2] + names[1][1]);
}
}
int[][] matriz = {{1,2},{3,4},{5,6}};
donde {1,2} corresponde a la fila 1, {3,4} a la fila 2 y {5,6} a la fila 3, y los números
separados por coma dentro de cada fila, corresponden a las columnas. En este caso, los
números (1, 3, 5) de cada una de las filas corresponden a la primera columna y los
números (2, 4, 6) atañen a la segunda columna.
Para obtener el número de filas de la matriz, podemos recurrir a la propiedad “length”
de los arrays, de la siguiente manera:
int filas = matriz.length;
Para el caso del número de columnas sería de la siguiente forma:
int columnas = matriz[0].length;
También Java nos permite la posibilidad de clonar una matriz, es decir, crear una matriz
nueva a partir de otra matriz, siguiendo esta sintaxis:
String[][] nuevaMatriz = matriz.clone();
donde clone() es un método especial, que permite la clonación de arrays de cualquier
dimensión en Java. De esta manera “nuevaMatriz” y “matriz” son 2 matrices distintas
pero con los mismos valores. Hablaremos del método clone más adelante.
Ejercicio EjArray02: (Entregar)
Vamos a plantear y resolver un ejercicio: queremos almacenar en una matriz el número
de alumnos con el que cuenta una academia, ordenados en función del nivel y del
idioma que se estudia. Tendremos 3 filas que representarán al Nivel básico, medio y de
perfeccionamiento y 4 columnas en las que figurarán los idiomas (0 = Inglés, 1 =
Francés, 2 = Alemán y 3 = Ruso). Se pide realizar la declaración de la matriz y asignarle
unos valores de ejemplo a cada elemento.
Copying Arrays
The System class has an arraycopy method that you can use to efficiently copy data
from one array into another:
public static void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length)