Imprimir Página - Los GoTo de JAVA, CONTINUE :TAG, BREAK:TAG, TRY CATH THROW FINALLY

Lenguajes de programación para PC => C, C#, C++ => Mensaje iniciado por: CompSystems en 31 de Enero de 2016, 11:06:48

Título: Los GoTo de JAVA, CONTINUE :TAG, BREAK:TAG, TRY CATH THROW FINALLY
Publicado por: CompSystems en 31 de Enero de 2016, 11:06:48

Hola amigos foreros, ya tengo varios hilos sobre JAVA, uno es GUI creadas desde teclado, otra es GUI creadas desde la pestaña DISEÑO de un IDE (arrastrar y pegar componentes o controladores)

Ahora hablare de un tema muy controversial el GoTo

Ya son 20 años desde que salio este super mega lenguaje, adquirió fama al revolucionar la Internet, pues antes de java las paginas web eran estáticas, con la introducción de los códigos ejecutables (APPLETS) sobre una pagina WEB se dio a la misma, animación, interactividad, etc. Muchas aplicaciones para PC se portaron a JAVA, por ejemplo MatLab esta re-escrito en gran parte en JAVA.

Se ha compilado programas JAVA para usarse en diversos equipos, desde nuestro ordenador o computador portátil, hasta en juguetes, relojes, tablets, celulares, periféricos de sistemas embebidos como pantallas táctiles etc. y mas allá ... de esos millones de códigos fuente ¿alguien no ha necesitado un Goto?

¿por que JAVA no tiene un GoTo funcional?

JAVA si tiene una palabra reservada GoTo, pero los diseñadores la reservaron sin funcionalidad, dicen que para incorporarla en un futuro, si hubiera una petición masiva por parte de los desarrolladores o programadores a nivel mundial, pero parece que nadie necesita un GoTo, también se dice que los diseñadores de JAVA reservaron la palabra GoTo, para que nadie creara una método o función que realice un GoTo y con el nombre en minúsculas "goto"

NO soy un teórico de la computación, ni soy maestro en JAVA, ni en informática, apenas un autodidacta en programación de alto nivel, así que mis exposiciones pueden estar erradas, alguien con mayor dominio del tema me puede refrendar o dar valides o no, a lo siguiente

¿Es necesaria e indispensable la instrucción GOTO? pues NO!, hay ciertos algoritmos en especial algebraicos donde existen una lógica o secuencia de ruptura de un lazo o bucle dentro de varios bucles anidados, la ruptura puede ser salir del bucle actual o salir del bucle actual y todos los anidados interiormente y caso mas extremo salir y abandonar todos los bucles e ir a una parte x del código, implica este tipo de lógica, que no se puede estructurar dicho algoritmo, entonces en este caso se requiere, QUIERA O NO la instrucción GOTO, pero que pasa si ese algoritmo tiene un algoritmo ALTERNATIVO o con pequeñas modificaciones de mover bloques de sentencias que no es considerado propiamente una modificación ejemplo

x=5
y=6

si intercambio

y=6
x=5

el algoritmo es igual lo importante es conservar las verdaderas sentencias del algoritmo como expresiones artimeticas, tampoco se considera cambio del algoritmo al agregar mas variables como desbordes de contadores para hacer una salida forzada del bucle, es decir o en resumen que haga lo mismo agregando pasos extras el algoritmo en ciertas partes y si no se puede mejor crear un nuevo algoritmo, que en tiempo de respuesta o no podría ser mas rápido o mas lento, entonces ESTE ALGORITMO ALTERNATIVO no se necesita el GOTO como tal, ósea que la TEORÍA DE QUE UN LENGUAJE ES INFERIOR por que no posee GOTO esta echada bajo tierra, se reivindicara el GOTO cuando exista en el mundo un único algoritmo y que nadie halla sido capaz de crear un alterno para solucionar algo y ese algoritmo requiera al menos un solo GoTo

Ahora en JAVA si hay GoTos, pero limitados o como deben ser, es decir se limita a ciertos sectores del código o cuerpos de bloque pero no un GOTO como valla a la etiqueta en x en tal parte del código, ya que un código con GoTos puede ser 100% funcional y lo mejor sin errores en su respuesta, pero un código fuente con GoTos se lo denomina "Código spaghetti/espagueti" un maraña que solo la entiende el creador, no Dios, si no el creador del código, los GoTos en otros lenguajes también son importantes para la captura de errores en tiempo de ejecución SI hay un error IR A ....

Los GoTos limitados de JAVA son: CONTINUE :TAG, BREAK:TAG, y para detectar o capturar errores TRY CATH THROW FINALLY con estas instrucciones se puede solventar cualquier tipo de algoritmo, por esta razón aun no es útil un GoTo en JAVA, si es que lo es alguna ves en su existencia

¿Debemos enterrar la sentencia GOTO?

