Viruz

Retrato de piedra en Photoshop (Parte 1)

noreply@blogger.com (Anonymous) — Mon, 17 Sep 2012 07:58:00 -0500

Que tal amigos de Viruz Blog el día de hoy dedicaremos la entrada a Photoshop el cual haremos entrega de la primera parte, de como poder realizar tu retrato de piedra a una imagen e incluso puedes elaborarlo mediante una foto tuya y poder convertirte en un muñeco de piedra, todo lo que necesitas puedes encontrar en este vídeo que se encuentra a continuación.

Recomendaciones:

No utilizar dibujos animados (hablando de renders para el trabajo actual).
Imagen sin cortes en la cabeza el cual se recomienda sea completa.
No cuerpo entero (ya que al modificar nuestra imagen no abarca todo el lienzo y suele no quedar muy bien).

Vídeo

En esta primera parte veremos los temas junto con las siguientes herramientas:

Modificar tamaño de lienzo.
Desaturar imagen.
Mascara rápida.
Brillo y contraste en los ojos.
Sobreexponer con medios tonos y sombras.

Recomendación: En bellos o partes semi oscuras utilizar medios tonos a un 30%.

Modo multiplicar y cambio de opacidad.
Niveles.
Duplicado de texturas.
Filtro desenfoque de superficie.
Filtro de mascara de enfoque.

Les dejo el .PSD de la primera versión junto con las imágenes que utilice como siempre también lo pueden encontrar ya en el DevianArt de un servidor que lo disfruten.

Descarga el PSD e imágenes

Retrato Piedra parte 1

¿Qué es C# y .NET Framework?

noreply@blogger.com (Anonymous) — Wed, 12 Sep 2012 22:15:00 -0500

Hola que tal me he abierto un tiempo para publicar esta entrada que realmente se les hará interesante para la comparación de 2 lenguajes de programación de muy alto nivel, se ha visto a lo largo del tiempo en el Blog Java (temática principal) pero ¿De que otro lenguaje se esta hablando? estoy hablando nada mas ni nada menos que de C.

Nosotros como programadores pueden encontrar en la red mucha información de estos 2 lenguajes y Blogs donde se realizan comparaciones de los lenguajes mencionados anteriormente. Siempre que se vaya a aprender, manejar, implementar, buscar, programar, etcétera;
Se debe tener conocimiento de lo que esencialmente es, ventajas y desventajas y ¿por qué no? su origen.

Se tratará de compartir el conocimiento que se adquiera en este lenguaje por un servidor sea mucho o poco espero que sea de su agrado y que ayude para solventar las dudas que les puedan llegar a surgir en sus trabajos.

¿Que es C#?

Este lenguaje es escrito C# (pronunciado C Sharp). C# es un lenguaje de programación muy flexible y potente, con una historia interesante. Fue desarrollado por Microsoft Corporation para una variedad de razones, algunas técnicas, otras política de marketing y muchas otras.

Características

Existen muchas características pero eso ya con el tiempo uno se irá dando cuenta lo que si tengo que mencionar y que realmente me pareció bastante atractivo es:

El lenguaje C # es orientado a objetos: Y es que C # tiene un gran parecido a los lenguajes de C + + y lenguajes de programación Java, después de haber prestado características (o mejoras) proporcionadas por estos lenguajes. Los orígenes de Java y C + + se puede remontar a un lenguaje llamado C, que es un lenguaje inventado en la década de 1970. C es famoso por ser el idioma que fue escrito el sistema operativo UNIX, y ha sido especialmente diseñado para ello. En conclusión he leído que surge como una fusión de estos 2 lenguajes.
Compatibilidad: Los programadores de este lenguaje sabrán de lo que habla muy bien esta característica, ya que la sintaxis es muy similar a Java, sino que el runtime de lenguaje común también ofrece la posibilidad de acceder a código nativo escrito como funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32.

Ventajas

No puedo definir todas las ventajas pero de las cuales me he topado son las siguientes:

Tipos de datos: En C# existe un rango más amplio y definido de tipos de datos que los que se encuentran en C, C++ o Java.
Declaraciones en el espacio de nombres: Al empezar a programar algo se puede definir una o más clases dentro de un mismo espacio de nombres.

Desventajas

A lo mismo que las ventajas a un no conozco todas pero creo que con el tiempo iré observando algunas otras mas pero entre las 2 mas destacadas son:

