jueves, 10 de noviembre de 2016

MÉTODO DE BÚSQUEDA

La operación  de buscar un dato dentro de un conjunto dado es una de las operaciones más frecuentes dentro del proceso de datos. 
Clasificaremos los algoritmos de búsqueda en función de si e conjunto de datos sobre lo que se extiende la búsqueda está ordenado o no.(Isabel Gallego Férnandez y Manuel Medina Llinás)
Búsqueda Secuencial 
El método de búsqueda secuencial es el mas sencillo y se debe utilizar si el conjunto de datos sobre el que se extiende la búsqueda no está ordenado siguiendo criterio alguno. Como su nombre indica, consiste en recorrer el conjunto de datos uno a uno y comparar cada rato con el valor buscado hasta encontrarlo, si es que existe, o hasta el último dato sin éxito en la búsqueda, en el caso que no exista.(Isabel Gallego Férnandez y Manuel Medina Llinás)
Búsqueda Binaria
En el caso de buscar sobre un conjunto ordenado, es posible optimizar el criterio de búsquedas gracias a esa ordenación. Estos métodos de búsqueda son muy eficientes, sobre todo para grandes cantidades de datos ; es por esta razón que se suelen utilizar incluso sobre conjuntos de datos no ordenados, sometiéndolos a un proceso de ordenación previo a la búsqueda propiamente dicha. Uno  de estos métodos, el mas popular y sencillo de diseñar, es el método de búsqueda binaria o dicotómica, que estudiaremos en este apartado. 
La búsqueda binaria se basa en aprovechar el hecho de que se trata de datos ordenados para extender la búsqueda únicamente a aquella porción de los datos donde, si el dato existe es seguro que se encuentra.(Isabel Gallego Férnandez y Manuel Medina Llinás)  

CLASE BUSQUEDAS
package practica2;

public class busqueda {

    int max = 100;
    int vector[];
    int indice = 0;

    public void llenarVector(int tamanio) {
        indice=0;
       vector= new int[max];
        while (this.indice < tamanio) {
            vector[this.indice++] = (int) (Math.random() * 20);
        }

    }

    public void Mostrar() {
        for (int i = 0; i < this.getIndice(); i++) {
            System.out.println("Vector [" + i + "] = " + vector[i]);
        }
    }

    public void busquedaSecuencial(int numero) {
        int band = 0;
        for (int i = 0; i < this.getIndice(); i++) {
            if (numero == vector[i]) {
                System.out.println("el numero esta en la posicion [" + i + "]");
                band++;
            }
        }
        if (band == 0) {
            System.out.println("no existe el numero dentro del vector ");
        }
        System.out.println("band " + band);
    }

    public int busquedaBinaria(int numero) {
        int inicio = 0;
        int fin = this.getIndice() - 1;
        int posicion;
        while (inicio <= fin) {
            posicion = (inicio + fin) / 2;
            if (vector[posicion] == numero) {
                return posicion;
            } else if (vector[posicion] < numero) {
                inicio = posicion + 1;
            } else {
                fin = posicion - 1;
            }
        }
        return -1;

    }

    public int getIndice() {
        return indice;
    }

    public int[] getVector() {
        return vector;
    }

    public void Intercambiar(int vector[], int i, int j) {
        int aux;
        aux = vector[j];
        vector[j] = vector[i];
        vector[i] = aux;
    }

    public void ordenamientoSeleccion() {
        int i, j, posicion, menor;
        for (i = 0; i < this.getIndice(); i++) {
            menor = vector[i];
            posicion = i;
            for (j = i + 1; j < this.getIndice(); j++) {
                if (vector[j] < menor) {
                    menor = vector[j];
                    posicion = j;
                }
            }
            if (posicion != i) {
                Intercambiar(vector, i, posicion);
            }
        }
    }

}
CLASE MAIN
package practica2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        busqueda bus = new busqueda();
        System.out.println("Ingrese el tamanio del vector : ");

        bus.llenarVector(Integer.parseInt(br.readLine()));
        bus.Mostrar();
        bus.ordenamientoSeleccion();
        System.out.println("");
        bus.Mostrar();

        System.out.println("Ingrese el numero a buscar : ");
        String numeroo = br.readLine();
        int numero = Integer.parseInt(numeroo);

        System.out.println("-----busqueda de secuencial-----");
        bus.busquedaSecuencial(numero);

        System.out.println("-----busqueda binaria-----");
        int busquedaBinaria = bus.busquedaBinaria(numero);
        if (busquedaBinaria != -1) {
            System.out.println(" existe en la posicion : " + busquedaBinaria);
        } else {
            System.out.println("no se encuentra");
        }
    }
}

