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