Muy pocos le dan uso a las instrucciones CONTINUE y BREAK muy útiles para simplificar código en ciertos algoritmos en donde se requiere saltar entre ciclos sin usar contadores de desborde, mostrare códigos CONTINUE y BREAK versus la VERSION SIN LOS MISMOS y es la que mas me gusta, finaliza este hilo con TRY CATH THROW FINALLY

A: instrucción CONTINUE
En tiempo de corrida o ejecución, si dentro de un cuerpo o bloque de repetición como FOR, se encuentra la instrucción CONTINUE el código que esta debajo de este, hasta el cierre de cuerpo del bloque de repetición (}) no se ejecuta, en otras palabras hace un salto o GoTo a la siguiente iteración del ciclo

1er Ejemplo:

Algoritmo:

Código: [Seleccionar]

Crear 1 FOR 
FOR1: rango [0, 5] paso 1  
Dentro del FOR1, mostrar valor actual del contador, calcule y muestre el cuadrado del contador

Código: Java

package curso_JAVA.consola.gotos;
public class EJEMPLO1_CONTINUE {
 
    public static void main(String argumentos_de_entrada[]) {
        double cuadrado = 0.;
        for (int ciclo1_contador = 0; ciclo1_contador <= 5; ciclo1_contador = ciclo1_contador + 1) {
            System.out.println("contador del ciclo1 en: " + ciclo1_contador);
            // valor al cuadrado del contador de ciclos
            cuadrado =  Math.pow(ciclo1_contador,2);
            continue;
             System.out.println("contador^2: " + ciclo1_contador  + "^2 = " + cuadrado);
             System.out.println("");
       }//next for
 
    }//main
 
}//class

la salida es

----------------------------------------
contador del ciclo1 en: 0
contador del ciclo1 en: 1
contador del ciclo1 en: 2
contador del ciclo1 en: 3
contador del ciclo1 en: 4
contador del ciclo1 en: 5
----------------------------------------

Pero no mostró o desplegó en pantalla los cuadrados de cada contador, ¿por qué?

Las sentencias

Código: Java

System.out.println("contador^2: " + ciclo1_contador  + "^2 = " + cuadrado);
System.out.println("");

nunca se ejecutan, pues antes de estas, la instrucción CONTINUE hace un GoTo a la próxima iteracion, el algoritmo no retorna lo deseado, se indicó como afecta una instrucción CONTINUE dentro de un bucle o ciclo

Si eliminamos la sentencia CONTINUE; todo el bloque se ejecutará y algoritmo propuesto arrojara lo pedido

La salida ahora es

----------------------------------------
contador del ciclo1 en: 0
contador^2: 0^2 = 0.0

contador del ciclo1 en: 1
contador^2: 1^2 = 1.0

contador del ciclo1 en: 2
contador^2: 2^2 = 4.0

contador del ciclo1 en: 3
contador^2: 3^2 = 9.0

contador del ciclo1 en: 4
contador^2: 4^2 = 16.0

contador del ciclo1 en: 5
contador^2: 5^2 = 25.0
----------------------------------------

Título: Re:Algo mas sobre JAVA
Publicado por: juaperser1 en 31 de Enero de 2016, 11:20:30

Hola compysystem, tengo una recomendación, creo que deberías cambiar el titulo del tema para dejar mas claro la parte de java que estas explicando, así será más fácil de encontrar para quien busque esta información.

Obviamente es solo un consejo ;-)

Un saludo

Título: Los GoTo de JAVA ...
Publicado por: CompSystems en 31 de Enero de 2016, 12:22:17

OK juaperser1, como dice JAVA refactor from "Algo mas sobre JAVA" to "Los GoTo de JAVA ..."

Como buena practica de programación informática, la instrucción CONTINUE se debe ser colocar dentro de un bloque de una estructura condicional

2do ejemplo

Algoritmo:

Código: [Seleccionar]

Crear 1 solo bucle usando FOR 
FOR1: rango [0, 5] paso 1  
Dentro del FOR1, mostrar valor actual y si el CONTADOR no es par (impar), salte a la siguiente iteración, 
de lo contrario calcule y muestre el cuadrado del contador, 
use un indicador, flag o bandera para determinar si es par o impar

Código: Java

package curso_JAVA.consola.gotos;
public class EJEMPLO2_CONTINUE {
 
    public static void main(String argumentos_de_entrada[]) {
        System.out.println("----------------------------------------");
        System.out.println("... Antes de entrar al bucle o ciclo PARA");
 
        boolean esPar = false;
        double control;// = 0.;
        for (int ciclo1_contador = 0; ciclo1_contador <= 5; ciclo1_contador = ciclo1_contador + 1) {
            System.out.println("\ncontador del ciclo1 en: " + ciclo1_contador);
            esPar = ((ciclo1_contador % 2) == 0);
            if (!esPar) {
                // Si no es par salta a la siguiente iteración y no ejecuta el bloque de abajo
                continue;
            }
            
            // Bloque condicional controlado por CONTINUE
            // valor al cuadrado del contador de ciclos 
            control = Math.pow(ciclo1_contador, 2);
            System.out.println("contador^2: " + ciclo1_contador + "^2 = " + control);
            // Fin del bloque condicional
            
        }//next for
        System.out.println("\nDespués de Salir del bucle o ciclo PARA ...");
        System.out.println("----------------------------------------");
 
    }//main
}//class