MÉTODO DE ORDENAMIENTOS

El problema de la ordenación de un conjunto de datos según un cierto criterio es uno de los más utilizados dentro del proceso de datos, y está ampliamente estudiado en la bibliografía.
Los métodos de ordenación externos se ocupan de estudiar la problemática especifica que comporta el hecho de tener los datos a ordenar almacenados en memoria auxiliar, como es el caso de los ficheros, sobre todo en el caso de ficheros secuenciales. (Isabel Gallego Férnandez y Manuel Medina Linas).
Existen tipos de ordenamiento entre ellos tenemos:
Ordenamiento Burbuja
Consiste en comparar pares de elementos adyacentes e intercambiarlos en el caso de que no estén bien situados según el criterio de ordenación utilizado. Para cada pasada del algoritmo conseguimos que el elemento menor, si la ordenación es creciente, suba como una burbuja hasta su lugar definitivo, pasando de esta forma a engrosar en un elemento el subconjunto ordenado. El método prosigue hasta que el subconjunto desordenado no consta de ningún elemento. (Isabel Gallego Férnandez y Manuel Medina LLinás).
Ordenamiento Inserción
Consiste en dividir el conjunto de datos a ordenar en dos subconjuntos que corresponden, respectivamente, al subconjunto de datos ya ordenados y el subconjunto que contiene los datos pendientes de ordenar. Cada paso del algoritmo consiste en incrementar en un elemento el subconjunto ordenado y decrementar el desordenado, hasta que todos los elementos pertenezcan al subconjunto ordenado y el subconjunto desordenado esté vacío (Isabel Gallego Férnandez y Manuel Medina Llinás).

Ordenamiento Selección
Consiste también en dividir el conjunto de datos a ordenar en dos subconjuntos, el ordenado y el que todavía está desordenado. En cada pasada, el algoritmo selecciona el elemento que cumple el criterio de ordenación(creciente o decreciente) del subconjunto desordenado y lo coloca en el subconjunto ordenado. El algoritmo prosigue hasta que el subconjunto desordenado no consta de ningún elemento.(Isabel Gallego Férnandez y Manuel Medina Llinás).

Ordenamiento QuickSort
Es también un método de ordenación basado en el intercambio, pero en este caso los intercambios no se realizan entre elementos adyacentes, sino distanciados lo más posible.El método Quicksort está basado en la idea de partir el vector en dos particiones delimitadas por un elemento "central" tales que, al final del tratamiento de una partición, la partición izquierda contenga solo elementos menores Al "central" y la derecha mayores al "central". El método consiste en realizar particiones de las particiones hasta que consten de un solo elemento (Isabel Gallego Férnandez y Manuel Medina Llinás).

Ordenamiento Shell
Consiste en ordenar el vector mediante la ordenación de subvectores. Cada subvector se construye mediante aquellos elementos que distan entre sí una constante, empezando por los mas distantes hasta llegar al vector compuesto por los elementos que distan una posición, es decir, todo el vector. Por esta razón, al método se Shell se le denomina también método de inserción con incrementos decrecientes. (Isabel Gallego Férnandez y Manuel Medina Llinás).
   

CLASE ORDENAMIENTOS
package practica1;
import java.util.Random;
public class ordenamiento {

    int max = 100;
    int vector[] = new int[max];

    public void generar(int tamanio) {
        for (int i = 0; i < tamanio; i++) {
            Random rd = new Random();
            vector[i] = rd.nextInt(20);
        }
    }

    public void mostrar(int tamanio) {
        for (int i = 0; i < tamanio; i++) {
            System.out.println("Vector [" + i + "] = " + vector[i]);
        }
    }

    public void Intercambiar(int vector[], int i, int j) {
        int aux;
        aux = vector[j];
        vector[j] = vector[i];
        vector[i] = aux;
    }

    public void ordenamientoBurbuja(int tamanio) {
        for (int i = 0; i < tamanio; i++) {
            for (int j = 0; j < 10; j++) {
                Intercambiar(vector, i, j);
            }
        }
    }