El cambio de versión: El IDE el cual se podría decir que es el oficial para este lenguaje es Visual Studio (también conoceremos mas adelante sobre este) y este debe de tener la versión mas reciente de Visual Studio .NET ademas que es mucho mas pesado tan solo en la instalación que NetBeans y por lo consecuente los requerimientos mínimos del sistema son mayores.

.NET Framework: El .Net Framework que se conocerá mas adelante suele cambiar muy poco pero al sacar una nueva versión las clases, librerías suelen después no ser reconocidas o marcadas como obsoletas y generan errores algo que con el JDK de Java no sucede; Se actualiza y marca como obsoleta pero te brinda la oportunidad de compilar tu programa o bien de darte una solución a la clase implementada.

.Net Framework vs JDK

Bien se podría decir que se esta pasando a la parte mas interesante de la entrada, en primer lugar se conoce que JDK:

Es un software que provee herramientas de desarrollo para la creación de programas en Java. Fuente: Wikipedia

Ahora un SDK es:

Un kit de desarrollo de software (SDK o DevKit) normalmente es un conjunto de herramientas de desarrollo que permite a un ingeniero de software crear aplicaciones para un cierto paquete de software, estructura de software, plataforma de hardware, sistema de computadora, consola de juegos de video, sistema operativo, o similar plataforma.

Ahora en conclusión podemos definir que el JDK es un tipo de SDK osea un kit de desarrollo especialmente para JAVA y nos proporciona variables de entorno para los sistemas operativos y hasta el día de hoy se encuentra en la versión 7u7.

Framework (Marco de desarrollo):

Un Framework de software es una abstracción en la que el código común que proporciona una funcionalidad genérica puede invalidar de manera selectiva o especializada por código de usuario que proporciona una funcionalidad específica. Frameworks son similares a las bibliotecas de software en que son abstracciones reutilizables de código envueltos en un API bien definido. A diferencia de las bibliotecas el flujo del programa general de control no está dictada por la persona que llama, sino por el framework.

.Net Framework:

.NET es un framework de Microsoft que hace un énfasis en la transparencia de redes, con independencia de plataforma de hardware y que permita un rápido desarrollo de aplicaciones, .NET podría considerarse una respuesta de Microsoft al creciente mercado de los negocios en entornos Web, como competencia a la plataforma Java de Oracle Corporation y a los diversos framework de desarrollo web basados en PHP.

La conclusión final es que un SDK es una biblioteca (a menudo con aplicaciones de herramientas adicionales, archivos de datos y código de ejemplo) que le ayudará en el desarrollo de código que utiliza un sistema en particular, dibujar gráficos 3D, escribir addons para extender otras aplicaciones, etcétera. Y el framework es una gran biblioteca que ofrece muchos servicios (tal vez en lugar de sólo una capacidad enfocada como la mayoría de las bibliotecas lo hacen), actualmente van en la versión 4.5.

Por último que cabe mencionar que tanto el SDK como el framework son necesarias para que puedas ejecutar tus aplicaciones .jar o .exe en el caso de C# y que si alguna aplicación muestra uno de los típicos mensajes "No se encontró el archivo .DLL requerido" lo solucionarás instalando Microsoft .NET Framework.

Recetario de cocina 1.0 en Java

noreply@blogger.com (Anonymous) — Sat, 8 Sep 2012 21:24:00 -0500

Después de un largo tiempo he podido sacar otra aplicación sencilla, aunque aún no esta al 100% ya se encuentra funcional y con el objetivo de que si el usuario desea alguna mejora puedan comentar o en el mejor de los casos si modifican alguno de los Bugs que se encuentren que en realidad son mas validaciones de campos que cualquier otra cosa pero ya estoy trabajando en ello.

La aplicación se trata de un recetario de cocina donde se pueda llevar el control de tus recetas (válgase la redundancia) y por consecuente los pasos de esta que pueda llevar y solo lo realizamos con puros arreglos que a lo largo de todo este tiempo hemos visto ejemplos, esta en su versión 1 igual e iré mejorando hasta llevarlo a una base de datos.

Lo que se necesita conocer

Nota: Estas entradas son muy importantes ya que se manejan funcionalidades en esta aplicación.

¿Como funciona el programa?

El programa es un poco extenso por lo que resumiré las clases más importantes y los métodos que se debe conocer su funcionamiento (ya ustedes al descargar el programa se darán de cuenta que es lo que hacen todas las clases). El proyecto cuenta con 6 clases (1 clase Main, 2 clases de set y get, 1 JFrame Form que es la ventana principal, 2 JDialog Form).

