Encuentra los temas que te intereza

domingo, 23 de octubre de 2016

TRABAJO GRUPAL

ORDENAMIENTO Y BÚSQUEDA


El día de hoy explicaremos como funciona el método de ordenamiento QuickSort, conocido por ser el más rápido y por ello eficiente ya que reduce recurso y sobre todo optimiza nuestro código. Y también explicaremos la Búsqueda Binaria, donde esta búsqueda es mucho más eficiente que otras; Y ese es el propósito de nuestro blogger. "OPTIMIZAR".

Ordenamiento Rápido (QuickSort):


Este algoritmo fue propuesto por Charles Antony Richard Hoare en 1960. En este método se recalca esta frase "Divide y vencerás"; ya que dicho método consiste en esto, ya que divide a nuestro arreglo en sub-arreglos y aplica este mismo método en los sub-arreglos. A esto se le llama recursividad y nuestro ordenamiento rápido funciona por ello.

A continuación el método de Ordenamiento QuickSort:
public class Metodos {
     
      public int[] quicksort2(int numeros[], int izq, int dere) {
        if (izq>=dere) 
            return numeros;
        int i=izq,d=dere;
        if (izq !=dere) {
            int pivote;
            int aux;
            pivote=dere;
            while (izq!= dere) {
                while (numeros[pivote] > =numeros[izq] && izq < dere) 
                    izq++;   
                  while (numeros[pivote] < numeros[der] && izq < dere) {
                        dere--; }  
                
                if(dere!=izq){
                
                    aux=numeros[dere];
                    numeros[dere]=numeros[izq];
                    numeros[izq]=aux;}
            }
            if (izq==dere) {
                quicksort2(numeros, i, izq-1);
                quicksort2(numeros, izq+1, d);
            }
            
        }else
            return numeros;
             
        return numeros;
    }
}

Búsqueda Binaria:


Cabe mencionar que, el método funciona si el vector esta ordenado; con cualquier método de ordenamiento. Con este método se examina primero el elemento medio del arreglo; si este es el elemento buscado entonces la búsqueda ha terminado. En caso contrario se determina si el elemento buscado está en la primera o segunda mitad del arreglo y a continuación se repite el proceso anterior, utilizando el elemento medio del arreglo de esta sublista.

A continuación el método de Búsqueda Binaria:

public class Metodos {
     
    public int busquedbinaria(int array[],int cantidad, int num) {
        int tam = cantidad;
        int min = 0, med = 0, max = tam;
        while (min <= max) {
            med = (min + max) / 2;
            if (num == array[med]) {
                System.out.println("ES CIERTO SALE DEL BUCLE ");
                break;
            }
            if (num < array[med]) {
                max = med;
            } else {
                min = med;
              }
        }
        return med;
    } 
}

Estos métodos lo implementamos en una Interface, para una mejor visualización y comprensión de los métodos. Ademas de ello los datos guardados se guardan en un Archivo txt. 
El programa lo dejare en el link de descarga para que puedan estudiarlo.




Link de Descarga:    AQUI !!!

sábado, 22 de octubre de 2016

Examen Parcial

ARREGLOS INTERFACES Y ARCHIVOS


La funcionalidad del Programa es que agrega aleatoriamente números enteros en la array. si el numero aleatorio es Impar lo agrega por pila y si el numero es Par lo agrega por cola. Donde aquí vemos como funcionan los métodos de Pilas y colas.

También Podemos sacar del arreglo los números múltiplos de dos.
Ademas de ello. El botón eliminar aleatorio, elimina un numero alzar del vector ya sea por pila o por cola.

Un botón ordenar, que me ordena el arreglo de forma descendente.
Y por ultimo un botón que realizara el conteo de la cantidad de los números pares que tiene mi arreglo.

Cabe mencionar que se implementaron los métodos en una interfaz, y ademas de ello estos datos generados se  guardaban en un archivo: llamado: D:/aleatorio.txt  que tenia la dirección del disco D.



Link de Descarga:      AQUI !!

lunes, 10 de octubre de 2016

PILAS Y COLAS

¿Que son Pilas y Colas?

