domingo, 16 de octubre de 2011

CRIBA DE ERATOSTENES

La criba de Eratóstenes es un algoritmo que permite hallar todos los números primos menores que un número natural dado N. Se forma una tabla con todos los números naturales comprendidos entre 2 y N y se van tachando los números que no son primos de la siguiente manera: Cuando se encuentra un número entero que no ha sido tachado, ese número es declarado primo, y se procede a tachar todos sus múltiplos. El proceso termina cuando el cuadrado del mayor número confirmado como primo es mayor que N.


Fuente: http://es.wikipedia.org/wiki/Criba_de_Erat%C3%B3stenes
Share:

INICIALIZAR MATRIZ EN LA DECLARACION (JAVA)

Inicializar matriz en la declaración


En Java es posible inicializar una matriz al declararla, tal y como sucede con los arreglos; esto se hace sin definir el número de renglones y columnas, colocando un operador de asignación y después entre llaves la lista de valores para cada renglón del arreglo, el arreglo separando con llaves para cada valor por columna, separado por comas, veamos los siguientes ejemplos:


double arreglo[][] = { {3.5, 5.4, -2.3 }, {22.3, 78.5, -9.4}};
char cadena[][] = {{‘a’, ‘g’, ‘u’, ‘a’}, {‘r’, ‘o’, ‘j’, ‘a’}} ;


En Java es posible saber el número de renglones de una matriz, solo escribiendo el nombre de la matriz un punto y la palabra length, también se puede saber el número de elementos de un renglón, dando el nombre del arreglo , el renglón entre corchetes y un punto y la palabra length, como se muestra en el siguiente ejemplo:



public class AplicacionMatrices2 {
    
    public static void main(String[] args) {
        int arreglo[][] = {{1,2,3}, {4,5,6}, {7,8,9}};
        
        for (int i=0; i<arreglo.length; i++) {
        for (int j=0; j<arreglo[0].length; j++) {
            System.out.print(" " + arreglo[i][j]  + " ");
        }
        System.out.println();
        }
    }
 }

El cual al ejecutar mostrará lo siguiente:
Es importante observar como se escriben los renglones por columna, recordando que se utiliza el print() para desplegar el valor, esto permitirá no cambiar de renglón, pero tampoco saldrá a la pantalla hasta encontrar un println(), el cual se hace después del ciclo de adentro que despliega todos los renglones de una columna.
Share:

domingo, 9 de octubre de 2011

ARREGLOS DE DOS DIMENSIONES I (JAVA)

¿Que es un arreglo de dos dimensiones?


Un arreglo de dos dimensiones es una colección de datos para una misma variable en dos dimensiones comúnmente llamados renglones y columnas.
Arreglo

12 -4 0 28 -3
-3 -5 2 189 -2
1 0 9 -4 12
Para poder guardar un valor u obtener alguno del arreglo de dos dimensiones (también llamado matriz) es ahora necesario utilizar dos dimensiones, el renglón y la columna.


Declaración de arreglos de dos dimensiones


Para declarar un arreglo de dos dimensiones se utiliza el siguiente formato:

tipo nombre_arreglo [][] = new tipo[ numero renglones][ numero columnas];

Donde tipo es el tipo de los datos que almacenará el arreglo de dos dimensiones. Es importante recordar que se pueden declarar arreglos de los tipos primitivos de Java (int, double, char, etc) o bien de tipos definidos por el usuario (Cuenta, Alumno, etc).

Tamaño representa la cantidad de casillas que se reservan para el arreglo. En Java todos los arreglos empiezan en el subíndice 0 y llegan al subíndice tamaño-1.


Por ejemplo:
int arr[][] = new int[5] [6]; // arreglo de 5 renglones y 6 columnas enteros
char cad[][] = new char[10] [5]; /* arreglo de 10 renglones por 5 columnas tipo                                                                               carácter*/


Uso e inicialización de los elementos del arreglo de dos dimensiones


Para usar los elementos individuales de un arreglo se usa el siguiente formato:

arreglo[subíndice-renglon] [subíndice-columna]

Como un elemento de un arreglo de dos dimensiones es también un dato, se puede usar como cualquier variable de ese tipo, debemos recordar que tanto el índice de renglón como el índice de columna toman como base el primer elemento cero:

int arr[][] = new int [2][5];
arr[3][4] = 12;
arr[1][0]= Integer.parseInt(t1.getText());
t2.setText("" + arr[0][1]);
arr[0][0] = arr[0][1] + arr[0][2];
int k = 2;


int l = 3
arr[k+1][l] = 20;


Ejemplo:
En este siguiente ejemplo, tenemos una aplicación que define un arreglo de enteros de dos dimensiones, con 3 renglones y 5 columnas, y los inicializa con el valor de 1 a 15, de acuerdo a cada renglón, empezando por 1 en el renglón 1, luego por 6 en el renglón 2 y 11 en el renglón 3. Después de inicializar la matriz, la despliega, desplegando los valores de un mismo renglón en la misma línea, como lo muestra la figura:
(/En construcción)

La aplicación es como se muestra a continuación:

 
public class AplicacionMatrices1 {
    
    public static void main(String[] args) {
        int arreglo[][] = new int [3][5];
        
        for (int i=0; i<3; i++) {
            for (int j=0; j<5; j++) {
                        arreglo [i][j] = i*5+j+1;                            
            }
        }
        
        for (int i=0; i<3; i++) {
            for (int j=0; j<5; j++) {
                        System.out.print(" " + arreglo[i][j]  + " ");
            }
            System.out.println();
        }
    }
 }
Share:

sábado, 1 de octubre de 2011

PALINDROMO EJERCICIO_1 (C++)

Bueno compañeros. Acá les dejo un algoritmo con su respectiva documentación que nos dice si un número es palindromo o no.


#include <iostream>
#include <conio.h>
#include <Math.h>
using namespace::std;
int num,cnum1,cnum2,i=0,j=1,k,cifraa,cifrab;
bool sw=true;
//ALGORITMO QUE DICE SI UN NUMERO ES PALINDROMO O NO
void main(){
//Se lee el numero
cout<<"Digite un numero entero: ";
cin>>num;
//Se saca el valor absoluto del numero ya que el signo es despreciable
cnum1=abs(num);
//Se saca el numero de cifras del numero
        while(cnum1>0){
                i++;
                cnum1=cnum1/10;
        }
//Volvemos a asignar la copia al numero original ya que se ha modificado debido al calculo de las cifras
cnum1=num;
//Comparamos hasta la mitad del numero y mientras que las cifras a comparar sean iguales
        while(j<=i/2 && sw==true){
                cnum2=num;
//Se saca la cifra mas a la derecha
                cifraa=cnum1%10;
//Un contador k para sacar la cifra mas a la izquierda
                 k=0;
//La formula i-j nos dice hasta donde se debe seguir reduciendo el numero para sacar la cifra mas a la izquierda
                         while(k<=i-j){
                                 cifrab=cnum2%10;
                                 cnum2=cnum2/10;
                                 k++;
                         }
//Ya teniendo las cifras, se comparan. Si son diferentes se cambia el switch a falso
                         if(cifraa!=cifrab){
                                 sw=false;
                         }
                cnum1=cnum1/10;
                j++;
        }
/*Si el switch es verdadero es porque el numero es palindromo o capicúa
Si es falso es porque no es palindromo o capicúa*/
        if (sw==true){
                cout<<"El numero "<<num<<" es palindromo.";
        }
        else{
                cout<<"El numero "<<num<<" no es palindromo.";
        }
    _getch();
}
Share:

APLICACIONES CON ARREGLOS (JAVA)

Supongamos que queremos utilizar una aplicación para poder tomar un arreglo y voltearlo en otro, es decir, supongamos que tenemos un arreglo con los números 1, 15, 17, 22 y 34 y los queremos cambiar al revés como 34, 22, 17, 15 y 1. La siguiente aplicación nos puede ayudar a comprender esto:


public class AplicacionArreglo3 {
public static void main(String[] args) {
int arreglo1[] = { 1, 15, 17, 22, 34 };
int arreglo2[] = new int[arreglo1.length];
for (int i = 0; i < arreglo1.length; i++) {
        arreglo2[arreglo1.length - i - 1] = arreglo1 [i];
}
System.out.println("Arreglo Inicial");
for (int i = 0; i < arreglo1.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo1[i]);
}
System.out.println("Arreglo Final");
for (int i = 0; i < arreglo2.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo2[i]);
}
}
}
Dicha aplicación muestra la siguiente salida:


Vemos como la clave de la asignación de cada elemento del arreglo 2 esta en hacer un poco de matemáticas, con la instrucción:
arreglo2[arreglo1.length - i - 1] = arreglo1 [i];

En esta instrucción al último índice de la posición le quitamos el valor de i que es nuestra variable índice que avanza hasta llegar al último, pero si hacemos un poco de sustitución y decimos arreglo1 tiene 5 elementos, cuando la i es cero, entonces arreglo.length – i – 1 nos da 4 que es realmente la última posición, ya que iría de 0 a 4. Si sustituimos ahora con i en 1, tendríamos 5 – 1 – 1 que sería 3 y así sucesivamente.



Contando las veces que se repite un número en un arreglo
Esto nos puede servir para cuando trabajamos con números, supongamos que tenemos la siguiente aplicación, en la cual tenemos un arreglo y buscamos dos números en el, tenemos que utilizar un ciclo para la búsqueda y si queremos contar las veces que se encuentra el número podemos utilizar un contador para cada uno, veamos la aplicación:


public class AplicacionArreglo4 {


public static void main(String[] args) {
int arreglo[] = { 1, 15, 17, 22, 34 , -5, 15, 22, 1};


int busca1 = 30; // numero 1 a buscar
int conta1 = 0; // contar cuantas veces aparece
int busca2 = 22; // numero 2 a buscar
int conta2 = 0; // contar cuantas veces aparece
for (int i = 0; i < arreglo.length; i++) {
if (busca1 == arreglo[i]) {
        conta1++;
}
if (busca2 == arreglo[i]) {
        conta2++;
}
}
System.out.println("Arreglo");
for (int i = 0; i < arreglo.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo[i]);
}
System.out.println("El numero " + busca1 + " aparece " + conta1 + " veces");
System.out.println("El numero " + busca2 + " aparece " + conta2 + " veces");
}
}


Dicha aplicación muestra el siguiente desplegado:


Observamos que el conta1 solo se incrementa si el valor buscado busca1 aparece en el arreglo, de la misma manera con el valor busca2, se utiliza conta2.

Juguemos ahora un poco con letras utilizando arreglos de caracteres, cambiando la aplicación quedaría como:


public class AplicacionArreglo5 {


public static void main(String[] args) {
char arreglo[] = { 'a', 't', 'e', 'n', 'i' , 'd', 'a', 's'};


char busca1 = 's'; // caracter 1 a buscar
int conta1 = 0; // contar cuantas veces aparece
char busca2 = 'a'; // caracter 2 a buscar
int conta2 = 0; // contar cuantas veces aparece
for (int i = 0; i < arreglo.length; i++) {
if (busca1 == arreglo[i]) {
        conta1++;
}
if (busca2 == arreglo[i]) {
        conta2++;
}
}
System.out.println("Arreglo");
for (int i = 0; i < arreglo.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo[i]);
}
System.out.println("El caracter " + busca1 + " aparece " + conta1 + " veces");
System.out.println("El caracter " + busca2 + " aparece " + conta2 + " veces");
}
}


Esta aplicación mostraría el siguiente desplegado:


Observamos entonces como un arreglo de caracteres puede ser manejado como un arreglo de números.

Utilizando los caracteres y usando el ejemplo de invertir los números de un arreglo a otro, podemos observar como se puede invertir un arreglo de caracteres en otro, veamos la siguiente aplicación:


public class AplicacionArreglo6 {


public static void main(String[] args) {
char arreglo1[] = { 'a', 't', 'e', 'n', 'i' , 'd', 'a', 's'};
char arreglo2[] = new char[arreglo1.length];


for (int i = 0; i < arreglo1.length; i++) {
        arreglo2[arreglo1.length - i - 1] = arreglo1 [i];
}
System.out.println("Palabra Inicial");
for (int i = 0; i < arreglo1.length; i++) {
        System.out.println("Caracter " + (i+1) + " = " + arreglo1[i]);
}
System.out.println();
System.out.println("Palabra Final");
for (int i = 0; i < arreglo2.length; i++) {
        System.out.println("Caracter " + (i+1) + " = " + arreglo2[i]);
}
}
}


Observando el desplegado de esta aplicación quedaría:

Share:

viernes, 23 de septiembre de 2011