1. Empezando por la clase Recetas se almacenan:

nombre: Una receta debe de tener un nombre para identificación.
elementos: Es un arreglo de la clase que se utilizará para asociar la receta con los pasos.

Código

Clase Recetas

/**
 *
 * @author Viruz
 */
public class Recetas {
    private String nombre;
    private PasosdeRecetas[] elementos;

    public Recetas(String nombre, PasosdeRecetas[] elementos) {
        this.nombre = nombre;
        this.elementos = elementos;
    }

    /**
     * @return the elementos
     */
    public PasosdeRecetas[] getElementos() {
        return elementos;
    }

    /**
     * @param elementos the elementos to set
     */
    public void setElementos(PasosdeRecetas[] elementos) {
        this.elementos = elementos;
    }

    /**
     * @return the nombre
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * @param nombre the nombre to set
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}

2. La clase PasosdeRecetas tendrá la información (variables) de cada receta que se crea anteriormente aquí los métodos set y get son:

pasos: Número o un índice de pasos que tiene cada receta.
información: Texto que el usuario vaya agregando en cada paso.

Clases PasosdeRecetas

/**
 *
 * @author Viruz
 */
public class PasosdeRecetas {

    private String informacion;
    private PasosdeRecetas pasos;

    public PasosdeRecetas (String infor) {
        this.informacion = infor;
    }

    /**
     * @return the informacion
     */
    public String getInformacion() {
        return informacion;
    }

    /**
     * @param informacion the informacion to set
     */
    public void setInformacion(String informacion) {
        this.informacion = informacion;
    }

    /**
     * @return the pasos
     */
    public PasosdeRecetas getPasos() {
        return pasos;
    }