Las pilas y colas son estructuras de datos que se utilizan generalmente para simplificar ciertas operaciones de programación. Estas estructuras pueden implementarse mediante arrays o mediante listas enlazadas; en estos ejemplos solo trabajaremos con arrays.


Pilas: 

Las pilas son estructuras de datos que tienes dos operaciones básicas: push (para insertar un elemento) y pop (para extraer un elemento). Su característica fundamental es que al extraer se obtiene siempre el último elemento que acaba de insertarse.

Las pilas se utilizan en muchas aplicaciones que utilizamos con frecuencia. Por ejemplo, la gestión de ventanas en Windows (cuando cerramos una ventana siempre recuperamos la que teníamos detrás). 

Colas: 


Las colas también son FIFO (First In First Out), que quiere decir “el primero que entra es el primero que sale”.

Se inserta por un sitio y se saca por otro, en el caso de la cola simple se inserta por el final y se saca por el principio. Para gestionar este tipo de cola hay que recordar siempre cual es el siguiente elemento que se va a leer y cual es el último elemento que se ha introducido.

Ejemplo Practico:

A continuación realizaremos un Array donde podamos agregar por pila y por cola números enteros.  Y de igual forma implementaremos los métodos de eliminar por pila y por cola.

Para ello Utilizaremos Interfaces donde implementaremos los botones de agregar por pila y por cola; y a su vez eliminar. Ademas de ello los datos agregados y eliminados se guardaran en un archivo llamado D:/PilasColas.txt; localizado en nuestro disco D.

INTERFACE:


Link de Descarga:     Programa Completo

miércoles, 5 de octubre de 2016

Archivos

ARCHIVOS JAVA(FICHEROS)

un fichero es un registro o una base de datos donde se almacenan los datos de tipo String 
al momento de ser creados estos pueden estar llevadas hasta la dirección que tu le das mediante el código.


Mediante esta clase llamada fichero útil nosotros podemos llamarla y poder guardar nuestro array de objetos y poder leerlo desde un archivo guardado.


import java.io.*;
import java.util.StringTokenizer;


public class ficheroUtil {
 
    public static final String direccionFicheroRegistro= "D:/alumno/registro.txt";
    public static final String direccionFicheroRegistroEliminado= "D:/alumno/registroEliminado.txt";
 
    private static int codigoNew;
 
    private static boolean existeDato = false;
    File fichero;
    public void CrearArchivo(String direccion){
        try {
            fichero = new File(direccion);
            if(!fichero.exists()){
                fichero.createNewFile();
            }
         
        } catch (Exception e) {
            System.out.println("problemas");
        }
    }
    public void agregarDatos(String Datos[],int cont,String direccion){
        try {
            CrearArchivo(direccion);
            FileWriter fw = new FileWriter(fichero);
            BufferedWriter bw = new BufferedWriter(fw);
            for (int i = 0; i <= cont; i++) {
                bw.write(Datos[i]);
                bw.newLine();
            }
            System.out.println("datos agregados");
            bw.close();
        } catch (Exception e) {
            System.out.println("problemas");
        }
    }
    public void LeerArchivoAlumno(alumno est[],String direccion){
        int i = 0;
        try{
            CrearArchivo(direccion);
            FileReader fr = new FileReader(fichero);
         
            BufferedReader br = new BufferedReader(fr);
            String cadena;
            while((cadena = br.readLine())!=null){
StringTokenizer st = new StringTokenizer (cadena,",");
                System.out.println(cadena);
                est[i] = new alumno();
                est[i].setNombre(st.nextToken());
                est[i].setCodigo(Integer.parseInt(st.nextToken()));
                est[i].setEdad(Integer.parseInt(st.nextToken()));
                est[i].setFacultad(st.nextToken());
                i++;
                this.setCodigoNew(est[i-1].getCodigo()+1);
             
                this.setExisteDato(true);
            }
            System.out.println("EL CODIGO NUEVO ES : "+i);
            br.close();
        }catch(FileNotFoundException e){
e.printStackTrace();
        }catch (IOException e) {
e.printStackTrace();
}
 
    }

sábado, 1 de octubre de 2016

Interfaces (GUI)

INTERFACES (GUI)


Interfaz Gráfica de Usuario: es un conjunto de componentes gráficos que permite la interacción usuario y la aplicación mediante ventanas (botones, listas, lista de diálogos, campos de textos).
La API de java nos proporciona Bibliotecas de clases para el desarrollo de interfaces gráficas de usuario.

Java provee dos API's con las que podemos trabajar para desarrollar GUIs, la más básica es AWT (Abstrct Window Toolkit). Las más desarrolladas se hacen con Swing, las cuales son más identificables ya que todas comienzan con "J", por ejemplo: JLabel, JButton, JTextField, JTextArea, JPanel y JFrame son clases de Swing.
Todo el manejo de eventos y layouts es exactamente el mismo para AWT y Swing.

La manera de importar los paquetes (AWT-swing) es de la siguiente manera:

import java.awt.*;
import javax.swing.*;

A continuación veremos los componentes JLabel, JTextField y JButton; que podemos utilizarlos al importar el paquete javax.swing.*;

Objeto de control JLabel Un objeto de control JLabel permite dibujar en el formulario una etiqueta, entendiéndose como etiqueta una expresión estática que se quiere colocar. También es usado para mostrar los resultados de un proceso.

Objeto de control JTextField Un objeto de control JTextField permite dibujar en el formulario un cuadro de texto, es decir, una caja que permite la introducción de un dato o valor. Este objeto es utilizado para el ingreso de datos

Objeto de control JButton Un objeto de control JButton permite dibujar en el formulario un objeto que contiene un proceso a ejecutar. Se utiliza comúnmente para llevar a cabo procesos específicos según la naturaleza de la aplicación.

Ahora mostraremos como crear una pequeña ventana y ademas incluiremos un JLabel que mostrará el siguiente mensaje: "Hola mundo" . Comencemos:


import java.awt.FlowLayout;
import javax.swing.*;

public class ventana extends JFrame{
   