    public void ordenamientoInsercion(int tamanio) {

        int aux, i, j;
        for (i = 0; i < tamanio; i++) {
            j = i;
            aux = vector[i];
            while (j > 0 && aux < vector[j - 1]) {
                vector[j] = vector[j - 1];
                j--;
            }
            vector[j] = aux;
            System.out.println(vector[j]);
            for (int k = 0; k < tamanio; k++) {
                System.out.print(" "+vector[k]);
                        
            }
            System.out.println(" i "+i);
            
        }
    }

    public void ordenamientoShell(int tamanio) {
        int j, l, aux;
        int k;
        k = ( tamanio / 2);
        while (k > 0) {
            for (int i = k; i < tamanio; i++) {
                j = i - k;
                while (j >= 0) {
                    l = j + k;
                    if (vector[j] <= vector[i]) {
                        j--;
                    } else {
                        aux = vector[j];
                        vector[j] = vector[i];
                        vector[i] = aux;
                    }
                }
            }
            k = k / 2;
        }

    }

    public void ordenamientoQuicksort(int vector[], int primero, int ultimo) {

        int aux;
        int i = primero;
        int j = ultimo;
        int pivote = vector[(primero + ultimo) / 2];
        while (i <= j) {
            while (vector[i] < pivote) {
                i++;
            }
            while (vector[j] > pivote) {
                j--;
            }
            if (i <= j) {
                aux = vector[i];
                vector[i] = vector[j];
                vector[j] = aux;
                i++;
                j--;
            }

        }
        if (primero < j) {
            ordenamientoQuicksort(vector, primero, j);
        }
        if (i < ultimo) {
            ordenamientoQuicksort(vector, i, ultimo);
        }

    }

    public void ordenamientoSeleccion(int tamanio) {
        int i, j, posicion, menor;
        for (i = 0; i < tamanio; i++) {
            menor = vector[i];
            posicion = i;
            for (j = i + 1; j < tamanio; j++) {
                if (vector[j] < menor) {
                    menor = vector[j];
                    posicion = j;
                }
            }
            if (posicion != i) {
                Intercambiar(vector, i, posicion);
            }
        }
    }

}

CLASE MAIN
package practica1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Vector;

/**
 *
 * @author luz
 */
public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Ingrese el tamanio del vector : ");
        String tamanioo = br.readLine();
        int tamanio = Integer.parseInt(tamanioo);

        ordenamiento o = new ordenamiento();
        o.generar(tamanio);
        o.mostrar(tamanio);

        System.out.println("-----Ordenamiento de burbuja----- ");
        o.ordenamientoBurbuja(tamanio);
        o.mostrar(tamanio);

        System.out.println("-----Ordenamiento de insercion-----");
        o.ordenamientoInsercion(tamanio);
        o.mostrar(tamanio);

        System.out.println("-----ordenamiento de shell-----");
        o.ordenamientoShell(tamanio);
        o.mostrar(tamanio);

        System.out.println("-----ordenamiento de quicksort-----");
        o.ordenamientoQuicksort(o.vector, 0, tamanio-1);
        o.mostrar(tamanio);

        System.out.println("-----ordenamiento de seleccion-----");
        o.ordenamientoSeleccion(tamanio);
        o.mostrar(tamanio);

    }
}

viernes, 4 de noviembre de 2016

PILAS


DEFINICIÓN DE PILAS:


Una pila es una estructura de datos de acceso restrictivo a sus elementos. 
Las operaciones que caracterizan la pila son las de introducir un nuevo elemento sobre la cima (PUSH) y la de extraer el elemento situado en la cima (POP).
Se puede entender como una pila de libros que se amontonan de abajo hacia arriba.
En principio no hay libros; después ponemos uno, y otro encima de éste, y así sucesivamente. Posteriormente los solemos retirar empezando desde la cima dela pila de libros, es decir, desde el último que pusimos, y terminaríamos por retirar el primero que pusimos, posiblemente ya cubierto de polvo.

Es una estructura de tipo LIFO (Last In First Out), es decir, último en entrar, primero en salir.




lunes, 31 de octubre de 2016

COLAS

"Las colas son secuencias de elementos caracterizadas porque las operaciones de inserción y borrado se realizan sobre extremos opuestos de la secuencia. La inserción se produce en el «final» de la secuencia, mientras que el borrado se realiza en el otro extremo, el «inicio» de la secuencia." (Pantigoso, 2007).