OPERACIONES CON ARREGLOS DE UNA DIMENSION (JAVA)



Utilizar un arreglo para hacer operaciones con el, en la mayoría de las veces implica el uso de la instrucción for, pues para poder tomar o actualizar cada elemento del arreglo, es necesario utilizar índice, y es por esto que el for es la instrucción ideal.


Por ejemplo, como se vio en arreglos de una dimensión, para inicializar un arreglo ya una vez definido podemos utilizar:

int arreglo[] = new int [10];
     for (int i=0; i<10; i++) {
          arreglo [i] = i;
     }


Pero también podemos utilizar la variable length, la cual es definida para todo arreglo en Java, y esta representa el número máximo de posiciones en el arreglo, es decir para el ejemplo anterior quedaría como:

int arreglo[] = new int [10];
     for (int i=0; i < arreglo.length; i++) { 
          arreglo [i] = i; 
     } 


Al hacer operaciones con arreglos es muy común que utilicemos también una constante para definir el máximo valor a utilizar en el arreglo, es decir para el ejemplo anterior quedaría como: 

int final MAX = 10; 
int arreglo[] = new int [MAX]; 
     for (int i=0; i < MAX; i++) { 
          arreglo [i] = i; 
     } 


Donde MAX es una constante (definida así al usar la cláusula final) que valdrá 10 durante la ejecución del método, clase o parte donde se encuentre definida. 


Sacando el mayor de un arreglo 
Cuando deseamos obtener el valor mayor de todos los valores definidos en un arreglo, debemos recorrer todo el arreglo y utilizar una variable que nos ayude en esta comparación. La mejor manera de inicializar esta variable es utilizar el primer valor del arreglo, por ejemplo: 


int mayor = arreglo[0]; // se toma el primer valor como el mayor 
// se revisa cada elemento en el arreglo empezando por el segundo 
     for (int i=1; i < arreglo.length; i++) { 
          // si el elemento del arreglo es mayor 
          if (arreglo[i] > mayor) {
               mayor = arreglo[i]; // cambiamos el valor del mayor
          }
     }
     System.out.println(“El valor mayor es “ + mayor);


Tomando el índice en el que se encuentra
Para hacer esto definimos otra variable, la cual debe empezar con 1 y si el valor del arreglo es mayor, además de hacer el cambio de mayor, actualizamos la posición de donde se encontró el mayor, el ejemplo quedaría como:


int posición = 0;
int mayor = arreglo[0]; // se toma el primer valor como el mayor
// se revisa cada elemento en el arreglo desde el segundo
     for (int i=1; i < arreglo.length; i++) { 
          // si el elemento del arreglo es mayor 
          if (arreglo[i] > mayor) {
               mayor = arreglo[i]; // cambiamos el valor del mayor
               posicion = i; // se actualiza la posicion
          }
     }
     System.out.println(“El valor mayor es “ + mayor);
     System.out.println(“Y esta en la posicion “ + (posición+1));


Si queremos saber en que posición se encontró el mayor valor, entonces debemos utilizar un índice, el cual empieza en 0 (si es que tomamos como referencia inicial el primer valor) y después al detectar que el valor del arreglo es mayor, se hace el cambio con mayor y se actualiza la posición, al desplegar la posición le añadimos uno mas, ya que empieza desde cero.


Sacando el menor de un arreglo y su posición
Para obtener el valor menor, solo se cambia la comparación y en lugar de comparar contra mayor, solo se compara contra menor, el ejemplo lo vemos como sigue:


int posición = 0;
int menor = arreglo[0]; // se toma el primer valor como el menor
// se revisa cada elemento en el arreglo desde el segundo
     for (int i=1; i < arreglo.length; i++) {
          // si el elemento del arreglo es menor
          if (arreglo[i] < menor) {
               menor = arreglo[i]; // cambiamos el valor del menor
               posicion = i; // se actualiza la posicion
          }
     }
     System.out.println(“El valor menor es “ + menor);
     System.out.println(“Y esta en la posicion “ + posicion);


Obteniendo el promedio del arreglo
Para obtener el promedio de un arreglo, se debe de sumar los elementos y dividir entre cuantos sean, el ejemplo lo vemos como sigue:

double promedio;
double suma = 0; // se inicializa la suma en cero
// se tomara cada elemento para sumarlo
     for (int i=0; i < arreglo.length; i++) {
          suma += arreglo[i];
     }
     promedio = suma / arreglo.length;
     System.out.println(“El promedio es “ + promedio);