    private JLabel label;//Defino mi JLabel
    
    public ventana(){
        
        super("Mi Primera GUI");//Costructor del Padre recibe el titulo de la VENTANA 
        setLayout(new FlowLayout()); //Defino el Layout que va tener la ventana
        setSize(300, 100);// Damos el tamaño o dimensiones que va tener la VENTANA
        setLocationRelativeTo(this);//Centramos la VENTANA 
        setDefaultCloseOperation(EXIT_ON_CLOSE);//Para cerrar el programa
        label = new JLabel("Hola Mundo");//Instanciamos el JLabel y le damos nombre
        add(label);//Agregamos el Jlabel al Contenedor
        setVisible(true);//Hacemos visible la VENTANA
    }
    
    public static void main(String[] args) {
        ventana v = new ventana();//Instanciamos la clase ventana
    }
}

Ya creamos nuestra primera GUI. Ahora haremos un programa mas complejo donde interactúen los tres componentes estudiados: JLabel, JTextField y JButton.


Para ello debemos saber acerca de los eventos, cuando presionamos el mouse en el JButton o si damos "enter" en el JTextField este realiza una acción a esto se le denomina (ActionEvent).

Crearemos un manejador de oyente . Para ello definimos la clase específica que haga de oyente de eventos y que implemente el método actionperformed(). 

Para comprender mejor, haremos un pequeño ejemplo de como implementar el método al hacer "click" en un botón. 


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MiOyente extends JFrame implements ActionListener{
    //Aplicamos herencia e implementamos una Interfaz ActionListener
    //En el cual nos obliga a implementar el metodo actionPerformed()
    private JButton boton;//Defino mi JButton
    
    public MiOyente(){
        //--->ESTO YA LO VIMOS
        //--->CON ESTO CREAMOS NUESTRO VENTANA CON UN BOTON
        
        super("Manejo de Evento");//Costructor del Padre recibe el titulo de la VENTANA 
        setLayout(new FlowLayout()); //Defino el Layout que va tener la ventana
        setSize(300, 100);// Damos el tamaño o dimensiones que va tener la VENTANA
        setLocationRelativeTo(this);//Centramos la VENTANA 
        setDefaultCloseOperation(EXIT_ON_CLOSE);//Para cerrar el programa
        boton = new JButton("BOTON");//Instanciamos el JButton y le damos nombre
        add(boton);//Agregamos el Jlabel al Contenedor
        setVisible(true);//Hacemos visible la VENTANA
        
        //-->AHORA HAREMOS QUE EL BOTON DE UNA ACION AL OYENTE
        
        boton.addActionListener(this);//Registro el componente en los eventos   
    }
    
    public void actionPerformed(ActionEvent ae) {
        if (ae.getSource()== boton) {
            //--->AQUI SE RESPONDE EL EVENTO DEL BOTON
        }
    }
    
    public static void main(String[] args) {
        MiOyente Mo = new MiOyente();//Instanciamos la clase MiOyente
                
    }
}

Ahora si procedemos a realizar nuestro programa donde interactúen el JLabel, JTextField y JButton.
Crearemos un JTextField donde ingresaremos nuestro nombre y cuando demos "click" en el JButton, nos mostrara nuestro nombre ingresado en el JLabel. Comencemos:


import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

public class Ventana_Nombre extends JFrame implements ActionListener{
    //Aplicamos herencia e implementamos una Interfaz ActionListener
    //En el cual nos obliga a implementar el metodo actionPerformed()
    