salida

----------------------------------------
... Antes de entrar al bucle o ciclo PARA

contador del ciclo1 en: 0
contador^2: 0^2 = 0.0

contador del ciclo1 en: 1

contador del ciclo1 en: 2
contador^2: 2^2 = 4.0

contador del ciclo1 en: 3

contador del ciclo1 en: 4
contador^2: 4^2 = 16.0

contador del ciclo1 en: 5

Después de Salir del bucle o ciclo PARA ...
----------------------------------------

el código anterior es muy trivial, solo es una demostración del uso de CONTINUE, dejando la condición intacta, el código debajo donde estaba el CONTINUE, se lo puede reemplazar encerrándolo dentro un cuerpo ELSE{}

Código: Java

package curso_JAVA.consola.gotos;
public class EJEMPLO2_CONTINUE {
 
    public static void main(String[] args) {
        System.out.println("----------------------------------------");
        System.out.println("... Antes de entrar al bucle o ciclo PARA");
 
        boolean esPar = false;
        double control;// = 0.;
        for (int ciclo1_contador = 0; ciclo1_contador <= 5; ciclo1_contador = ciclo1_contador + 1) {
            System.out.println("\ncontador del ciclo1 en: " + ciclo1_contador);
            esPar = ((ciclo1_contador % 2) == 0);
            if (!esPar) {
                // no realice nada
            } else {
                 // valor al cuadrado del contador de ciclos
                control = Math.pow(ciclo1_contador, 2);
                System.out.println("contador^2: " + ciclo1_contador + "^2 = " + control);
            }
        }//next for
        System.out.println("\nDespués de Salir del bucle o ciclo PARA ...");
        System.out.println("----------------------------------------");
 
 
    }//main
}//class

otra opción es introducir o mover el código debajo donde estaba el CONTINUE, dentro del cuerpo THEN del IF, pero además se necesita suprimir la negación de NO ES PAR por ES PAR para conservar la lógica del algoritmo

Código: Java

if (esPar) {
                 // valor al cuadrado del contador de ciclos
                control = Math.pow(ciclo1_contador, 2);
                System.out.println("contador^2: " + ciclo1_contador + "^2 = " + control);
            }

... Pero el poder de CONTINUE es que este permite una etiqueta, antes de mostrar un ejemplo veamos la instrucción BREAK

A: instrucción BREAK
En tiempo de corrida o ejecución, si dentro de un cuerpo o bloque de repetición como FOR, se encuentra la instrucción BREAK abandona y termina el ciclo, en otras palabras hace un salto o GoTo a la siguiente sentencia después del cierre de cuerpo del bloque de repetición ( } )

Título: Re:Los GoTo de JAVA
Publicado por: CompSystems en 31 de Enero de 2016, 20:26:14

Código reemplazando CONTINUE con BREAK del ejemplo anterior

3cer Ejemplo

Algoritmo:

Código: [Seleccionar]

Crear 1 FOR 
FOR1: rango [0, 5] paso 1  
Dentro del FOR1, mostrar valor actual y si el CONTADOR no es par (impar)
termine el ciclo o rutina de repetición 
de lo contrario calcule y muestre el cuadrado del contador

Código: Java

package curso_JAVA.consola.gotos;
public class EJEMPLO3_BREAK {
 
    public static void main(String argumentos_de_entrada[]) {
        System.out.println("----------------------------------------");
        System.out.println("... Antes de entrar al bucle o ciclo PARA");
 
        boolean esPar;// = false;
        double control;// = 0.;
        for (int ciclo1_contador = 0; ciclo1_contador <= 5; ciclo1_contador = ciclo1_contador + 1) {
            System.out.println("\ncontador del ciclo1 en: " + ciclo1_contador);
            esPar = ((ciclo1_contador % 2) == 0);
            if (!esPar) {
                // Si no es par termine el ciclo o bucle
                break;
            } else {
                  // valor al cuadrado del contador de ciclos
                control = Math.pow(ciclo1_contador, 2);
                System.out.println("contador^2: " + ciclo1_contador + "^2 = " + control);
              }
        }//next for
        System.out.println("\nDespués de Salir del bucle o ciclo PARA ...");
        System.out.println("----------------------------------------");
 
    }//main
}//class

Salida

----------------------------------------
... Antes de entrar al bucle o ciclo PARA

contador del ciclo1 en: 0
contador^2: 0^2 = 0.0

contador del ciclo1 en: 1

Después de Salir del bucle o ciclo PARA ...
----------------------------------------

Título: Re:Los GoTo de JAVA
Publicado por: CompSystems en 31 de Enero de 2016, 22:12:11

Un ejemplo donde se anidan FORes, la secuencia se ve interrumpida por condiciones como si el contador es o no par del ciclo anterior, esto con el propósito de hacer saltos condicionales entre FORes

