Mostrando entradas con la etiqueta JOptionPane. Mostrar todas las entradas
Mostrando entradas con la etiqueta JOptionPane. Mostrar todas las entradas

jueves, 15 de octubre de 2015

Simple Editor Java - File Analizer





package Proyecto;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.io.File;
import java.io.FileWriter;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyleContext;
import org.jdesktop.swingx.JXCollapsiblePane;

public class Principal extends javax.swing.JFrame
{
    public Principal()
    {
        initComponents();
        this.setLocationRelativeTo(null);
        setTitle("Code Editor");
        jXCollapsiblePane1.setLayout(new BorderLayout());
        jXCollapsiblePane1.add(jPanel2, BorderLayout.CENTER);
        btnControl.addActionListener(jXCollapsiblePane1.getActionMap().get(JXCollapsiblePane.TOGGLE_ACTION));
        //txtEditor.setText("public class Hola {}");
        dirArchivo.setEnabled(false);
    }
    
    String titulo = " - Editor 0.1";
    final StyleContext cont = StyleContext.getDefaultStyleContext();
    final AttributeSet attr = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, Color.BLUE);
    final AttributeSet attrBlack = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, Color.BLACK);
    final AttributeSet attrComent = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, Color.RED);
    
    DefaultStyledDocument doc = new DefaultStyledDocument()
    {
        @Override
        public void insertString(int offset, String str, AttributeSet a) throws BadLocationException
        {
            super.insertString(offset, str, a);
            String text = getText(0, getLength());
            int before = findLastNonWordChar(text, offset);
            if (before < 0) 
            {
                before = 0;
            }
            int after = findFirstNonWordChar(text, offset + str.length());
            int wordL = before;
            int wordR = before;

            while (wordR <= after) {
                if (wordR == after || String.valueOf(text.charAt(wordR)).matches("\\W")) {
                    if (text.substring(wordL, wordR).matches("(\\W)*(abstract|continue|for|new|switch|default|if|package|synchronized|boolean|do|goto|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|return|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|volatile|const|float|native|super|while)")) {
                        setCharacterAttributes(wordL, wordR - wordL, attr, false);
                    } else {
                        setCharacterAttributes(wordL, wordR - wordL, attrBlack, false);
                    }
                    wordL = wordR;
                }
                wordR++;
            }
        }

        public void remove(int offs, int len) throws BadLocationException {
            super.remove(offs, len);
            String text = getText(0, getLength());
            int before = findLastNonWordChar(text, offs);
            if (before < 0) {
                before = 0;
            }
            int after = findFirstNonWordChar(text, offs);

            if (text.substring(before, after).matches("(\\W)*(abstract|continue|for|new|switch|default|if|package|synchronized|boolean|do|goto|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|return|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|volatile|const|float|native|super|while)")) 
.
.
.
Descargar:
https://www.dropbox.com/s/8f9bxbls19xdxa0/Compilers.rar?dl=0
https://www.youtube.com/user/delfirosales

miércoles, 28 de mayo de 2014

Reproductor de Audio en Java

Reproductor de Audio basico en Java con opciones de Play, Pausa y Stop.
Primero descargar e instalar Java Media Framework API (JMF) del siguiente enlace. http://www.oracle.com/technetwork/java/javase/download-142937.html


import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.media.CannotRealizeException;
import javax.media.Manager;
import javax.media.NoPlayerException;
import javax.media.Player;
import javax.media.Time;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileNameExtensionFilter;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Delfi
 */
public class Reproductor extends javax.swing.JFrame {
   
    Player audioPlayer = null;
    String audioPath = " ";  
    /**
     * Creates new form Reproductor
     */
    public Reproductor() {
        initComponents();
        this.setLocationRelativeTo(null);
        jlabelEstado.setText(" ");
        dirArchivo.setText(" ");
    }  

    /**
     * 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")
    //                         
    private void initComponents() {

        jPanel2 = new javax.swing.JPanel();
        btnPlay = new javax.swing.JButton();
        btnPause = new javax.swing.JButton();
        btnStop = new javax.swing.JButton();
        jlabelEstado = new javax.swing.JLabel();
        dirArchivo = new javax.swing.JLabel();
        jMenuBar1 = new javax.swing.JMenuBar();
        jMenu1 = new javax.swing.JMenu();
        jMenuAbrir = new javax.swing.JMenuItem();
        jMenuSalir = new javax.swing.JMenuItem();
        jMenuAbout = new javax.swing.JMenu();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Reproductor de Audio - Java Tips - http://javacodebasics.blogspot.mx");
        setIconImage(new ImageIcon(getClass().getResource("/Imagenes/music.png")).getImage());
        setResizable(false);

        btnPlay.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imagenes/play.png"))); // NOI18N
        btnPlay.setText("Play");
        btnPlay.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnPlayActionPerformed(evt);
            }
        });

        btnPause.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imagenes/pause.png"))); // NOI18N
        btnPause.setText("Pause");
        btnPause.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnPauseActionPerformed(evt);
            }
        });

        btnStop.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imagenes/stop.png"))); // NOI18N
        btnStop.setText("Stop");
        btnStop.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnStopActionPerformed(evt);
            }
        });

        jlabelEstado.setFont(new java.awt.Font("Tahoma", 1, 11)); // NOI18N
        jlabelEstado.setText("Reproductor");

        dirArchivo.setText(" ");

        javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
        jPanel2.setLayout(jPanel2Layout);
        jPanel2Layout.setHorizontalGroup(
            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel2Layout.createSequentialGroup()
                .addComponent(btnPlay, javax.swing.GroupLayout.PREFERRED_SIZE, 165, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(18, 18, 18)
                .addComponent(btnPause, javax.swing.GroupLayout.PREFERRED_SIZE, 165, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(18, 18, 18)
                .addComponent(btnStop, javax.swing.GroupLayout.PREFERRED_SIZE, 165, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 0, Short.MAX_VALUE))
            .addGroup(jPanel2Layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(jPanel2Layout.createSequentialGroup()
                        .addComponent(jlabelEstado, javax.swing.GroupLayout.PREFERRED_SIZE, 223, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addGap(0, 0, Short.MAX_VALUE))
                    .addComponent(dirArchivo, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
                .addContainerGap())
        );
        jPanel2Layout.setVerticalGroup(
            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel2Layout.createSequentialGroup()
                .addContainerGap(14, Short.MAX_VALUE)
                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(btnPlay)
                    .addComponent(btnPause)
                    .addComponent(btnStop))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addComponent(jlabelEstado)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(dirArchivo)
                .addGap(3, 3, 3))
        );

        jMenu1.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imagenes/archivo.png"))); // NOI18N
        jMenu1.setText("Archivo");

        jMenuAbrir.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imagenes/abrir.png"))); // NOI18N
        jMenuAbrir.setText("Abrir archivo de audio");
        jMenuAbrir.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jMenuAbrirActionPerformed(evt);
            }
        });
        jMenu1.add(jMenuAbrir);

        jMenuSalir.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imagenes/salir.png"))); // NOI18N
        jMenuSalir.setText("Salir");
        jMenuSalir.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jMenuSalirActionPerformed(evt);
            }
        });
        jMenu1.add(jMenuSalir);

        jMenuBar1.add(jMenu1);

        jMenuAbout.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imagenes/about.png"))); // NOI18N
        jMenuAbout.setText("About");
        jMenuAbout.addMouseListener(new java.awt.event.MouseAdapter() {
            public void mouseClicked(java.awt.event.MouseEvent evt) {
                jMenuAboutMouseClicked(evt);
            }
        });
        jMenuBar1.add(jMenuAbout);

        setJMenuBar(jMenuBar1);

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addComponent(jPanel2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 0, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addContainerGap())
        );

        pack();
    }//                       

    private void btnPauseActionPerformed(java.awt.event.ActionEvent evt) {                                        
        audioPlayer.stop();
        jlabelEstado.setText("Pausa");
    }                                      

    private void btnPlayActionPerformed(java.awt.event.ActionEvent evt) {                                      
        if(file.equals(""))
        {
            JOptionPane.showMessageDialog(null, "Cargue una Pista de Audio", "Error al Reproducir", JOptionPane.INFORMATION_MESSAGE, new ImageIcon(getClass().getResource("/imagenes/verificar.png")));
        }
        else
        {
            audioPlayer.start();
            jlabelEstado.setText("Reproduciendo");
        }
    }                                      

    private void btnStopActionPerformed(java.awt.event.ActionEvent evt) {                                      
        audioPlayer.stop();
        audioPlayer.setMediaTime(new Time(0.0));
        jlabelEstado.setText("");
    }                                      

    String file="";
    public String abrirAudio()
    {    
        JFileChooser se = new JFileChooser();
       
        se.setCurrentDirectory(new File(System.getProperty("user.home") + "\\Music"));
        FileNameExtensionFilter filtro = new FileNameExtensionFilter("Archivos de Imagen", "mp3", "wav");
        se.setFileFilter(filtro);
        se.setFileSelectionMode(JFileChooser.FILES_ONLY);
       
        int estado = se.showOpenDialog(null);
        if(estado == JFileChooser.APPROVE_OPTION)
        {
            try
            {
                String pathArchivo = se.getSelectedFile().getPath();
                URL url = se.getSelectedFile().toURL();  
                this.file= se.getSelectedFile().getName();
                audioPlayer = Manager.createRealizedPlayer( url );
                dirArchivo.setText(pathArchivo);
            } catch (MalformedURLException ex) {
                Logger.getLogger(Reproductor.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IOException ex) {
                Logger.getLogger(Reproductor.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NoPlayerException ex) {
                Logger.getLogger(Reproductor.class.getName()).log(Level.SEVERE, null, ex);
            } catch (CannotRealizeException ex) {
                Logger.getLogger(Reproductor.class.getName()).log(Level.SEVERE, null, ex);
            }
        }        
        return "Java Tips - " + this.file;
    }
   
    private void jMenuAbrirActionPerformed(java.awt.event.ActionEvent evt) {                                          
      this.setTitle(abrirAudio());
    }                                        

    private void jMenuSalirActionPerformed(java.awt.event.ActionEvent evt) {                                          
        this.dispose();
    }                                        

    private void jMenuAboutMouseClicked(java.awt.event.MouseEvent evt) {                                      
        About a = new About();
        a.setVisible(true);
    }                                      

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //
        /* 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(Reproductor.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(Reproductor.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(Reproductor.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(Reproductor.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new Reproductor().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify                    
    private javax.swing.JButton btnPause;
    private javax.swing.JButton btnPlay;
    private javax.swing.JButton btnStop;
    private javax.swing.JLabel dirArchivo;
    private javax.swing.JMenu jMenu1;
    private javax.swing.JMenu jMenuAbout;
    private javax.swing.JMenuItem jMenuAbrir;
    private javax.swing.JMenuBar jMenuBar1;
    private javax.swing.JMenuItem jMenuSalir;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JLabel jlabelEstado;
    // End of variables declaration                  
}



Descargar Archivo Netbeans:

martes, 15 de abril de 2014

Customize JOptionPane Dialog

import javax.swing.*;

public class Test
{
    public static void main(String[] args)
    {
        final ImageIcon icon = new ImageIcon("C:\\Users\\Delfi\\Desktop\\ejemplo.jpg");
        JOptionPane.showMessageDialog(null, "Blah blah blah", "About", JOptionPane.INFORMATION_MESSAGE, icon);
    }
}
or
String mensaje = "Java Tips"

JOptionPane.showMessageDialog(null, mensaje, "http://javacodebasics.blogspot.com/", 
JOptionPane.INFORMATION_MESSAGE, new ImageIcon(getClass().getResource("/Imagenes/dataOk.png")));

sábado, 7 de diciembre de 2013

Arreglo Bidimensional o Matrices en Java

Un array en Java puede tener más de una dimensión. El caso más general son los arrays bidimensionales también llamados matrices o tablas. La dimensión de un array la determina el número de índices necesarios para acceder a sus elementos. Los vectores que hemos visto en otra entrada anterior son arrays unidimensionales porque solo utilizan un índice para acceder a cada elemento. Una matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos representar una matriz como una tabla de n filas y m columnas cuyos elementos son todos del mismo tipo. 

La siguiente figura representa un array M de 3 filas y 5 columnas:


Para procesar ( recordar solo operaciones y comparaciones) internamente todos los elementos de la tabla se ocupan dos ciclos for(), uno externo para controlar renglón y uno interno para controlar columna.

Ejemplo de un Arreglo Bidimensional.

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class Arreglo_Bidimensional
{
    public static void main (String args[])
    {
        int arreglo1[][];
        int arreglo2[][];
        int arreglo3[][];
        int Nfilas, Mcolumnas;
        String entrada, entrada1, entrada2;
        
        JTextArea areaSalida = new JTextArea();
        areaSalida.setText("             #########################\n");
        areaSalida.append("                       Arreglo Bidimensional\n");
        areaSalida.append("             #########################\n\n");
        
        entrada = JOptionPane.showInputDialog("Introduce el Numero de Filas para el Arreglo");
        Nfilas = Integer.parseInt( entrada );
        
        entrada1 = JOptionPane.showInputDialog("Introduce el Numero de Columnas para el Arreglo");
        Mcolumnas = Integer.parseInt( entrada1 );
        
        arreglo1 = new int[Nfilas][Mcolumnas];
        arreglo2 = new int[Nfilas][Mcolumnas];
        arreglo3 = new int[Nfilas][Mcolumnas];
        
        areaSalida.append("Numero de filas son:\n  " + Nfilas);
        areaSalida.append("\nNumero de columnas son:\n  " + Mcolumnas + "\n");
        
        int i, j;
        areaSalida.append("Arreglo 1: \n");
        for(i = 0; i < Nfilas; i++)
        {
            for(j = 0; j < Mcolumnas; j++)
            {
                entrada2 = JOptionPane.showInputDialog("Introduzca el elemento de la fila " +(i)+ " y columna " +(j)+" del Arreglo1");
                arreglo1[i][j] = Integer.parseInt( entrada2 );
                areaSalida.append("  " + arreglo1[i][j] + "  - ");              
            }
            areaSalida.append(" \n");
        }
        
        areaSalida.append("Arreglo 2 : \n");
        for(i = 0; i < Nfilas; i++)
        {
            for(j = 0; j < Mcolumnas; j++)
            {
                entrada2 = JOptionPane.showInputDialog("Introduzca el elemento de la fila " +(i)+ " y columna " +(j)+" del Arreglo2");
                arreglo2[i][j] = Integer.parseInt( entrada2 );
                areaSalida.append("  " + arreglo2[i][j] + "  - ");
            }
            areaSalida.append("\n");
        }

        areaSalida.append("La suma del Arreglo 1 + Arreglo 2 = Arreglo 3 \n");
        for(i = 0; i < Nfilas; i++)
        {
            for(j = 0; j < Mcolumnas; j++)
            {
                arreglo3[i][j] = arreglo1[i][j] + arreglo2[i][j];
                areaSalida.append("  " + arreglo1[i][j] + "  +  " + arreglo2[i][j] + "  =  " + arreglo3[i][j] + "\n");
            }
            areaSalida.append("\n");
        }
        
        JOptionPane.showMessageDialog(null, areaSalida);
        }
}
Output:

Pares, Impares + Suma de elementos en un Arreglo

/*******************************************************************************
 *                  Universidad Autonoma de Guerrero                           *
 *                   Unidad Academica de Ingenieria                            *
 *                           Programacion I                                    *
 *============================= Java Tips =====================================*
 ******************************************************************************/
import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class JavaTips
{
    public static void main (String args[])
    {
        int arreglo[];
        int introducido, elemento;
        String entrada, entrada2;
        
        JTextArea areaSalida = new JTextArea();
        areaSalida.setText("    #########################\n");
        areaSalida.append("\t Java Tips\n");
        areaSalida.append("     #########################\n\n");
        
        entrada = JOptionPane.showInputDialog("Introduce el tamaño del Arreglo");
        introducido = Integer.parseInt(entrada);
        arreglo = new int [introducido];
        
        areaSalida.append("El tamaño del Arreglo es de:\n  " + entrada);
        areaSalida.append("\n\nElementos Introducidos del Arreglo\n");
        
        for (elemento = 0; elemento < introducido; elemento++)
        {
            entrada2 = JOptionPane.showInputDialog("Introduce el elemento " + (elemento + 1) + " para el Arreglo");
            arreglo[elemento] = Integer.parseInt(entrada2);
            areaSalida.append("  " + arreglo[elemento] + ",");
        }

        int suma1 = 0, suma2 = 0;
        areaSalida.append("\n\nLos Numero Pares del Arreglo son\n");
        for (elemento = 0; elemento < introducido; elemento++)
        {
            if( arreglo[elemento]%2==0)
            {
                suma1 = suma1 + arreglo[elemento];
                areaSalida.append("  " + arreglo[elemento] + ",");
            }
        }
        
        areaSalida.append("\n\nLos Numero Impares del Arreglo son\n");
        for (elemento = 0; elemento < introducido; elemento++)
        {
            if( arreglo[elemento]%2!=0)
            {
                suma2 = suma2 + arreglo[elemento];
                areaSalida.append("  " + arreglo[elemento] + ",");
            }
        }
        areaSalida.append("\n\nResultado de la Suma de los Pares\n  " + suma1);
        areaSalida.append("\n\nResultado de la Suma de los Impares\n  " + suma2);
        
        JOptionPane.showMessageDialog( null, areaSalida, "Java Tips", JOptionPane.INFORMATION_MESSAGE);
    }
}
Output:

lunes, 18 de marzo de 2013

si ya existe, insertarlo al final del Arreglo

Introducir elementos de un arreglo y al final agregar un nuevo elemento, si el elemento ya existe en el arreglo insertarlo al final.
import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class ExamenProgramacion_II
{
    public static void main (String args[])
    {
        int arreglo[];
        int introducido, elemento, NuevoNumero, posicion;
        String entrada, entrada2, entrada3, entrada4;
        
        JTextArea areaSalida = new JTextArea();
        areaSalida.setText("#############################\n");
        areaSalida.append("                      Java Tips\n");
        areaSalida.append("#############################\n\n");
        
        entrada = JOptionPane.showInputDialog("Introduce el tamaño del Arreglo");
        introducido = Integer.parseInt(entrada);
        arreglo = new int [introducido];
        
        areaSalida.append("El tamaño del Arreglo es de:\n " + entrada);
        areaSalida.append("\n\nElementos Originales del Arreglo\n");
        for (elemento = 0; elemento < introducido; elemento++)
        {
            entrada2 = JOptionPane.showInputDialog("Introduce el elemento " + (elemento + 1) + " para el Arreglo");
            arreglo[elemento] = Integer.parseInt(entrada2);
            areaSalida.append("  " + arreglo[elemento] + ",");
        }
        
        entrada3 = JOptionPane.showInputDialog("Introduce el Nuevo Elemento");
        NuevoNumero = Integer.parseInt(entrada3);
        
        entrada4 = JOptionPane.showInputDialog("Introduce la Posicion del Elemento en el Arreglo");
        posicion = Integer.parseInt(entrada4);
        
        areaSalida.append("\n\nArreglo con el Elemento Insertado\n");
        if( NuevoNumero !=  arreglo[posicion] )
        {
            arreglo[posicion] = NuevoNumero;
            for (elemento = 0; elemento < introducido; elemento++)
            {
                areaSalida.append("  " + arreglo[elemento] + ",");
            }
        }
        else
        {
            JOptionPane.showMessageDialog(null, "El elemento ya existe en el Arreglo, se insertara al final");
            for (elemento = 0; elemento < introducido; elemento++)
            {
                areaSalida.append("  " + arreglo[elemento] + ",");
            }
            areaSalida.append("  " + arreglo[posicion] + ",");
        }
        
        JOptionPane.showMessageDialog( null, areaSalida, "Java Tips", JOptionPane.INFORMATION_MESSAGE);  
    }    
}
Output:
 

Suma de dos arreglos y almacenarlos en un tercer arreglo

// Suma de Arreglo1 + Arreglo2 da como resultado un tercer Arreglo3
import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class Arreglo_Unidimensional
{
    public static void main (String args[])
    {
        int elemento, N;    // Declaramos dos variables de tipo int
        int arreglo1[];     // Declaramos el arreglo1[]        
        int arreglo2[];     // Declaramos el arreglo2[]  
        int arreglo3[];     // Declaramos el arreglo3[]  
        String entrada, entrada1, entrada2;
        
        // Creamos un objeto JTextArea con nombre areaSalida y colocamos texto en el objeto con setText
        JTextArea areaSalida = new JTextArea();
        areaSalida.setText("                Suma de Arreglos\n\n");
        
        // Pide al usuario que ingrese el tamaño de elemento para el arreglo1 y arreglo2
        entrada = JOptionPane.showInputDialog("Introduce el tamaño de elementos para Arreglo1 y Arreglo2");
        // Convierte el dato introducido de tipo String a tipo int en la variable N
        N = Integer.parseInt( entrada );
        // Creamos los tres arreglos cada uno con elementos de N ingresado por el usuario
        arreglo1 = new int [ N ];
        arreglo2 = new int [ N ];
        arreglo3 = new int [ N ];
        
        // Mostramos texto en el objeto areaSalida de JTextArea
        areaSalida.append("El tamaño de cada Arreglo es de:\n" + N);
        areaSalida.append("\nElementos del Arreglo1 son:\n");
        // Ciclo que pide en cada pasada los elementos del arreglo1
        for (elemento = 0; elemento < N; elemento++)
        {
        // Pide al usuario que ingrese en cada pasada los elementos del arreglo1
        entrada1 = JOptionPane.showInputDialog("Introduzca el elemento " + (elemento + 1) + " del Arreglo 1");
        // Cada elemento introducido lo convertimos a tipo int en el arreglo1[]
        arreglo1[elemento] = Integer.parseInt( entrada1 );
        // En cada pasada se iran agregando los elementos al objeto areaSalida
        areaSalida.append(" " + arreglo1[elemento] + ",");
        }
        // Mostramos texto en el objeto aresaSalida de JTextArea
        areaSalida.append("\nElementos del Arreglo2 son:\n");
        // Ciclo que pide en cada pasada los elementos del arreglo2
        for (elemento = 0; elemento < N; elemento++)
        {
        // Pide al usuario que ingrese en cada pasada los elementos del arreglo2
        entrada2 = JOptionPane.showInputDialog("Introduzca el elemento " + (elemento + 1) + " del Arreglo 2");
        // Cada elemento introducido lo convertimos a tipo int en el arreglo2[]
        arreglo2[elemento]  = Integer.parseInt( entrada2 );
        // En cada pasada se iran agregando los elementos al objeto areaSalida
        areaSalida.append(" " + arreglo2[elemento] + ",");
        }        
        // Mostramos texto en el objeto areaSalida
        areaSalida.append("\nSuma del Arreglo1 + Arreglo2 = Arreglo3\n\n");
        // Ciclo que suma los elementos del arreglo1 y arreglo2 para dar resultado a un arreglo3
        // Y en cada pasada se va mostrando en el objeto areaSalida los elementos del arreglo3
        for (elemento = 0; elemento < N; elemento++)
        {
            arreglo3[elemento]= arreglo1[elemento] + arreglo2[elemento];
            areaSalida.append(" " + arreglo1[elemento] + " + " + arreglo2[elemento] + " = " + arreglo3[elemento] + "\n");    
        }
        // Mostramos los resultados en pantalla
        JOptionPane.showMessageDialog(null, areaSalida);
    }
}
Output:

miércoles, 24 de octubre de 2012

Arreglo Unidimensional

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class ArregloUnidimensional
{
    public static void main ( String args[] )
    {
        int arreglo1[];     // Declaramos arreglo1[]
        int arreglo2[];     // Declaramos arreglo2[]
        int introducido;    // Variable que controla el tamaño del arreglo
        int elemento;       // Varibale que nos servira para contar
        String entrada1, entrada2;

        JTextArea areaSalida = new JTextArea();
        areaSalida.setText( "                     Arreglo Unidimensional\n");

        entrada1 = JOptionPane.showInputDialog( "Introduce el Tamaño del Arreglo ");
        introducido = Integer.parseInt( entrada1 );
        arreglo1 = new int [ introducido ];
        arreglo2 = new int [ introducido ];

        for(elemento = 0; elemento < introducido; elemento++)
        {
            entrada2 = JOptionPane.showInputDialog(  "Introduce el elemento " + ( elemento + 1 ) + " para el Arreglo" );
            arreglo2[introducido-(elemento+1)] = arreglo1[elemento] = Integer.parseInt(entrada2);
        }

        areaSalida.append("\nEl tamaño del Arreglo es de:\n  " + entrada1 + "\nElementos del Arreglo A introducidos son: \n");
 for(elemento = 0; elemento < introducido; elemento++)
        {
            areaSalida.append("  " + arreglo1[elemento] + ",");
        }

 //Imprimir en orden inverso
        areaSalida.append("\nElementos del Arreglo B (Orden Inverso) son: \n");
 for(elemento = 0; elemento < introducido; elemento++)
        {
            areaSalida.append("  " + arreglo2[elemento] + ",");
        }
        JOptionPane.showMessageDialog( null, areaSalida, "Arreglo Unidimensional", JOptionPane.INFORMATION_MESSAGE);
    }
}

martes, 23 de octubre de 2012

Ejemplo Arreglo

import javax.swing.JOptionPane;
import javax.swing.JTextArea;
import javax.swing.JScrollPane;

public class EjemploArreglo
{
    public static void main (String args[])
    {
        //Creamos un objeto JTextArea con nombre llamado Area y agrega los componentes al frame
        JTextArea Area = new JTextArea(15,40);
        JScrollPane ScrollPane;
        
        // Creamos dos variables de tipo String Ns para tamaño y ValorS para elementos
        String Ns, valorS; 
        int i, j, N, A[]; // Variables de tipo int mas la declaracion del arreglo A[]
        
        // Pide al usuario que ingrese el tamaño del arreglo
        Ns = JOptionPane.showInputDialog("De que tamaño desea el arreglo");
        N = Integer.parseInt(Ns); // Convertimos el dato ingresado (Ns) a tipo int 
        A = new int [N];          // Creamos el arreglo con elementos N
        
        // Ciclo que controlara las pasadas dependiendo del tamaño (N) del arreglo
        for (i=0; i<N; i++) 
        {
            // En cada pasada pedira que el usuario teclee los elementos del arreglo
            valorS = JOptionPane.showInputDialog("Introduzca el elemento" + (i+1) + " para el Arreglo");
            A[i] = Integer.parseInt(valorS); // En cada pasada se almacenara al Arreglo A[i]
        }
        // Mostramos texto con el objeto Area
        Area.setText("Los elementos del arreglo son;\n\n");
        // Ciclo que mostrara en pantalla los elementos introducidos del arreglo 
        for(i=0; i<N; i++)
            
        Area.append("A[ "+ (i+1) + "]  = " + A[i] + "\n");
        ScrollPane = new JScrollPane(Area);
        
        // Mostramos la salida en pantalla
        JOptionPane.showMessageDialog(null, ScrollPane, "Ejemplo de Arreglo", JOptionPane.INFORMATION_MESSAGE);
        
        System.exit(0);  // Terminar el programa
    }  
}

domingo, 21 de octubre de 2012

Usando cuadros de diálogo para Entrada/Salida con JOptionPane

En los anteriores posts vimos un par de programas que muestran la salida en la ventana de comandos. Ahora veremos un par de programas de como mostrar la salida o entrada utilizando una ventana o cuadro de dialogo. Generalmente muchos programas ofrecen una interfaz gráfica de usuario (GUI) o los cuadros de dialogo (también llamados diálogos) que son ventanas en las que los programas muestran mensajes importantes a los usuarios del programa. Java contiene una clase llamada JOptionPane que nos permite producir cuadros de dialogo previamente empaquetados, los cuales permiten a los programas mostrar ventanas que contengan mensajes. A estas ventanas se les conoce como diálogos de mensaje. Un cuadro de dialogo es un objeto de interfaz gráfica de usuario (GUI), pero ¿cual es la diferencia entre mostrar la salida en consola y en interfaz gráfica?. En consola solo podemos mostrar texto y en una interfaz gráfica de usuario podemos mostrar no solo texto, si no también varios elementos gráficos como botones, barras, casillas de verificación, menús, cuadros de texto e imágenes.

El método showMessageDialog es un método especial de la clase JOptionPane, el cual se conoce como método static. Generalmente los métodos estatic se llaman utilizando el nombre de la clase, seguido de un punto ( . ) y el nombre del método, tal como se muestra a continuación.

Proceso de llamar un método estatic.

Uno de los puntos fuertes de Java es su extenso conjunto de clases predefinidas que los programadores pueden usar, en vez de tener que "reinventar todo". Las numerosas clases predefinidas de Java se agrupan en clases relacionadas, conocidas como paquetes. Un paquete es una colección de clases con nombre, estos se conocen colectivamente como biblioteca de clases, o la Interfaz de Programación de Aplicaciones (API) de Java. Estos paquetes (API) de Java se dividen en básicos y opcionales. Los nombres de la mayoría de los paquetes del API de Java comienzan, ya sea con "java" (paquetes básicos) o "javax" (paquetes opcionales). Muchos de estos se incluyen como parte del Kit de desarrollo de software para Java.

En este post mostraremos un pequeño programa modificado del anterior post llamado PrimerPrograma para que el texto que muestra en consola, ahora lo muestre en un cuadro de dialogo. Este programa muestra el objeto String “"¡Bienvenido a la programacion en Java!\n\n http://delfirosales.blogspot.com” en un dialogo de mensaje (o cuadro de dialogo).
//usando JOptionPane para mostrar la salida en un cuadro de dialogo.

import javax.swing.JOptionPane;

public class PrimerPrograma {
 
 public static void main ( String args [] )
 {
  JOptionPane.showMessageDialog( null, "¡Bienvenido a la programacion en Java!\n
  \n http://delfirosales.blogspot.com" );
 }
}
En este ejemplo utilizamos la clase predefinida de Java JOptionPane, la cual se encuentra en el paquete javax.swing.

import javax.swing.JOptionPane; //Este programa usa JOptionPane

La declaración import es una declaración que se utiliza para identificar las clases predefinidas que se utilizan en nuestro programa en Java. Esta declaración ayuda al compilador a localizar las clases que deseamos utilizar. Importante saber es que todas las declaraciones import deben de aparecer antes de las declaración de la clase, si lo ponemos dentro o después de la declaración de una clase, es un error de sintaxis . Por cada nueva clase que utilizamos del API de Java debemos indicar el paquete en el que se encuentra esa clase.

Ahora entonces, la linea import javax.swing.JOptionPane; indica al compilador que en nuestro programa utilizaremos la clase JOptionPane del paquete javax.swing.

JOptionPane.showMessageDialog( null, "¡Bienvenido a la programacion en Java!\n\n http://delfirosales.blogspot.com" );

Las lineas anteriores contenidas en el método main, llaman al método showMessageDialog de la clase JOptionPane para mostrar un cuadro de dialogo que contiene un mensaje. Este método requiere de dos argumentos y cuando un método requiere varios argumentos, estos se separan con comas ( , ). Por ahora el primer argumento sera la palabra clave null y el segundo argumento "¡Bienvenido a la programacion en Java!\n\n http://delfirosales.blogspot.com" es la cadena a mostrar en el cuadro de dialogo. El primer argumento ayuda a la aplicación en Java a determinar en donde se va a colocar el cuadro de dialogo, cuando el primero argumento es null, el cuadro de dialogo aparece en el centro de la pantalla de la computadora, tal como se muestra en la siguiente imagen.

Usando JOptionPane para mostrar la salida de la aplicación PrimerPrograma.

La barra de titulo del cuadro de dialogo contiene la cadena Mensaje, esto para indicar que este cuadro de dialogo va a presentar un mensaje al usuario. El cuadro de dialogo incluye un botón Aceptar (OK), que el usuario puede oprimir para descartarlo (ocultarlo).
Cuadro de Dialogo de Mensaje.

El paquete javax.swing contiene muchas clases que ayudan a los programadores en Java a crear Interfaces Gráficas de Usuario (GUIs) para las aplicaciones. Los componentes de la GUI facilitan la entrada de datos al usuario del programa y la presentación de los datos de salida. Tal como lo comentamos anteriormente en las GUIs (interfaz gráfica de usuario) podemos mostrar no solo texto, si no también elementos gráficos como botones, casillas de verificación, menús, cuadros de texto e imágenes. Todos estos forman parte de la GUI y permiten interactuar con el programa.

Introducción de Texto en un Cuadro de Dialogo (Diálogos de Entrada)

Hay varios tipos de cuadros de dialogo de la clase JOptionPane. Consideremos el anterior uno de ellos, el cuadro de dialogo de salida, es el que genera el método showMessageDialog. Ahora toca mostrar el cuadro de dialogo de entrada, el cual permite al usuario introducir datos en el programa. El cuadro de dialogo de entrada muestra un mensaje de confirmación y muestran un icono de signo de pregunta esperando la entrada del usuario. Al hacer clic en el botón Aceptar se procede el valor introducido. El siguiente programa utiliza otro cuadro de dialogo predefinido de la clase JoptionPane, que permite al usuario introducir un valor para utilizarlo en el programa. En este caso pide el nombre del usuario y responde con un dialogo de mensaje que contiene un saludo y el nombre que el usuario haya introducido.
//Entrada básica con un cuadro de dialogo.
import javax.swing.JOptionPane;

public class EjemploGUI
{
 public static void main ( String args[] )
 {
  // Pide al usuario que escriba su nombre
  String nombre = JOptionPane.showInputDialog( "Cual es su nombre?" );
  
  // Crea el mensaje
  String mensaje = String.format( "Bienvenido, %s, a la programación en Java!", nombre );
  
  // Muestra el mensaje para dar la bienvenida al usaurio por su nombre
  JOptionPane.showMessageDialog( null, mensaje, JOptionPane.INFORMATION_MESSAGE );
 }
}
Cuadro de dialogo de Entrada, pide al usuario que escriba su nombre.

Muestra el mensaje para dar la bienvenida al usuario por su nombre.

String nombre = JOptionPane.showInputDialog( "Cual es su nombre?" );

Las líneas anteriores utilizan el método showInputDialog de JOptionPane para mostrar el dialogo de entrada, el cual contiene un indicador y un campo (conocido como campo de texto) en la cual el usuario puede introducir texto. El argumento de showInputDialog es el indicador que muestra lo que el usuario debe escribir. El usuario escribe caracteres en el campo de texto, a continuación, hace clic en el botón Aceptar o presionar la tecla intro para devolver la cadena de caracteres (objeto String) al programa. El método showInputDialog devuelve un objeto String que contiene los caracteres tecleados por el usuario. Almacenamos el objeto String en la variable nombre. Si se oprime el botón Cancelar en el cuadro de dialogo, el método devuelve null y el programa muestra la palabra clave “null” como el nombre.

String mensaje = String.format( "Bienvenido, %s, a la programación en Java!", nombre );

La linea anterior es una instrucción que utiliza el método static String llamado format para devolver un objeto String que contiene un saludo con el nombre de usuario. El método format es similar al metodo System.out.printf, excepto que format devuelve el objeto String con formato, en vez de mostrarlo en una ventana de comandos.

JOptionPane.showMessageDialog( null, mensaje );

La línea anterior muestra el saludo en un cuadro de dialogo del mensaje.

Iconos o constantes de dialogo utilizados por JoptionPane

La clase JoptionPane proporciona varias versiones sobrecargadas de los métodos showInputDialog y showMessageDialog, así como métodos que muestran otros tipos de diálogos. Los Iconos o constantes que representan los tipos de diálogos de mensajes se muestran en la siguiente figura.

Iconos o contantes static de la clase JoptionPane para diálogos de mensaje.

Todos los tipos de dialogo de mensaje, excepto PLAIN_MESSAGE, muestran un icono a la izquierda del mensaje. Estos iconos proporcionan una indicación visual de la importancia del mensaje para el usuario. Por ejemplo el icono QUESTION_MESSAGE es el icono predeterminado para un cuadro de dialogo de entrada.

Referencias:
Class JOptionPane
Java How to Program (early objects) (9th Edition) (Deitel)
Java Programming, Joyce Farrell.
Introduction to Java Programming, Comprehensive (8th Edition)

jueves, 18 de octubre de 2012

Multiplication Table

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class TablaMultiplicar
{
     public static void main(String args[])
     {
         String Num1; // Numero de la tabla introducido por el usuario
         int A;       // Valor del numero de la tabla a multiplicar
         
         // Creamos un objeto JTextArea con nombre areaSalida y colocamos texto con setText
         JTextArea TextoSalida = new JTextArea();
         TextoSalida.setText("El numero introducido es: ");
         
         // Pide al usuario que introduzca el numero a multiplicar
         Num1 = JOptionPane.showInputDialog("Introduce el Numero de la Tabla a Multiplicar");
         // Convertimos el numero introducido a int con la variable A
         A = Integer.parseInt( Num1 );
         
         // Ciclo que itera 10 veces
         for ( int x=1;x<11;x++ )
         {
             // Concatemos texto incluyendo la operacion de multiplicacion del numero introducido
             TextoSalida.append("\n" + A  + " x " + x + " = " + ( x*A ));
         }
         
         // Mostramos los resultados en pantalla         
         JOptionPane.showMessageDialog( null, TextoSalida, "Obtencion de la Tabla de Multiplicar", JOptionPane.PLAIN_MESSAGE);
        }
}

Another Application: Adding Integers

Aplicacion1.java
// El programa usa la clase JOptionPane
import javax.swing.JOptionPane;

public class Aplicacion1
{
    public static void main(String args[])
    {
        String Num1; // Variable para primera cadena introducida por el usuario
        String Num2; // Variable para segunda cadena introducida por el usuario

        int A;      //Declaramos una variable int llamada A que sera el primer numero introducido
        int B;      // Segunda variable que sera el segundo numero
        int Mayor;  // variable con parametro mayor

        Num1 = JOptionPane.showInputDialog( "Introduce el Primer Numero" ); //pide al usuario introducir el primer numero
        Num2 = JOptionPane.showInputDialog( "Introduce el Segundo Numero" ); //pide el segundo numero
        
        //Convierte los numeros de tipo string a tipo int
        A = Integer.parseInt( Num1 );
        B = Integer.parseInt( Num2 );

        if ( A > B ) //Si la condicion se cumple entonces el numero mayor es = A
            Mayor = A;
        else        // Si la condicion no se cumple entonces el numero mayor es = B
            Mayor = B;
           
        //Imprimimos en pantalla los resultados con la clase JOptionPane y el metodo showMessageDialog mas los argumentos
        JOptionPane.showMessageDialog( null, " El mayor de " + A + ", " + B + " es: " +  Mayor , "Obtención del Numero Mayor", JOptionPane.PLAIN_MESSAGE);
    }
}
Aplicacion2.java
import javax.swing.JOptionPane;

public class Aplicacion2
{
    public static void main(String args[])
    {
        // Declaramos las variables para las tres cadenas que introduzca el usuario
        String Num1;
        String Num2;
        String Num3;

        int A;  // Primero Numero
        int B;  // Segundo Numero
        int C;  // Tercer Numero
        int Mayor; // Parametro para elegir el numero mayor
        
        // Pedir la entrada de datos, del primer, segundo y tercer numero
        Num1 = JOptionPane.showInputDialog( "Introduce el Primer Numero" );
        Num2 = JOptionPane.showInputDialog( "Introduce el Segundo Numero" );
        Num3 = JOptionPane.showInputDialog( "Introduce el Tercer Numero" );
        
        // Convertimos los numero introducidos de tipo String a tipo int 
        A = Integer.parseInt( Num1 );
        B = Integer.parseInt( Num2 );
        C = Integer.parseInt( Num3 );
        
        // Realizamos la condicion de los primeros dos numeros (A) y (B)
        if ( A > B ) // Si el primero numero (A) introducido, es mayor que el segundo numero (B) entonces A = Mayor
            Mayor = A;
        else // Si la condicion anterior no se cumple, entonces B = Mayor
            Mayor = B;
        if ( C > Mayor ) // De la lo anterior se compara el Mayor con el tercer numero (C) y si esta condicion
            Mayor = C;   // se cumple entonces C = Mayor y si no se cumple se descarta esta condicion.
        
        // Por ultimo, imprimimos los resultados en pantalla y listo
        JOptionPane.showMessageDialog( null, " El mayor de " + A + ", " + B + " y " +  C + " es: " +  Mayor , "Obtención del Numero Mayor", JOptionPane.PLAIN_MESSAGE);
    }
}

miércoles, 17 de octubre de 2012

Your First Program in Java

Bienvenido.java
public class Bienvenido
{
    // El metodo main empieza la ejecuion de nuestra aplicacion en Java
    public static void main (String args[])
    {
        // Imprimimos texto en pantalla con el objeto de salida estandar "System.out"
        System.out.println("Bienvenido a la Programacón en Java!");

    }
   
}
Bienvenido2.java
import javax.swing.JOptionPane;

public class Bienvenido2
{
    // El metodo main empieza la ejecuion de nuestra aplicacion en Java
    public static void main (String args[])
    {
        // Mostramos la salida en un cuadro de dialogo utilizando la clase JOptionPane
        JOptionPane.showMessageDialog(null, "Bienvenido a la Programacón en Java!");
        // "JOptionPane" es una clase que nos permite producir cuadros de dialgo
        // "showMessageDialog" es un metodo especial de la clase JOptionPane
    }
}

Entradas populares