En una cola hay dos extremos, uno es llamado la parte delantera y el otro extremo se llama la parte trasera de la cola. En una cola, los elementos se retiran por la parte delantera y se agregan por la parte trasera, "el primero en llegar es el primero en salir".




viernes, 23 de septiembre de 2016

INTERFAZ GRÁFICA DE USUARIO (GUI)

Las interfaces gráficas de usuario(GUI) ofrecen al usuario ventanas, cuadros de diálogo, barras de herramientas, botones, listas desplegables y muchos otros elementos con los que ya estamos muy acostumbrados a tratar. 
Las GUI se construyen a partir de componentes de GUI (llamados widgets). Un componente de GUI es un objeto visual  con el que el usuario puede interactuar a través del teclado o el mouse.  

Existen dos APIs para la programación de interfaces gráficos de usuario AWT(Abstract Windowing Toolkit) y SWING. 


Similitudes entre Swing y AWT
  • Por regla general, las clases Swing "equivalentes" a las  de AWT se llaman igual, pero con una J delante: JFrame, JTextField, JLabel,etc. teniendo en cuenta que "no todos los componentes están extendidos: para algunos hay componentes equivalentes (Choise), para otros no (Canvas) y para otros constructores son diferentes (Checkbox, Scrollbar, List)".
  • Muchos constructores en Swing tienen los mismos argumentos que en AWT, pero no todos. 
Diferencia entre el Swing y AWT

SWINGAWT
Podemos decir que es la evoluciòn del AWT, la cual al igual que Swing es un conjunto de librerias enfocadas a la construcción de interfaces.
Cada una de las componentes de una ventana en AWT se representa mediante uno o más objetos de la aplicación.
El paquete Swing es parte de la JFC (Java Foundation Classes) en la plataforma Java. La JFC provee facilidades para ayudar a la gente a construir GUIs. Swing abarca componentes como botones, tablas, marcos, etc.
La diferencia de los componentes AWT los Swing se reconocen porque anteponen la letra J antes del nombre.Por ejemplo en AWT se llama Label, mientras que en el Swing se llama JLabel.
Las componentes de Swing utilizan la infraestructura de AWT, incluyendo el modelo de eventos AWT, el cual rige cómo una componente reacciona a eventos tales como, eventos de teclado, mouse, etc.
Permite hacer interfaces gráficas mediante artefactos de interacción con el usuario, como botones, menus, etc.


En sí existe una diferencia, pero al mismo tiempo hay grandes aspectos en común, ambos nos srven para realizar artefactos gráficos y utilizan prácticamente las mismas funciones y componentes, pero la diferencia es que Swing es más avanzado y sus componentes se desarrollan mejor, además AWT necesita tener una plataforma especifica, mientras que desde java Swing podemos utilizarlo y visualizarlo desde diferentes lugares.

AWT
Significa Abstract Windowing Toolkit contiene componentes originales pero no pura interfaz gráfica de usuario que viene con la primera versión de JDK.
  • Es una librería que define un conjunto de clases e interfaces java que permiten la construcción de interfaces gráficas de usuario.
  • Permite hacer interfaces gráficas mediante artefactos de interacción con el,usuario, como botones, menús, texto, botones, etc.Tambien despiegue gráfico general. 
COMPONENTES Y CONTENEDORES
  • COMPONENTES
         *Cualquier elemento gráfico que puede aparecer en una GUI.
         *Lo son todas las clases que derivan de java.awt.Component

         *Ejemplos:

-Botones (java.awt.Button), Campos de texto (java.awt.TextField), etiquetas (java.awt.Label),Listas (java.awt.List), elementos de selección múltiple y exclusiva (java.awt.Checkbox),etc.

  • CONTENEDORES
        *Es un elemento gráfico que puede contener dentro a componentes.
        *Lo son todas las clases que derivan de java.awt.Container
        *Ejemplos:
                           -Ventana (java.awt.Frame)
                           -Dialogo (java.awt.Dialog)
                           -Panel (java.awt.Panel)


JERARQUÍA DE AWT




SWING
Swing es la  evolución de AWT, la cuál al igual que Swing es un conjunto de librerias enfocadas a la construcción de interfaces.

  • Las clases cuyo nombre comienza por J forman parte de Swing.
  • Swing está escrito complementamente en java por lo que es independiente de la plataforma.