4to Ejemplo

Algoritmo:

Código: [Seleccionar]

Crear 3 FORes 
FOR1: rango [0, 5] paso 1  
FOR2: rango [4, 7] paso 1 
FOR3: rango [8, 11] paso 1 

anidar FOR 2 dentro FOR1
anidar FOR3 dentro FOR2
debe estar FOR3 dentro de FOR2 dentro de FOR1

Dentro del FOR1, mostrar valor actual del contador y si el contador del FOR1 supera el valor de 3 abandonar todos los ciclos internos a FOR1

Dentro del FOR2, mostrar valor actual del contador y si el contador del FOR anterior (FOR1) es par, terminar ciclo ACTUAL e INTERNOS (FOR2) 

Dentro del FOR3, mostrar valor actual del contador y  si el contador del FOR anterior (FOR2) es impar, terminar ciclo ACTUAL

Código: Java

public class package curso_JAVA.consola.gotos;
public class EJEMPLO4_BREAK {
 
 
    public static void main(String argumentos_de_entrada[]) {
        System.out.println("----------------------------------------");
        System.out.println("... Antes de entrar al bucle o ciclo PARA");
 
       
        System.out.println("rango para cada ciclo");
        System.out.println("for i desde 0 a 5 en pasos de 1, total 6 pasos");
        System.out.println("for j desde 4 a 7 en pasos de 1,, total 4 pasos");
        System.out.println("for k desde 8 a 11 en pasos de 1, total 4 pasos\n");
 
        int i;
        int minI = 0;
        int maxI = 5;
        int incrI = 1;
 
        int j;
        int minJ = 4;
        int maxJ = 7;
        int incrJ = 1;
 
        int k;
        int minK = 8;
        int maxK = 11;
        int incrK = 1;
 
        for (i = minI; i <= maxI; i = i + incrI) {
            System.out.println("Bucle I [" + minI + ", ... " + maxI + "]");
            System.out.println("      I = " + i);
            if (i > 3) {
                System.out.println("      como el contador I es mayor que 3, termina bloque ACTUAL I e INTERNOs J,K\n");
                break;
            }
 
            for (j = minJ; j <= maxJ; j = j + incrJ) {
                System.out.println("Bucle __J [" + minJ + ", ... " + maxJ + "]");
                System.out.println("        J = " + j);
                if ((i % 2) == 0) {
                    System.out.println("        como el contador anterior I es par, termina bloque ACTUAL J e INTERNO K\n");
                    break;
                }
 
                for (k = minK; k <= maxK; k = k + incrK) {
                    System.out.println("Bucle   __K [" + minK + ", ... " + maxK + "]");
                    System.out.println("          K = " + k);
                    if ((j % 2) != 0) {
                        System.out.println("          como el contador anterior J es IMPAR, termina bloque ACTUAL K\n");
                        break;
                    }
 
                }//next for K
            }//next for J
        }//next for I
 
        System.out.println("\nDespués de Salir del bucle o ciclo PARA ...");
        System.out.println("----------------------------------------");
    }//main
}//class

salida

... Antes de entrar al bucle o ciclo PARA
rango para cada ciclo
for i desde 0 a 5 en pasos de 1, total 6 pasos
for j desde 4 a 7 en pasos de 1,, total 4 pasos
for k desde 8 a 11 en pasos de 1, total 4 pasos

Bucle I [0, ... 5]
I = 0
Bucle __J [4, ... 7]
J = 4
como el contador anterior I es par, termina bloque ACTUAL J e INTERNO K

Bucle I [0, ... 5]
I = 1
Bucle __J [4, ... 7]
J = 4
Bucle __K [8, ... 11]
K = 8
Bucle __K [8, ... 11]
K = 9
Bucle __K [8, ... 11]
K = 10
Bucle __K [8, ... 11]
K = 11
Bucle __J [4, ... 7]
J = 5
Bucle __K [8, ... 11]
K = 8
como el contador anterior J es IMPAR, termina bloque ACTUAL K

Bucle __J [4, ... 7]
J = 6
Bucle __K [8, ... 11]
K = 8
Bucle __K [8, ... 11]
K = 9
Bucle __K [8, ... 11]
K = 10
Bucle __K [8, ... 11]
K = 11
Bucle __J [4, ... 7]
J = 7
Bucle __K [8, ... 11]
K = 8
como el contador anterior J es IMPAR, termina bloque ACTUAL K

Bucle I [0, ... 5]
I = 2
Bucle __J [4, ... 7]
J = 4
como el contador anterior I es par, termina bloque ACTUAL J e INTERNO K

Bucle I [0, ... 5]
I = 3
Bucle __J [4, ... 7]
J = 4
Bucle __K [8, ... 11]
K = 8
Bucle __K [8, ... 11]
K = 9
Bucle __K [8, ... 11]
K = 10
Bucle __K [8, ... 11]
K = 11
Bucle __J [4, ... 7]
J = 5
Bucle __K [8, ... 11]
K = 8
como el contador anterior J es IMPAR, termina bloque ACTUAL K