    private JTextField jtf_nombre;//Defino mi JTextField
    private JButton jbtn_nombre;//Defino mi JButton
    private JLabel jl_nombre;//Defino mi JLabel
    
    public Ventana_Nombre(){
        super("MOSTRAR NOMBRE");//Costructor del Padre recibe el titulo de la VENTANA 
        setLayout(new FlowLayout()); //Defino el Layout que va tener la ventana
        setSize(290, 150);// Damos el tamaño o dimensiones que va tener la VENTANA
        setLocationRelativeTo(this);//Centramos la VENTANA 
        setDefaultCloseOperation(EXIT_ON_CLOSE);//Para cerrar el programa
        jtf_nombre = new JTextField(10);//Instanciamos el JTextField y le damos nombre
        jbtn_nombre = new JButton("MOSTRAR");//Instanciamos el JButton y le damos nombre
        jl_nombre = new JLabel();//Instanciamos el JLabel y le damos nombre
        add(jtf_nombre);//Agregamos el JTextField al Contenedor
        add(jbtn_nombre);//Agregamos el Jlabel al Contenedor
        add(jl_nombre);//Agregamos el JLabel al contenedor
        setVisible(true);//Hacemos visible la VENTANA
        
        //HAREMOS QUE EL BOTON DE UNA ACION AL OYENTE
        
        jbtn_nombre.addActionListener(this);//Registro el componente en los eventos 
    }
    
    public void actionPerformed(ActionEvent ae) {
        if (ae.getSource()==jbtn_nombre) {  //RESPONDE EL EVENTO DEL BOTON
            jl_nombre.setText(jtf_nombre.getText());//Utilizamos los metodos 
        }                                           //setText y getText
    }
    
    public static void main(String[] args) {
        Ventana_Nombre vn = new Ventana_Nombre();//Instanciamos la clase Ventana_Nombre
                
    }
}

Concluimos dejan un ejercicio para que desarrollen una calculadora aplicando los temas estudiados de los componentes de la Interfaz Gráfica de usuario.

Referencias:

Enlace 1 Enlace 2

martes, 6 de septiembre de 2016

Array Unidimensional

ARRAY UNIDIEMNSIONAL
Un array unidimensional es un conjunto o estructura de datos que contiene en sus datos un solo tipo de variable, que quiero decir?, puesto que los datos dentro del array seran llenados por la variable que el programador lo aya puesto dentro del codigo.

Ejemplo.

         Variable[] Nombre = New Variable[Rango];
                                   ò
         Podra ser llamado cuendo se necesite.

         Variable[] Nombre;
          .
          .
          .
         Nombre = New Variable[Rango];

Donde:

          - Variable: Seran los tipos de datos que existen (JAVA).

               -byte[].
               -short[].
               -int[].
               -long[].
               -float[].
               -double[].
               -boolean[].
               -char[].
               -string[].

         En cada caso las cadenas tendran valor NULL. que no es "0" ni "_", es un valor vacio
         en caso de los boolean sera FALSE.
     