COMPONENTEDESCRIPCIÓN
JButton Una implementación de un botón "push".
JCheckBoxUna implementación de una casilla de verificación-un elemento que puede activarse o desactivarse, y que muestra su estado al usuario.
JComboBox Un componente que combina un botón o campo editable y una lista desplegable.
JComponentLa clase base para todos los componentes Swing, excepto contenedoresde Alto nivel.
JDialog La clase principal para la creación de una ventana de diálogo.
JFileChooser Proporciona n mecanismo sencillo para que el usuario elija un archivo.
JFrameUna versión extendida de java.awt.Frame que añade soporte para la arquitectura de componentes JFC/Swing.
JLabelUn área de visualización de una cadena corta de texto o una imagen, o ambos.
JList Un componente que muestra una lista de objetos y permite al usuario seleccionar uno o más  elementos
JMenu Una implementación de un menu-una ventana emergente que contiene JMenusItems que se    muestra cuando el usuario selecciona un elemento en la JMenuBar.
JOptionPaneHace que sea fácil para que aparezca un cuadro de diálogo estándar que solicita a los   usuarios un valor o les informa algo.
JPanelEs un contenedor ligero genérico.
JRadioButtonUna implementacion de un boton de radio-un elemento que puede activarse o desactivarse, y que muestra su estado al usuario.
JScrollBarUna implementación de una barra de desplazamiento.
Jslider Un componente que permite al usuario seleccionar gráficamente un valor deslizando un botón dentro de un intervalo acotado.
JTextAreaUn JTextArea es un area de varias lineas que muestra texto sin formato.
JTextFieldUn JTextField es un componente ligero que permite la edición de una sola línea de texto.
JTreeUn control que muestra un conjunto de datos jerárquicos como un esquema.
JWindow Un JWindow es un contenedor que se puede mostrar en cualquier lugar en el escritorio del usuario
JApplet Una versión extendida de java.applet.Applet que añade soporte para la arquitectura de componentes JFC / Swing

JERARQUÍA DE SWING


A continuación se realizara un ejemplo de operaciones: suma, resta, producto y cociente
//A continuación se realizara un ejemplo de operaciones:suma, resta,prodcto y cociente
package Tarea;
import java.awt.event.*;
import javax.swing.*;

public class Calcu extends JFrame{
    
    JLabel jl_var_1;
    JLabel jl_var_2;
    JLabel jl_result;   
    JTextField jtf_var1;
    JTextField jtf_var2;
    JTextField jtf_resultado;
    JButton btn_suma;
    JButton btn_resta;
    JButton btn_producto;
    JButton btn_cociente;
    JButton btn_salir;
    
    public Calcu() {
        
        setLayout(null);
        
        jl_var_1= new JLabel("Variable 1");
        jl_var_1.setBounds(10, 10, 100, 20);
        
        jl_var_2= new JLabel("Variable 2");
        jl_var_2.setBounds(10, 30, 150, 25);
        
        jl_result=new JLabel("Resultado");
        jl_result.setBounds(30, 170, 100, 15);
        
        jtf_var1= new JTextField(50);
        jtf_var1.setBounds(80,10,100,20);
        
        jtf_var2 = new JTextField(50);
        jtf_var2.setBounds(80,40,100,20);
        
        jtf_resultado = new JTextField(50);
        jtf_resultado.setBounds(100, 170, 120, 20);
        
        btn_suma= new JButton("Suma");
        btn_suma.setBounds(150, 70, 100, 20);
        
        btn_resta = new JButton("Resta");
        btn_resta.setBounds(150, 95, 100, 20);
        
        btn_producto = new JButton("Producto");
        btn_producto.setBounds(150, 120, 100, 20);
        
        btn_cociente = new JButton("Cociente");
        btn_cociente.setBounds(150, 145, 100, 20);
        
        btn_salir= new JButton("Salir");
        btn_salir.setBounds(150, 200, 100, 20);
        
        add(jl_var_1);
        add(jl_var_2);
        add(jl_result);
        add(jtf_var1);
        add(jtf_var2);
        add(jtf_resultado);
        add(btn_suma);
        add(btn_resta);
        add(btn_producto);
        add(btn_cociente);
        add(btn_salir);
        
        btn_suma.addActionListener(new evenSuma());
        btn_resta.addActionListener(new evenResta());
        btn_producto.addActionListener(new evenProducto());
        btn_cociente.addActionListener(new evenCociente());
        btn_salir.addActionListener(new evenSalir());

        
        setTitle(" OPERACION ");
        setSize(300,300);
        setVisible(true);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        
    }
    