Bucle __J [4, ... 7]
J = 6
Bucle __K [8, ... 11]
K = 8
Bucle __K [8, ... 11]
K = 9
Bucle __K [8, ... 11]
K = 10
Bucle __K [8, ... 11]
K = 11
Bucle __J [4, ... 7]
J = 7
Bucle __K [8, ... 11]
K = 8
como el contador anterior J es IMPAR, termina bloque ACTUAL K

Bucle I [0, ... 5]
I = 4
como el contador I es mayor que 3, termina bloque ACTUAL I e INTERNOs J,K

Después de Salir del bucle o ciclo PARA ...

Título: Re:Los GoTo de JAVA
Publicado por: CompSystems en 01 de Febrero de 2016, 00:19:02

Ejemplo 4.1

El RETO ahora es codificar el mismo código sin el uso de BREAK, para demostrar que aun sin BREAK y CONTINUE se puede llevar la logica de un algoritmo a codigo

reto superado :-/

Código: Java

package curso_JAVA.consola.gotos;
public class EJEMPLO4_1_BREAK {
 
    public static void main(String argumentos_de_entrada[]) {
        System.out.println("----------------------------------------");
        System.out.println("... Antes de entrar al bucle o ciclo PARA");
 
        System.out.println("rango para cada ciclo");
        System.out.println("for i desde 0 a 5 en pasos de 1, total 6 pasos");
        System.out.println("for j desde 4 a 7 en pasos de 1,, total 4 pasos");
        System.out.println("for k desde 8 a 11 en pasos de 1, total 4 pasos\n");
 
        int i;
        int minI = 0;
        int maxI = 5;
        int incrI = 1;
 
        int j;
        int minJ = 4;
        int maxJ = 7;
        int incrJ = 1;
 
        int k;
        int minK = 8;
        int maxK = 11;
        int incrK = 1;
 
        for (i = minI; i <= maxI; i = i + incrI) {
            boolean desbordeI = false;
            System.out.println("Bucle I [" + minI + ", ... " + maxI + "]");
            System.out.println("      I = " + i);
            if (i > 3) {
                System.out.println("      como el contador I es mayor que 3, termina bloque ACTUAL I e INTERNOs J,K\n");
                desbordeI = true; // se fija a verdadero el ID de desborde de I
                // desborda el contador de i, por ende sale del ciclo I
                i = maxI + incrI;
                //break;
            }// end if
 
            for (j = minJ; j <= maxJ; j = j + incrJ) {
                boolean desbordeJ = false;
                if (desbordeI == true) {
                    // se coloca j > maxJ para que el ciclo for J nunca se efectue
                    j = maxJ + incrJ;
                } else {
                    System.out.println("Bucle __J [" + minJ + ", ... " + maxJ + "]");
                    System.out.println("        J = " + j);
                    if ((i % 2) == 0) {
                        System.out.println("        como el contador anterior I es par, termina bloque ACTUAL J e INTERNO K\n");
                        desbordeJ = true; // se fija a verdadero el ID de desborde de J
                        // desborda el contador de J, por ende sale del ciclo J
                        j = maxJ + incrJ;
                        // break;
                    }// end if
                }// end else
                for (k = minK; k <= maxK; k = k + incrK) {
                    if (desbordeI == true || desbordeJ == true) {
                        // se coloca k > maxK para que el ciclo for K nunca se efectue
                        k = maxK + incrK;
                        // invierte el flag
                        desbordeI = false;
                        desbordeJ = false;
                    } else {
                        System.out.println("Bucle   __K [" + minK + ", ... " + maxK + "]");
                        System.out.println("          K = " + k);
                        if ((j % 2) != 0) {
                            System.out.println("          como el contador anterior J es IMPAR, termina bloque ACTUAL K\n");
                            // desborda el contador de k, por ende sale del ciclo K
                            k = maxK + incrK;
                            //break;
                        }// end if
                    }// end else
                }//next for K
            }//next for J
        }//next for I
 
        System.out.println("\nDespués de Salir del bucle o ciclo PARA ...");
        System.out.println("----------------------------------------");
    }//main
}//class

Título: Re:Los GoTo de JAVA
Publicado por: KILLERJC en 01 de Febrero de 2016, 00:51:04

Citar

el código anterior es muy trivial, solo es una demostración del uso de CONTINUE, se podria haber reemplazado por un else

Mas que un else, directamente haber cambiado la condicion del if

Código: Java

for (int ciclo1_contador = 0; ciclo1_contador <= 5; ciclo1_contador = ciclo1_contador + 1) {
            System.out.println("\ncontador del ciclo1 en: " + ciclo1_contador);
            esPar = ((ciclo1_contador % 2) == 0);
            if (esPar) {
                 // valor al cuadrado del contador de ciclos
                control = Math.pow(ciclo1_contador, 2);
                System.out.println("contador^2: " + ciclo1_contador + "^2 = " + control);
            }
        }//next for

El continue y el break funcionan de la misma forma que en C