    /**
     * @param pasos the pasos to set
     */
    public void setPasos(PasosdeRecetas pasos) {
        this.pasos = pasos;
    }
}

3. Dentro de la ventana principal se encontrarán los eventos de botón en el que hacen el ABC (Alta, Baja y Consulta) del programa. Aquí hay 2 métodos importantes que son:

agregarPasos(): Primero dentro de un ciclo do-while se pregunta si el usuario desea agregar mas pasos si la respuesta es igual con la opción No se sale.

do {
    String paso = JOptionPane.showInputDialog (this,"Inserte el paso "+(contador+1));
    if (primero) {
        primerNodo.setInformacion(paso);
        primero = false;
    } else {
        otroNodo = new PasosdeRecetas (paso);
    }
    nodoAux.setPasos(otroNodo);
    nodoAux = otroNodo;
    contador++;
    respuesta2 = JOptionPane.showConfirmDialog(null, "¿Desea insertar otro paso?","¿Continuar?", JOptionPane.YES_NO_OPTION);

    if (respuesta2 != 0 && contador == 1) {
        JOptionPane.showMessageDialog(null, "Solamente se pueden ingresar Recetas con 2 o más pasos");
        respuesta2 = 0;
    }
} while (respuesta2 == 0);

En el mismo método al salir del ciclo se realiza un método de ordenamiento para los pasos agregados y por último se pasan como parámetros a la clase de Recetas.

PasosdeRecetas[] elementos = new PasosdeRecetas [contador];
otroNodo = primerNodo;
int i = 0;
do {
    try {
        elementos[i] = otroNodo;
        otroNodo = otroNodo.getPasos();
        i++;
    } catch (Exception e) {
        break;
    }
} while (otroNodo != null);
unaLista = new Recetas (nombre, elementos);
listas[indiceListas] = unaLista;
indiceListas++;

El segundo método se utiliza cuando se eliminan las recetas en la aplicación y sirve para el recorrido de indices en los arreglos.

/* Método que Actualiza los Indices al Eliminar una Receta*/
public void setListas (Recetas[] recetas) {
    listas = recetas;
    for (int i = 0; i < listas.length; i++) {
        if (listas == null) {
            this.indiceListas = i;
            return;
        }
    }
}

El JDialog Form de ModificarRecetas cuenta con 5 opciones que son las siguientes:

Modificar paso.
Eliminar paso.
Nuevo paso antes.
Nuevo paso después.
Salir.

Con la excepción de Salir y Modificar Paso en las otras 3 se deben realizar las mismas validaciones pero con diferente operación este es un ejemplo con Eliminar Paso.

Nota: Encerré en Try- catch por los OptionPane.

try {
    paso = Integer.parseInt (JOptionPane.showInputDialog("Inserte el Paso a eliminar"));

    /***********Validaciones*********/
    if (paso == 1) {
        nodos[paso-1].setInformacion(null);
        nodos[paso-1].setPasos(null);
        nodos[paso-1] = null;
        PasosdeRecetas []listaNueva = new PasosdeRecetas [nodos.length];
        int cont1 = 0;
        int cont2 = 0;
        do {
            if (nodos[cont1] != null) {
                listaNueva[cont2] = nodos[cont1];
                cont2++;
            }
            cont1++;
        } while (cont1 < nodos.length);
        laLista.setElementos(listaNueva);
        JOptionPane.showMessageDialog(null,"Paso Eliminado");
        this.dispose();
        return;
    }

    if (paso == nodos.length) {
        nodos[paso-2].setPasos(null);
        nodos[paso-1].setInformacion(null);
        nodos[paso-1].setPasos(null);
        nodos[paso-1] = null;
        PasosdeRecetas []listaNueva = new PasosdeRecetas [nodos.length];
        int cont1 = 0;
        int cont2 = 0;
        do {
            if (nodos[cont1] != null) {
                listaNueva[cont2] = nodos[cont1];
                cont2++;
            }
            cont1++;
        } while (cont1 < nodos.length);
        laLista.setElementos(listaNueva);
        JOptionPane.showMessageDialog(null,"Paso Eliminado");
        this.dispose();
        return;
    }

    if (nodos[paso-1] != null) {
        nodos[paso-1].setInformacion(null);
        nodos[paso-2].setPasos(nodos[paso]);
        nodos[paso-1].setPasos(null);
        nodos[paso-1] = null;
        PasosdeRecetas []listaNueva = new PasosdeRecetas [nodos.length];
        int cont1 = 0;
        int cont2 = 0;
        do {
            if (nodos[cont1] != null) {
                listaNueva[cont2] = nodos[cont1];
                cont2++;
            }
            cont1++;
        } while (cont1 < nodos.length);
        laLista.setElementos(listaNueva);
        JOptionPane.showMessageDialog(null,"Paso Eliminado");
        this.dispose();
    }

    else {
        JOptionPane.showMessageDialog (null, "El Paso seleccionado no existe");
    }

} catch (HeadlessException | NumberFormatException e) {
    JOptionPane.showMessageDialog(null, "Error: Invalid Input!",
                                  "Error", JOptionPane.ERROR_MESSAGE);
}

Validaciones:

Nombre de la receta - no null.
Mínimo 2 pasos en una receta.
Nombre de pasos de recetas - no null.
Recorrer indices cuando se elimina.
Modificaciones, consultas y eliminaciones no pueden ir null en los JOptionPane (todos).

Bugs:

Validar que se consulte cuando no tenga pasos.
Al borrar y volver insertar se actualice la lista.
Validar que al dar aceptar no acepta nada.

Vídeo

Descarga el código

Recetario de cocina

Mensajería BETA 1.0 en Java.net

noreply@blogger.com (Anonymous) — Tue, 14 Aug 2012 17:30:00 -0500

En esta ocasión traigo un programa de mensajería que se encuentra en versión BETA pero realiza el funcionamiento que les deseo enseñar y se trata de una mensajería instantánea como Messenger por poner algún ejemplo, aunque me faltan opciones para integrar a la interfaz al menos lo que se desea funciona correctamente y ya podrán descargarlo.

Para ello se debe conocer un poco de las clases que se utilizarán en este programa, pero antes se dará un repaso de lo que se ha apreciado últimamente en primero se aprendió a obtener la dirección IP de alguna pagina y junto con ella el LocalHost de nuestra maquina para ello se utilizo la clase InetAddress el cual se puede consultar mas abajo la API, después se realizo un Servidor TCP el cual se ocupaba de Java.net dos clases nuevas Socket y ServerSocket (Esto añadiéndole los flujos de entrada y salida Buffered de java.io) y por último el cliente TCP en el cual se ocuparon 2 de las anteriores mencionadas para realizar la conexión.

Lo que se necesita conocer

Dirección IP - InetAddress
Servidor TCP - ServerSocket y Socket
Cliente TCP - InetAddress y Socket
DatagramSocket
DatagramPacket

Ahora se verán 2 clases nuevas (de Java.net) estas son DatagramSocket y DatagramPacket, la primera representa un socket para enviar y recibir paquetes de datagramas.

¿Que es un Datagrama?

Hay dos formas de encaminar los paquetes en una red. Estas son: datagrama y circuito virtual. En la técnica de datagrama cada paquete se trata de forma independiente, conteniendo cada uno la dirección de destino. (Fuente: Wikipedia)

Y la segunda representa un paquete datagrama, estos se utilizan para implementar un servicio de entrega de paquetes sin conexión. Cada mensaje se envía de una máquina a otra basada exclusivamente en la información contenida dentro de ese paquete.

Para ver un resumen podemos ver esta imagen que me encontré en Internet de lo que se ha visto:

Ahora después de comprender un poco mejor las clases con las que se maneja Java.net pasamos a lo mas importante el funcionamiento del programa junto con su código, para ello iré paso a paso explicando.

¿Como funciona el programa?

1. Empezando por el servidor se declara un DatagramSocket y en el constructor se crea una instancia dentro de un try - catch.

public class VentanaServidor extends javax.swing.JFrame {
    private DatagramSocket socket;
    /**
     * Creates new form VentanaServidor
     */
    public VentanaServidor() {
        initComponents();

        try {
            socket = new DatagramSocket( 5000 );
        } catch ( SocketException excepcionSocket ) {
            System.exit( 1 );
        }
    }

2. El programa solo cuenta con 2 métodos y un evento de un JTextField, en el primer método llamado esperarPaquetesCliente() se encuentra un ciclo while()
que estará iterando infinitamente se crea un arreglo de byte[] que irán de 100 en 100 obteniendo el mensaje y se instancia la segunda clase mencionada DatagramPacket en el que como se ve en la API se pasan 2 parámetros un arreglo de byte[] y el tamaño que tendrá el DatagramPacket.

Ahora mediante el método receive() se recibe el mensaje que manda el cliente es decir se para el identificador del objeto creado y después se pasa el mensaje al segundo método mostrarMensaje() en el cual con getData() regresamos un buffer de datos y con getLength() devuelve la longitud de los datos que se envían o la longitud de los datos recibidos.

public void esperarPaquetesCliente() {
    while (true) {
        try {
            byte datos[] = new byte[ 100 ];
            DatagramPacket recibirPaquete = new DatagramPacket( datos, datos.length );

            socket.receive( recibirPaquete );

            mostrarMensaje("\nCliente dice: "+ "\n" + new String
                           (recibirPaquete.getData(), 0, recibirPaquete.getLength()) + "\n");
        } catch ( IOException excepcionES ) {
            mostrarMensaje( excepcionES.toString() + "\n" );
        }
    }
}

3. En el segundo método es un hilo el cual se encargará de desplegar el mensaje junto con la ubicación y el tamaño del texto completo.

private void mostrarMensaje( final String mensajeAMostrar ) {
    SwingUtilities.invokeLater(new Runnable() {
        @Override
        public void run() {
            jTextAreaServidor.append( mensajeAMostrar );
            jTextAreaServidor.setCaretPosition(
                jTextAreaServidor.getText().length() );
        }
    }
                              );
}

4. Toca el turno del evento (actionPerfomed) de la etiqueta de texto que es donde se escribe el mensaje primero se declara un String (cadena de texto) y se obtiene el mensaje que se escribe en el JTextField con el método getActionCommand() ahora se le asigna a un arreglo de bytes[] el String con el método getBytes. Diferente a cuando se recibe se crea un objeto de DatagramPacket pero se pasarán 4 parámetros en ves de 2:

Arreglo de bytes, longuitud, la dirección IP (InetAddress), dirección del Socket (SocketAddress).

Listo ya por último se cambia el método para enviar en ves de receive() es send().

private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {
    try {
        jTextAreaServidor.append("\nServidor dice: " + "\n" +
                                 evt.getActionCommand() + "\n" );

        String mensaje = evt.getActionCommand();
        byte datos[] = mensaje.getBytes();

        DatagramPacket enviarPaquete = new DatagramPacket( datos,
                datos.length, InetAddress.getLocalHost(), 63160 );

        socket.send( enviarPaquete );

        jTextAreaServidor.setCaretPosition(
            jTextAreaServidor.getText().length() );
        jTextField1.setText("");
    } catch ( IOException excepcionES ) {
        mostrarMensaje( excepcionES.toString() + "\n" );
    }
}

Vídeo

Descarga el código

Mensajería BETA

Métodos de ordenamiento en Java

noreply@blogger.com (Anonymous) — Sun, 12 Aug 2012 14:35:00 -0500

Hemos conocido a lo largo de este tiempo varios métodos de ordenamiento al igual en donde podemos aplicarlos y como realizarlos, si en dado caso desean conocer alguno de los métodos que se han hecho en el blog mas adelante podrán apreciar los enlaces. Mientras veremos un programa visual en el cual integran varias métodos de ordenamiento a la vez.

Imagen

Lo que se necesita conocer

Se debe conocer que existen muchos métodos existentes con los cuales uno puede ordenar cadenas (estructura de datos) en este ejemplo se verán los siguientes en un solo programa:

Burbuja.
Búsqueda Secuencial.
Shell Sort.
Radix Sort.

Nota: Antes de explicar debo decir que los métodos shell y radix los encontré en la web y los integre a mi programa así que pueden existir otros mejores.

¿Como funciona el programa?

El primer paso es crear el diseño de la ventana en el caso de este ejemplo se crearon dentro 2 paneles que contiene los métodos de ordenamiento y las opciones del vector.
Con el componente JRadioButton se elabora el primer panel donde estos solo tendrán el evento de asignarse un número para identificar en un Swicth - Case.
El botón (JButton) es el que tiene la lógica para ejecutar los métodos para ello se debe instanciar la clase MetodosOrdenamiento en el constructor y así mandar a llamar los métodos.
Por último en esta clase se tienen 2 arreglos llenados de manera estática o implícitamente como también se le conoce en el cual siempre se va a mostrar el llamado arr el otro se ocupa para las diferentes opciones como copiar, eliminar e insertar.

Código

Clase Ventana

import javax.swing.ButtonGroup;
import javax.swing.JOptionPane;

/**
 *
 * @author Viruz
 */
public class Ventana extends javax.swing.JFrame {