    public  class evenSuma implements ActionListener{

        public  void actionPerformed (ActionEvent ee){
            if (ee.getSource()==btn_suma) {
                double a,b,s;
                String n;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                s=a+b;
                n=String.valueOf(s);
                jtf_resultado.setText(n);
            }
            
            
        }
    }
     
    public class evenResta implements ActionListener{
         public  void actionPerformed (ActionEvent e){
             if (e.getSource()==btn_resta) {
                double a,b,r;
                String m;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                r=a-b;
                m=String.valueOf(r);
                jtf_resultado.setText(m);
             }
         }
    }
    
    public class evenProducto implements ActionListener{
        public void actionPerformed (ActionEvent eee){
            if (eee.getSource() == btn_producto) {
                double a,b,p;
                String mm;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                p=a*b;
                mm=String.valueOf(p);
                jtf_resultado.setText(mm);
            }
        }
    }
    
    public class evenCociente implements ActionListener{
        public void actionPerformed(ActionEvent eee){
            if (eee.getSource() == btn_cociente) {
                double a, b, c;
                String nn ;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                if (b != 0) {
                    c=a/b;
                    nn=String.valueOf(c);
                    jtf_resultado.setText(nn);
                    
                }else{
                    JOptionPane.showMessageDialog(null, "No existe");
                }
            }
        }
    }
    
    public class evenSalir implements ActionListener{
        public void actionPerformed (ActionEvent eeee){
            if (eeee.getSource() == btn_salir) {
                System.exit(0);
            }
        }
    }
    
    public static void main(String[] args) {
        Calcu calcu = new Calcu();
    }
    
}


ARCHIVOS

Los programas usan variables para almacenar información: datos de entrada, los resultados calculados y valores intermedios generados a lo largo del cálculo. Toda esta información es efímera: cuando acaba el programa, todo desaparece. Pero, para muchas aplicaciones, es importante poder almacenar datos de manera permanente, es para esto que se crean archivos o también llamados ficheros ya que nos permite guardar información más allá del tiempo de ejecución. Los archivos nos permite interactuar con los dispositivos de almacenamiento externo para poder mantener la información en el tiempo.

Existen dos tipos de archivos:

1. ARCHIVO DE TEXTO O PLANO

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres, estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

2. ARCHIVO BINARIO

Un archivo binario  es un archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores, como por ejemplo: imágenes, sonido, vídeo, etc.


LA CLASE FILE: Proporciona información acerca de los archivos, de sus atributos, de los directorios, etc. Se usa para crear un archivo.

-Constructores