Título: Re:Los GoTo de JAVA
Publicado por: CompSystems en 01 de Febrero de 2016, 11:46:45

Citar

... directamente haber cambiado la condición del if

Gracias KILLERJC por el aporte, agregado en el ejemplo#2

Citar

El continue y el break funcionan de la misma forma que en C

pero en JAVA tiene la opción de ir a una etiqueta, apenas esta semana me entere de esto consultando sobre el uso de CONTINUE Y BREAK, próximamente anexare ejemplos

Título: Re:Los GoTo de JAVA
Publicado por: CompSystems en 01 de Febrero de 2016, 23:30:43

con la lógica del ejemplo 4.1 (desborde contadores para no usar CONTINUE ni BREAK), muestro un algoritmo practico,

Ejemplo #5

LISTAR LOS #S PRIMOS hasta un valor N

Usa uno de tanto algoritmos de Criba o Colador De Números Primos, recordemos que el primer Colador de primos lo creo Eratóstenes hace mucho mucho tiempo (prehistoria)
El programa debe retornar, los números primos menores a N

Es importante analizar los siguientes casos

Si n es menor que 10 debe mostrar la siguiente lista de #s primos:

{ 2, 3, 5, 7 } (4 en total)

Si n es menor que 100, (26 en total)

{ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 y 97 }

Si n es menor que 1,000 (168 en total)

{ 2   3   5   7   11   13   17   19   23   29   31   37   41   43   47   53   59   61   67
71   73   79   83   89   97   101   103   107   109   113   127   131   137   139   149   151   157   163
167   173   179   181   191   193   197   199   211   223   227   229   233   239   241   251   257   263   269
271   277   281   283   293   307   311   313   317   331   337   347   349   353   359   367   373   379   383
389   397   401   409   419   421   431   433   439   443   449   457   461   463   467   479   487   491   499
503   509   521   523   541   547   557   563   569   571   577   587   593   599   601   607   613   617   619
631   641   643   647   653   659   661   673   677   683   691   701   709   719   727   733   739   743   751
757   761   769   773   787   797   809   811   821   823   827   829   839   853   857   859   863   877   881
883   887   907   911   919   929   937   941   947   953   967   971   977   983   991   997 }

Si n es menor que 10,000 son 1229

{ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, ..., 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973 }

Si n es menor que 100,000 son 9592 ...

¿Que noto a simple vista? que el único primo par es el 2, entonces podemos pensar que un colador o generador de primos debe descartar los números pares o empezar a buscar solamente dentro los números impares 2*n+1 ó 2*n-1, como el código agrega los 2 primeros números primos, basta con chequear desde x = 6 * n - 1

se observa también que al incrementar N, la lista crece rápidamente, entonces si ejecuta el código con N mayor a 1000000 podrá ver que se demora muchísimo tiempo

El código de abajo se codifico con muchas variables para facilitar la depuración, próximamente incluiré código fuente simplificado del mismo y usando BREAK, ...

SI USTED DESEA APRENDER MAS, corra el programa paso a paso, se ha demostrado que un método para facilitar el aprendizaje o adquirir lógica de programacion es "Debugiar" o Depurar un código, ademas observa el mecanismo del algoritmo

El algoritmo indicado abajo no es eficiente, solo sirve para demostrar como usar el desborde del contador de cada FOR para salir del bucle sin usar BREAK o CONTINUE, ni mucho menos el GoTo

Código: [Seleccionar]

PASOS
1: declarar un objeto tipo LISTA, ya que este objeto en JAVA es de tipo dinámico el cual podrá almacenar miles de números solo con la limitante de su memoria RAM 

cálculos aproximados, si me equivoco me corrigen por favor

Si al correr el programa se tiene 1 GiBytes libre en RAM y como un  GiBytes equivale a
2^30 bytes = 1024 mebibyte (MiG) = 1073741824 bytes
y como cada elemento de la lista es un LONG de 8 Bytes,
podemos almacenar 1073741824 bytes / 8 bytes = 134,217,728  ~ 134 mil números primos y cada uno entre [0, ..., 2^(8*8-1)-1=  9,223,372,036,854,775,807] que es el limite de LONG para números enteros positivos en java

pero si almacenamos la salida en un archivo es decir cada primo encontrado lo escribimos en un archivo texto podemos colocar millones de #s primos, solo nos limitaría la capacidad de nuestro disco duro

Si tenemos libre un 1 tebibyte osea 2^40 bytes = 1 099 511 627 776 en nuestro disco duro
 y como LONG maneja hasta 19 dígitos + un espacio = 20 caracteres y so almacenados cada dígito en ASCCI de 8 bytes cada impresión podría ocupar hasta 8*20 = 160 bytes,
con este razonamiento entonces podemos almacenar aproximadamente
1099511627776 / 160 = 6,871,947,673.6 impresiones  ~
6.8 mil millones de números primos pero es mas realmente, por que no todos los primes inician en 19 dígitos