         -Nombre: Sera el nombre del ARRAY que se asigne por el programador.

         -Rango: Es la cantidad de datos que se ingresara y siempre inicializado en 0.
                 OJO: no podra ser cambiado dentro del programa (una ves ejecutado).

EJEMPLO de la Declaracion: como se dijo tiene que ser exacto a la hora de ser declarado.

          String[] nombre = new String[3];
          nombre[0] = "Alfredo"; (1)
          nombre[1] = "Briand";   (2)
          nombre[2] = "Jose";       (3)
       
En este caso la declaracion estaria bien pues tendria 3 parametros como entrada.

ERROR A LA HORA DE COMPILAR.

La mayoria de las personas piensa que al poner un RANGO de 4 estariamos hablando de 5 datos(0,1,2,3,4,5) eso seria un error. Pues si esta fuera del rango el IDE botara un ERROR o un Exception.

El mas conocido Desboradmiento de Array:
"Java.langArrayIndexOutOfBoundsException:(numero dado :: 5)
           at "archivo contenido"( "archivo contenido": linea de problema)"

Sino se llenara de forma correcta los datos que se ingresaron o ingresaran.

viernes, 2 de septiembre de 2016

ARRAY

¿Qué es un Array?

Es una estructura de datos donde podemos almacenar un solo tipo de dato, donde se almacenan gran cantidad de datos. En cuanto a su tamaño se lo tiene que declarar en un primer momento y además este no puede cambiar en tiempo de ejecución.


Arrays Unidimensionales


Conocido también como VectorLa sintaxis para declarar e inicializar un array sera:

Tipo_de_variable Nombre_del_array[] = new Tipo_de_variable[dimensión];

También podemos alternativamente usar esta declaración:

                      Tipo_de_variable Nombre_del_array[];
                Nombre_del_array = new Tipo_de_variable[dimensión];



->Los arrays se numeran desde el elemento cero, que sería el primer elemento, hasta el tamaño-1 que sería el último elemento. Es decir, si tenemos un array de diez elementos, el primer elemento sería el cero y el último elemento sería el nueve.


->Cuando declaramos e instanciamos un arreglo este se crea con sus valores por defecto que son:

a) Para números el valor cero “0”.
b) Para cadenas y letras el valor vacío. 
c) Para booleanos el valor false. 

En caso de que queramos inicializarlos con valores propios, haremos esto:
     int edad []= {45, 23, 11, 9}; //Array de 4 elementos
     double estatura[] = {1.73, 1.67, 1.56}; //Array de 3 elementos 
     String nombre[] = {“María”, “Gerson”}; //Array de 2 elementos 
     char sexo[] = {‘m’,’f’}; //Array de 2 elementos 
     boolean array[] = {true,false}; //Array de 2 elementos 



->Para acceder a algún elemento del array debemos especificar el índice del elemento que queremos inspeccionar o modificar ( recordar que va de 0 a N-1).
Donde el indice del elemento debe ser enteros o  expresiones enteras; es decir, que al evaluarse nos de un entero en dicho rango.

Veamos un ejemplo:
public class Array {

  public static void main(String[] args) {
      
     String Nombres[] = new String[5];
   
     Nombres[0] = "Jorge";  //Damos valor al vector
     Nombres[1] = "Brayan";
     Nombres[2] = "Luis"; 
     Nombres[3] = "Pablo";
     Nombres[4] = "Andy"; 

     System.out.println(Nombres[1]); //Mostramos el vector
                                     //en la posicion 1

     for (int i = 0; i < Nombres.length; i++) {  //Usando Bucles
         System.out.println(Nombres[i]); //Mostramos todos los
     }                                   //elementos de arreglo
  }
}


Precaución:

Tenemos que tener mucho cuidado cuando accedemos a algún elemento del array, es un buen hábito de programación verificar que nunca nos saldremos del rango especificado, por ejemplo que nunca ocurrirá lecturas[-1] o lecturas[20]. Si lo hacemos, el compilador Java no sabrá detectarlo en tiempo de compilación pero generará un error en tiempo de ejecución ya que invadiremos otra zona de memoria. 


Referencias:

Enlace 1      Enlace 2      Enlace 3