Share:

domingo, 18 de septiembre de 2011

EJEMPLO_1 ARREGLOS (APPLET JAVA)

Es muy sencillo tomar datos y agregarlos a un arreglo, como lo puede mostrar la siguiente aplicación, este applet, tomará un dato de texto y lo añadirá en un arreglo de números, además desplegará lo que tiene el arreglo en memoria, para ser desplegado en el texto de área.

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
 
// <applet width="400" height="200" code="AppletArreglos1"></applet>
 
public class AppletArreglos1 extends Applet implements ActionListener{
 
                Label l1, l2;
                Button b1, b2,b3,b4;     
                TextField t1;
                TextArea ta1;
                int arreglo[];
                int conta;
 
             public AppletArreglos1() {
                                     l1 = new Label("Dato a Añadir");
                                     l2 = new Label("Texto para ver Arreglo");
                                     t1 = new TextField();
                                     ta1 = new TextArea(10,12);
                                     b1 = new Button("Añade");
                                     b2 = new Button("Muestra Vector");
                                     b3 = new Button("Limpia Vector");
                                     b4 = new Button("Limpia Campos");
                                     add(l1);
                                     add(t1);
                                     add(l2);
                                     add(ta1);
                                     add(b1);
                                     add(b2);
                                    add(b3);
                                     add(b4);
                                     b1.addActionListener(this);
                                     b2.addActionListener(this);
                                     b3.addActionListener(this);
                                     b4.addActionListener(this);
                                     arreglo = new int[100];
                                     conta=0;
                }
                 
                public void actionPerformed(ActionEvent ae) {
                    if (ae.getSource() == b1) {
                        if (conta > arreglo.length) {
                            ta1.setText("No se puede añadir otro elemento");
                        }
                        else {
                            arreglo[conta++] = Integer.parseInt(t1.getText());
                            t1.setText("");   
                        }
                     }
                     if (ae.getSource() == b2) {
                           ta1.setText("");
                           for (int i=0; i < conta; i++) {
                               ta1.append("" + arreglo[i] + "\n");
                           }
                     }
                     if (ae.getSource() == b3) {
                           conta = 0;
                           arreglo = new int[100];
                     }
                     if (ae.getSource() == b4) {
                           t1.setText("");
                           ta1.setText("");
                     }
                }
}


La cual se visualiza asi:























De la aplicación anterior podemos se observar que aunque length es el número de elementos en el arreglo, solo se utiliza conta en el ciclo para desplegar, ya que esta variable nos dice cuantos elementos se han introducido al arreglo.
Share:

¿QUE SON LOS APPLETS?

Un applet es un componente de una aplicación que se ejecuta en el contexto de otro programa, por ejemplo un navegador web. El applet debe ejecutarse en un contenedor, que lo proporciona un programa anfitrión, mediante un plugin, o en aplicaciones como teléfonos móviles que soportan el modelo de programación por 'applets'.

A diferencia de un programa, un applet no puede ejecutarse de manera independiente, ofrece información gráfica y a veces interactúa con el usuario, típicamente carece de sesión y tiene privilegios de seguridad restringidos. Un applet normalmente lleva a cabo una función muy específica que carece de uso independiente. El término fue introducido en AppleScript en 1993.

Ejemplos comunes de applets son las Java applets y las animaciones Flash. Un Java applet es un código JAVA que carece de un método main, por eso se utiliza principalmente para el trabajo de páginas web, ya que es un programa pequeño que es utilizado en una página HTML y representado por una pequeña pantalla gráfica dentro de ésta.

Por otra parte, la diferencia entre una aplicación JAVA y un applet radica en cómo se ejecutan. Para cargar una aplicación JAVA se utiliza el intérprete de JAVA. En cambio, un applet se puede cargar y ejecutar desde cualquier explorador que soporte JAVA (Netscape, Mozilla Firefox, Google Chrome.).

Share:

MAL USO DE LOS INDICES EN ARREGLOS (JAVA)

Usando mal los Índices 
Cuando un subíndice esta mal empleado, haciendo referencia a un elemento en el arreglo que no existe, Java arroja un error de ejecución llamado de excepción, el cual es ArrayIndexOutOfBoundsException, debemos tener cuidado en esto, pues la aplicación se cancela y no continua, como se muestra en la siguiente aplicación:

public class AplicacionArreglo4 { 
    public static void main(String[] args) { 
        int arreglo[] = {1,2,3};  
           for (int i=0; i<arreglo.length+1; i++) {
                System.out.println("Elemento [" + i + "] = " + arreglo[i]);
         }
     }
 } 

La ejecución que muestra la aplicación es:

 
Podemos observar como la aplicación alcanza a mostrar el último valor posible, pero cuando hace referencia al elemento 3 (ya que en la aplicación la condición es i < arreglo.length + 1) se sale del rango y arroja la excepción.

Share:

domingo, 11 de septiembre de 2011

ARREGLOS DE UNA DIMENSION

¿Qué es un arreglo?
Un arreglo es un tipo de dato estructurado que permite guardar colecciones de elementos del mismo tipo.

Arreglo
12 -4 0 28 -3

Esto representa un lugar en memoria en el que se pueden guardar más de un valor en una misma variable, solo utilizando el índice en el que se encuentra el valor deseado.


Declaración de arreglos 
Para declarar un arreglo se utiliza el siguiente formato: 

         tipo nombre_arreglo [] = new tipo[tamaño];

Donde tipo es el tipo de los datos que almacenará el arreglo. Es importante mencionar que se pueden declarar arreglos de los tipos primitivos de Java (int, double, char, etc) o bien de tipos definidos por el usuario (Persona, Estudiante, etc).

Tamaño representa la cantidad de casillas que se reservan para el arreglo. En Java todos los arreglos empiezan en el subíndice 0 y llegan al subíndice tamaño-1.
Por ejemplo: 

         int arr[] = new int[6];   // arreglo de 6 elementos enteros
         char cad[] = new char[10]; // arreglo de 10 elementos de tipo carácter

En los ejemplos anteriores, arr es un arreglo entero de 6 elementos, cuyo índice inicial es cero y el último es 5, cad es un arreglo de caracteres, que contiene 10 diferentes caracteres, desde el cero hasta el 9.

 
Uso de los elementos del arreglo 
Para usar los elementos individuales de un arreglo se usa el siguiente formato: 

arreglo[subíndice]

Como un elemento de un arreglo es un dato, se puede usar como cualquier variable de ese tipo; Enseguida se pueden ver algunos ejemplos:
 
int arr[] = new int [4];
arr[3] = 8;
arr[2]= Integer.parseInt(t1.getText());
t2.setText("" + arr[3]);
arr[0] = arr[1] + arr[2];
int k = 2;
arr[k+1] = 20; 



Ejemplo:
En este siguiente ejemplo, tenemos una aplicación que define un arreglo de 10 enteros y los inicializa con el valor de 0 a 9 correspondientemente el valor de cada índice, es decir que el elemento cero tiene un cero, el elemento 1, tiene 1, y así sucesivamente hasta 9. Finalmente se despliegan los valores.
 
 
public class AplicacionArreglo {
    
    public static void main(String[] args) {
        int arreglo[] = new int [10];
        
        for (int i=0; i<10; i++) {
           arreglo [i] = i;
        }
        
        for (int i=0; i<10; i++) {
           System.out.println("Elemento [" + i + "] = " + arreglo[i]);
        }
    }
 }
 
Esta aplicación provocará la siguiente ejecución:
 




Inicializar arreglos en la declaración 
En Java es posible inicializar un arreglo al declararlo; esto se hace sin definir el número de elementos y colocando un operador de asignación y después entre llaves la lista de valores para el arreglo separados por comas, veamos los siguientes ejemplos:

double arreglo[] = { 23.5, 54.22, 78};
char cadena[] = {‘a’, ‘b’, ‘c’, ‘d’}; 

En Java es posible saber el número de elementos del arreglo utilizando el nombre del arreglo un punto y la palabra length, como se muestra en el siguiente ejemplo:



public class AplicacionArreglo1 {
    
    public static void main(String[] args) {
        int arreglo[] = {1,2,3};
                
        for (int i=0; i<arreglo.length; i++) {
           System.out.println("Elemento [" + i + "] = " + arreglo[i]);
        }
    }
}
El cual al ejecutar mostrará lo siguiente:


Share:

Ipod


BTemplates.com