2: adherir el 2 y 3 como los dos primeros primos,, ya que algoritmo cola el primer primo a partir de 5
3: desplegar en pantalla los dos primeros #s primos
4: declarar variables de cada expresión del algoritmo para facilitar la depuración
(N, contador primer bucle)
(K, contador segundo bucle)
(maxK, limite segundo bucle)
(J, contador primo)
...
5: iniciar un bucle en pasos de 1 y entre N=1 hasta N<=100 ó 1000 o el que desee 
6: evaluar la expresión X=6*N-1
...

Código: Java

import java.util.ArrayList;
 
public class UnColadorDePrimos{
 
    public static void main(String[] args) {
        // Crea un objeto tipo lista
        ArrayList<Double> lista = new ArrayList();
        // Adhiere 2 a la lista
        lista.add(2.);
        // Adhiere 3 a la lista
        lista.add(3.);
 
        System.out.println(lista.get(0));
        System.out.println(lista.get(1));
        // variables valor para FOR n
        // Contador para FOR n
        int n;
        // rango FOR n [1, 6] pasos en 1
        int minN = 1;
        int maxN = 100;
        int incrN = 1;
 
        // variables valor para FOR k
        // Contador para FOR k
        int k;
        // rango FOR n [1, j] pasos en 1
        int minK = 1;
        int maxK;
        int incrK = 1;
 
        // Contador, maximo valor para FOR k, inicialmente en 2
        int j = 2;
 
        double x;
 
        for (n = minN; n <= maxN; n = n + incrN) {
            x = 6 * n - 1;
            maxK = j;
            boolean desbordeK = false;
            for (k = minK; k <= maxK; k = k + incrK) {
                desbordeK = false;
                double numero = lista.get(k - 1);
                double testA = numero;
                double testB = Math.sqrt(x);
                boolean test1 = (testA > testB);
                if (test1 == true) {
                    j = j + 1;
                    lista.add(x);
                    System.out.println(lista.get(j - 1));
                    x = 6 * n + 1;                    
                    // Abandonar ciclo
                    desbordeK = true;
                    k = maxK + incrK;
                } else {
                    double testC = x / numero;
                    double testD = Math.floor(x / numero);
                    boolean test2 = (testC == testD);
                    if (test2 == true) {
                        x = 6 * n + 1;
                        desbordeK = true;
                        // Abandonar ciclo
                        k = maxK + incrK;
                    }
                }// end if
 
            }//next for k
 
            if (desbordeK != true) {
                j = j + 1;
                lista.add(x);
                System.out.println(lista.get(j - 1));
            }
 
            maxK = j;
            boolean desbordeK2 = false;
            for (k = minK; k <= maxK; k = k + incrK) {
                desbordeK2 = false;
                double numero = lista.get(k - 1);
                double testA = numero;
                double testB = Math.sqrt(x);
                boolean test1 = (testA > testB);
                if (test1 == true) {
                    j = j + 1;
                    lista.add(x);
                    System.out.println(lista.get(j - 1));
                    // Abandonar ciclo
                    desbordeK2 = true;
                    k = maxK + incrK;
                } else {
                    double testC = x / numero;
                    double testD = Math.floor(x / numero);
                    boolean test2 = (testC == testD);
                    if (test2 == true) {
                        // Abandonar ciclo
                        k = maxK + incrK;
                    }
                }// end if
 
            }//next for k
 
            if (desbordeK2 != true) {
                j = j + 1;
                lista.add(x);
                System.out.println(lista.get(j - 1));
            }
 
        }//next for n
 
    }// main
 
}// class

Título: Re:Los GoTo de JAVA, CONTINUE :TAG, BREAK:TAG, TRY CATH THROW FINALLY
Publicado por: CompSystems en 04 de Febrero de 2016, 09:52:44

Como el máximo long en java es (2^63)-1 = 9,223,372,036,854,775,807 se requiere en ciertos algoritmos números aun mas grandes, como los que se muestran en algunos vídeos de PI con millones de dígitos. ¿Entonces existe en java una biblioteca que maneje números enteros mas grandes que LONG?

Una aplicación de estos números "largos" son los números primos

mas info en wikipedia
https://es.wikipedia.org/wiki/N%C3%BAmero_primo

Código: [Seleccionar]

total primos      rango de búsqueda hasta
0                       10^0=0                                       
4                       10^1=10                                                     
25                      10^2=100                                    
168                     10^3=1,000                                 
1,229                   10^4=10,000             
9,592                   10^5=10,0000             
78,498                  10^6=1millon            
664,579                 10^7=10millones         
5,761,455               10^8=100millones        
50,847,534              10^9=1000millones       
455,052,511             10^10=10,000millones    
4,118,054,813           10^11=100,000millones                
37,607,912,018          10^12=1billon                       
346,065,536,839         10^13=10billones                  
3,204,941,750,802       10^14=100billones                
29,844,570,422,669      10^15=1000billones               
279,238,341,033,925     10^16=10,000billones    
2,623,557,157,654,233   10^17=100,000billones   
24,739,954,287,740,860  10^18=1trillon          
234,057,667,276,344,607 10^19=10trillones                          234,057,667,276,344,607 10^20=100trillones