    /**
     * Creates new form Ventana
     */
    private MetodosOrdenamiento metodos;
    private int opc;

    public Ventana() {
        initComponents();
        metodos = new MetodosOrdenamiento();


        ButtonGroup grupoRadio = new ButtonGroup();
        //Adición a grupo de botones
        grupoRadio.add(jRadioButton1);
        grupoRadio.add(jRadioButton2);
        grupoRadio.add(jRadioButton3);
        grupoRadio.add(jRadioButton4);
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    private void initComponents() {

        jPanel1 = new javax.swing.JPanel();
        jPanel2 = new javax.swing.JPanel();
        jScrollPane1 = new javax.swing.JScrollPane();
        jList1 = new javax.swing.JList();
        jButton2 = new javax.swing.JButton();
        jPanel3 = new javax.swing.JPanel();
        jRadioButton2 = new javax.swing.JRadioButton();
        jRadioButton3 = new javax.swing.JRadioButton();
        jRadioButton1 = new javax.swing.JRadioButton();
        jRadioButton4 = new javax.swing.JRadioButton();
        jButton1 = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Viruz Blog: Métodos de Ordenamiento");
        setAutoRequestFocus(false);

        jPanel1.setLayout(new java.awt.BorderLayout());

        jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Opciones de vector:"));

        jList1.setModel(new javax.swing.AbstractListModel() {
            String[] strings = { "Mostrar Vector", "Insertar nuevo valor", "Eliminar Número", "Salir" };
            public int getSize() {
                return strings.length;
            }
            public Object getElementAt(int i) {
                return strings[i];
            }
        });
        jScrollPane1.setViewportView(jList1);

        jButton2.setText("Aceptar");
        jButton2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton2ActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
        jPanel2.setLayout(jPanel2Layout);
        jPanel2Layout.setHorizontalGroup(
            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane1)
            .addGroup(jPanel2Layout.createSequentialGroup()
                      .addGap(158, 158, 158)
                      .addComponent(jButton2)
                      .addContainerGap(159, Short.MAX_VALUE))
        );
        jPanel2Layout.setVerticalGroup(
            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel2Layout.createSequentialGroup()
                      .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 74, javax.swing.GroupLayout.PREFERRED_SIZE)
                      .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 17, Short.MAX_VALUE)
                      .addComponent(jButton2))
        );