Constructores de la clase FileEjemplo
public File(String pathname) ;new File("/carpeta/archivo");
public File(String parent, Stringchild) ;new File("carpeta", "archivo");
public File(File parent, Stringchild) ;new File(new File("/carpeta"), "archive");
public File(URI uri) ;new File(new URI(str);

-Métodos

MÉTODOS
canRead()comprueba si el fichero se puede leer
canWrite()comprueba siel fichero se puede escribir
delete()borra dicho fichero
getPath()devuelve la ruta del fichero
mkdir()crea un directorio con la ruta del objeto que lo recibe
isDirectory()comprueba si dicho fichero es un directorio

JERARQUÍA DE FLUJO DE DATOS


Las clases Reader y Writer son clases bases de la jerarquía para los flujos de caracteres es decir se usa para la escritura y lectura de archivos plano o de texto.


Las clases InputStream y OutputStream con las clases bases para leer y escribir archivos binarios.


EJEMPLO DE LECTURA/ESCRITURA DE ARCHIVO PLANO

A continuación se creará, escribirá y leerá un archivo de texto plano:
 package blogger;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class Archivo_de_texto {
    private File f;
    
    public void crearArchivo(){
        try {
            
            f = new File ("Archivos/archivo_plano.txt");
            
            if(!f.exists()){
                f.createNewFile();
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }      
    }
    
    public void escribirArchivo(){
        try {
            FileWriter fw = new FileWriter(f);
            fw.write("Mi primer archivo plano");
            fw.close();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
   
    }
    public void leerArchivo (){
        try {
            FileReader fr = new FileReader(f);
            BufferedReader br = new BufferedReader(fr);
            String linea = null;
            while ((linea=br.readLine()) != null) {                
                System.out.println(linea);
            }
            br.close();
            fr.close();
            
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
EJEMPLO DE LECTURA/ESCRITURA DE ARCHIVO BINARIO

A continuación se creará, escribirá y leerá un archivo de texto plano:
package blogger;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class Archivo_Binario {
    private File f;
    
    public void crearArchivoBinario(){
            try {
                f= new File("Archivos/archivo_binario.txt");
               if(!f.exists()){
                f.createNewFile();
            }
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
    }    
    
    public void escribir_ArchivoBinario(){
        try {
            List  estudiantes = new ArrayList ();
            Estudiante e1 = new Estudiante("Jorge", "75426598", 18, "1234567", "Sistemas");
            Estudiante e2 = new Estudiante("Martha", "7757856", 16, "1745863", "Zootecnia");
            Estudiante e3 = new Estudiante("Martin", "7786626", 22, "1234567", "Ambiental");
           
            estudiantes.add(e1);
            estudiantes.add(e2);
            estudiantes.add(e3);
            
            FileOutputStream fos = new FileOutputStream(f);
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            oos.writeObject(estudiantes);
            oos.close();
            fos.close();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    
    public void leerArchivoBinario(){
        try {
            FileInputStream fis = new FileInputStream(f);
            ObjectInputStream ois = new ObjectInputStream(fis);
            ois.close();
            fis.close();
            
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

viernes, 2 de septiembre de 2016

ARREGLOS UNIDIMENSIONALES

Concepto de Array

También es conocido como tabla, matriz, vector, arreglo, disposición, etc. Java proporciona una clase Array como contenedor básico de objetos y tipos primitivos. Los arrays surgen de la necesidad de tratar conjuntos de datos del mismo tipo relacionados entre sí. (Ing. Jose F. Vélez Serrano, Universidad Rey Juan Carlos).

Los arreglos son una estructura homogénea de datos, de tamaño constante, en la cual se accede a cada uno de sus elementos mediante un identificador común y uno o varios índices.  

Por definición podemos ver:

  • Todos los elementos del array son del mismo tipo.
  • El número máximo de valores posibles que puede tomar cada índice se denomina rango de esa dimensión o índice. Los valores han de ser consecutivos, por lo que el índice ha de ser de un tipo ordinal. 
  • El número de ellos no varía durante la ejecución del programa.

Declarar y Crear un Array

Para declarar un array se escribe:

tipo_de_dato[]  nombre_del_array;  
o
tipo_de_dato  []nombre_del_array;

Ejemplo: Declarar un array  de  enteros.

int numeros[]; 
Para crear un array de 4 números enteros escribimos 

nombre=new tipo[tamaño];

 numeros=new int[4];

La declaración y la creación del array se pueden hacer en una misma línea. Usando el siguiente formato:

tipo[] nombre=new tipo[tamaño]
por ejemplo:  
int[] numeros =new int[4];

Observación:
En la declaración de una variable array no está permitido  poner el tamaño  del arreglo.

EJERCICIO


El siguiente programa lee por teclado 7 números y una posición (0-9). Elimina el número que corresponde a la posición ingresada.
 

public class Ejercicio {

    public static void main(String[] args) {
        int numeros[] = new int[7];
        int posicion;

        Scanner sc = new Scanner(System.in);
        // lee los 7 números
        for (int i = 0; i < numeros.length; i++) {
            System.out.print("Elemento [" + i + "]: ");
            numeros[i] = sc.nextInt();
        }

        System.out.println();
        // lee la posicion a eliminar
        System.out.print("Posición a eliminar: ");
        posicion = sc.nextInt();
        // desplazamos desde el índice a eliminar hasta el final, todos los 
        //elementos un lugar hacia la izquierda, de esta manera el elemento que
        //está en posición se borra.
        for (int i = posicion; i < numeros.length - 1; i++) //llega hasta la penúltima posición
        {
            numeros[i] = numeros[i + 1];
        }
        System.out.println("El vector queda de la siguiente forma: ");
        for (int i = 0; i < numeros.length - 1; i++) //hay un elemento menos en el arreglo
        {
            System.out.println(numeros[i]);
        }
    }
}