Título: Re:Los GoTo de JAVA, CONTINUE :TAG, BREAK:TAG, TRY CATH THROW FINALLY
Publicado por: KILLERJC en 04 de Febrero de 2016, 12:40:23

http://docs.oracle.com/javase/6/docs/api/java/math/BigInteger.html

Título: Re:Los GoTo de JAVA, CONTINUE :TAG, BREAK:TAG, TRY CATH THROW FINALLY
Publicado por: CompSystems en 13 de Febrero de 2016, 01:12:06

Gracias por el link, en 20 libros de java que he consultado, hoy encontré uno solo que menciona precisión arbitraria, pero no hay ejemplos en estos libros :( , buscando en la red ...

Ejemplo #6

faltaba agregar un ejemplo usando BREAK y CONTINUE CON ETIQUETAS, las etiquetas deben estar exclusivamente antes de un ciclo, de lo contrario el compilador se quejará, para que sean útiles las etiquetas estas deben romper ciclos, de mas de un ciclo interno, de lo contrario seria equivalente a un CONTINUE y BREAK sin etiqueta, tambien la variable de inicializacion debe ESTAR por lo general POR FUERA DE LOS "PARAMETROS" del FOR,

¿Saben si otros lenguajes tienen la opción del BREAK y CONTINUE con etiquetas?
si es así me comentan, gracias

Ejemplo basado en uno que encontré en un libro de JAVA, Se demuestra que el uso del GOTO sin control NO son necesarios, los únicos GoTo QUE SE REQUIEREN son los mencionados en esta publicación, CONTINUE, BREAK, los mismos con etiqueta y detección de errores, nada mas, hasta que alguien me demuestre lo contrario, e incluso estoy casi seguro que ni los CONTINUE, BREAK se necesitan, pues demostré con ejemplos que todo algoritmo se puede estructurar, reitero hasta que alguien me de un contraejemplo :mrgreen: para modificar este articulo

Los GoTo se los dejamos a los programadores en lenguaje ASM, que a mi también me gusta, pero cada cosa en su lugar

Código: Java

public class BreakYContinueConEtiquetas {
 
    public static void main(String[] args) {
        int i = 1;
        int k = 0;
        outer: // No puede haber sentencias, después de esta instrucción 
 
        for (int f = 1; f <= 4; f = f + 1) {
            System.out.print("\nfor f = " + f);
            inner: // No puede haber sentencias, después de esta instrucción
            //           
            for (; i <= 10; i = i + 1) {
                System.out.print("\nfor i = " + i);
                if (i == 2) {
                    System.out.print(" =[continue next iteration]");
                    continue; // 
                }
 
                if (i == 3) {
                    System.out.print(" =[continue next iteration]");
                    continue inner; // innecesaria etiqueta, se puede reemplazar solo por break
                }
 
                if (i == 4) {
                    System.out.print(" =[continue to outer, break loop i]");
                    i = i + 1; // contador incrementado manualmente
                    continue outer;
                }
 
                if (i == 5) {
                    System.out.print(" =[break loop i]");
                    i = i + 1; // contador incrementado manualmente
                    break;
                }
 
                if (i == 8) {
                    System.out.print(" =[break outer, break loop i]");
                    i = i + 1; // contador incrementado manualmente
                    break inner; // innecesaria etiqueta, se puede reemplazar solo por break
                }
 
                if (i == 9) {
                    System.out.print(" break outer, break all loops i, f");
                    break outer;
                }
 
                if (i == 10) {
                    System.out.print(" nunca se ejecuta");
                }
 
                System.out.print("\nfor k = ");
                for (; k < 4; k = k + 1) {
 
                    if ((k % 2) == 0) { // es par
                        System.out.print("" + k + " =[continue to inner, break loop k]");
                        k = k + 1; // contador incrementado manualmente
                        continue inner;
                    } else {
                        System.out.print(k + ", ");
                    }
 
                }//next for k
                System.out.print("bucle i sin salto i=" + i);
 
            }//next for i
 
        }//next for f
 
        System.out.println("\nfin ");
    }//main
}

salida

Código: [Seleccionar]

for f = 1
for i = 1
for k = 0 =[continue to inner, break loop k]
for i = 2 =[continue next iteration]
for i = 3 =[continue next iteration]
for i = 4 =[continue to outer, break loop i]
for f = 2
for i = 5 =[break loop i]
for f = 3
for i = 6
for k = 1, 2 =[continue to inner, break loop k]
for i = 7
for k = 3, bucle i sin salto i=7
for i = 8 =[break outer, break loop i]
for f = 4
for i = 9 break outer, break all loops i, f
fin

El reto es codificar el código anterior sin BREAK, y CONTINUE, intentando ...
Próximamente ejemplos con TRY CATH THROW FINALLY

TODOPIC

Lenguajes de programación para PC => C, C#, C++ => Mensaje iniciado por: CompSystems en 31 de Enero de 2016, 11:06:48