        jPanel1.add(jPanel2, java.awt.BorderLayout.CENTER);

        jPanel3.setBorder(javax.swing.BorderFactory.createTitledBorder("Método de Ordenamiento:"));
        jPanel3.setPreferredSize(new java.awt.Dimension(400, 185));

        jRadioButton2.setText("Búsqueda Secuencial");
        jRadioButton2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jRadioButton2ActionPerformed(evt);
            }
        });

        jRadioButton3.setText("Shell Sort");
        jRadioButton3.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jRadioButton3ActionPerformed(evt);
            }
        });

        jRadioButton1.setSelected(true);
        jRadioButton1.setText("Burbuja");
        jRadioButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jRadioButton1ActionPerformed(evt);
            }
        });

        jRadioButton4.setText("Radix Sort");
        jRadioButton4.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jRadioButton4ActionPerformed(evt);
            }
        });

        jButton1.setText("Ordenar");
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout jPanel3Layout = new javax.swing.GroupLayout(jPanel3);
        jPanel3.setLayout(jPanel3Layout);
        jPanel3Layout.setHorizontalGroup(
            jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel3Layout.createSequentialGroup()
                      .addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                                .addComponent(jRadioButton1)
                                .addComponent(jRadioButton2)
                                .addComponent(jRadioButton3)
                                .addComponent(jRadioButton4))
                      .addGap(0, 0, Short.MAX_VALUE))
            .addGroup(jPanel3Layout.createSequentialGroup()
                      .addGap(157, 157, 157)
                      .addComponent(jButton1)
                      .addContainerGap(158, Short.MAX_VALUE))
        );
        jPanel3Layout.setVerticalGroup(
            jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel3Layout.createSequentialGroup()
                      .addContainerGap()
                      .addComponent(jRadioButton1)
                      .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                      .addComponent(jRadioButton2)
                      .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                      .addComponent(jRadioButton3)
                      .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                      .addComponent(jRadioButton4)
                      .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 31, Short.MAX_VALUE)
                      .addComponent(jButton1))
        );

        jPanel1.add(jPanel3, java.awt.BorderLayout.PAGE_START);

        getContentPane().add(jPanel1, java.awt.BorderLayout.CENTER);

        pack();
    }// </editor-fold>

    private void jRadioButton2ActionPerformed(java.awt.event.ActionEvent evt) {
        setOpc(2);
    }

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
        switch (getOpc()) {
        case 1:
            System.out.println("\n\nBurbuja: ");
            metodos.Burbuja();
            metodos.mostrar();
            break;
        case 2:
            String n = JOptionPane.showInputDialog(null, "Numero a Buscar:");
            int num = Integer.parseInt(n);
            System.out.println("\nBusqueda Secuencial: ");
            metodos.busquedaSecuencial(num);
            break;
        case 3:
            System.out.println("\n\nShell Sort: ");
            metodos.shellSort();
            metodos.mostrar();
            break;
        case 4:
            System.out.println("\n\nRadix Sort: ");
            metodos.radixSort();
            metodos.mostrar();
            break;
        }
    }

    private void jRadioButton3ActionPerformed(java.awt.event.ActionEvent evt) {
        setOpc(3);
    }

    private void jRadioButton1ActionPerformed(java.awt.event.ActionEvent evt) {
        setOpc(1);
    }

    private void jRadioButton4ActionPerformed(java.awt.event.ActionEvent evt) {
        setOpc(4);
    }

    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
        switch (jList1.getSelectedIndex()) {
        case 0:
            System.out.print("\nVector Desordenado: \n");
            metodos.mostrar();
            break;
        case 1:
            String nInsert = JOptionPane.showInputDialog(null, "Numero a Insertar:");
            int nInsert2 = Integer.parseInt(nInsert);
            metodos.insertarNumero(nInsert2);
            break;
        case 2:
            String nInsert3 = JOptionPane.showInputDialog(null, "Numero a Eliminar:");
            int nInsert4 = Integer.parseInt(nInsert3);
            metodos.eliminarNumero(nInsert4);
            break;
        case 3:
            System.out.println("");
            System.exit(0);
        }
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /*
         * Set the Nimbus look and feel
         */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /*
         * If Nimbus (introduced in Java SE 6) is not available, stay with the
         * default look and feel. For details see
         * http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
         */
        try {
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(Ventana.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(Ventana.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(Ventana.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(Ventana.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>

        /*
         * Create and display the form
         */
        java.awt.EventQueue.invokeLater(new Runnable() {

            public void run() {
                new Ventana().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JList jList1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JPanel jPanel3;
    private javax.swing.JRadioButton jRadioButton1;
    private javax.swing.JRadioButton jRadioButton2;
    private javax.swing.JRadioButton jRadioButton3;
    private javax.swing.JRadioButton jRadioButton4;
    private javax.swing.JScrollPane jScrollPane1;
    // End of variables declaration
    /**
     * @return the opc
     */
    public int getOpc() {
        return opc;
    }

    /**
     * @param opc the opc to set
     */
    public void setOpc(int opc) {
        this.opc = opc;
    }
}

Clase MetodosOrdenamiento

/**
 *
 * @author Jesus Ivan
 */
public class MetodosOrdenamiento {
    public int arrFijo[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    public int arr[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };

    public void restablecer() {
        int tam = this.arr.length;
        int newvector[] = new int[tam];
        System.arraycopy(this.arrFijo, 0, newvector, 0, newvector.length);
        this.arr = newvector;
    }

    public void insertarNumero(int num) {
        int tam = this.arr.length;
        int[] newvector = new int[tam+1];
        System.arraycopy(this.arr, 0, newvector, 0, newvector.length-1);

        this.arr = newvector;
        this.arr[tam] = num;
        this.arrFijo = newvector;
        this.arrFijo[tam] = num;
    }

    public void eliminarNumero(int x) {
        int nPosicion=0;
        for (int j=0; j < arr.length; j++) {
            if ( arr[j]== x ) {
                nPosicion = j;
                break;
            } else {
                if (j == arr.length)
                    System.out.println("Elemento no Encontrado");
            }
        }

        for (int k = nPosicion; k < this.arr.length-1; k++)
            this.arr[k] = this.arr[k+1];

        int tam = this.arr.length;
        int[] newvector = new int[tam-1];
        for (int i = 0; i < newvector.length; i++)
            newvector[i] = this.arr[i];

        this.arr = newvector;
        this.arrFijo = newvector;
    }

    public void Burbuja() {
        int n = arr.length;
        int aux;
        int control = 0;

        for (int j = n-1; j > 0; j--)
            for (int i =0; i < j; i++)
                if (arr[i] > arr[i+1]) {
                    aux = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = aux;
                    control = 0;
                } else {
                    control++;
                    if (control == j)
                        j=0;
                }
    }

    public void busquedaSecuencial(int x) {
        for (int i=1; i <= arr.length; i++) {
            if ( arr[i-1]== x ) {
                System.out.println("Elemento Encontrado");
                System.out.println("Posicion: " + (i-1));
                break;
            } else {
                if (i == arr.length)
                    System.out.println("Elemento no Encontrado");
            }
        }
    }


    public void shellSort() {
        int salto;
        int cambios;
        int aux;
        int i;
        for (salto=(arr.length/2); salto!=0; salto/=2) {
            for (cambios=1; cambios!=0;) {
                cambios=0;
                for (i=salto; i<arr.length; i++) {
                    if (arr[i-salto]>arr[i]) {
                        aux=arr[i];
                        arr[i]=arr[i-salto];
                        arr[i-salto]=aux;
                        cambios++;
                    }
                }
            }
        }
    }

    public void radixSort() {
        int tam = arr.length;
        int[] control = new int[tam];
        int[] siguiente = new int[tam];
        int[] delante = new int[10];
        int[] atras = new int[10];
        int num=0, primero=0, i=0, j=0, k=0, p=0, q=0, y=0;

        for (i=0; i<10; i++ ) {
            control[i]=arr[i];
            siguiente[i]=i+1;
        }

        control[tam-1]=arr[tam-1];
        siguiente[tam-1]=-1;
        primero=0;

        for (k=1; k<4; k++) {
            for (i=0; i<(tam-1); i++) {
                atras[i]=-1;
                delante[i]=-1;
            }
            while (primero!=-1) {
                p=primero;
                primero=siguiente[primero];
                y=control[p];
                num=1;

                for (i=1; i<=k-1; i++)
                    num=num*10;

                j=(y/num) % 10;
                q=atras[j];
                if (q==-1) {
                    delante[j]=p;
                } else {
                    siguiente[q]=p;
                }

                atras[j]=p;
            }
            for (j=0; (j<10)&&(delante[j]==-1); j++);
            primero=delante[j];
            while (j<=9) {
                for (i=j+1; (i<10)&&(delante[i]==-1); i++);
                if (i<=9) {
                    p=i;
                    siguiente[atras[j]]=delante[i];
                }
                j=i;
            }

            if (atras[p]!=-1)
                siguiente[atras[p]]=-1;
        }

        for (i=0; i<tam; i++) {
            arr[i]=control[primero];
            primero=siguiente[primero];
        }
    }

    public void mostrar() {
        for (int i =0; i < this.arr.length; i++)
            System.out.print(this.arr[i] + ", ");
        restablecer();
    }
}

Vídeo

Descarga el código

Métodos de ordenamiento