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")));

Add & remove ImageIcon to JLabel

Java adding ImageIcon to JLabel

ImageIcon image;
image = new ImageIcon(C:/Users/Delfi/Desktop/data4.png);
jlabel1.setIcon(image);

How to use getClass().getResource() method

ImageIcon image;
image = new ImageIcon(getClass().getResource("/Imagenes/data4.png"));
jlabel1.setIcon(image);

Remove an icon on a JLabel

jlabel1.setIcon(null) 
in the event handler that handles the button click, if you're using Swing.

lunes, 14 de abril de 2014

Labels alineadas y formateadas HTML + CSS

En ocasiones, es más útil mostrar todos los campos del formulario con su <label> alineada a la izquierda y el campo del formulario a la derecha de cada <label>, como muestra la siguiente imagen:

Mostrando las etiquetas label alineadas con los campos del formulario

Para mostrar un formulario tal y como aparece en la imagen anterior no es necesario crear una tabla y controlar la anchura de sus columnas para conseguir una alineación perfecta. Sin embargo, sí que es necesario añadir un nuevo elemento (por ejemplo un <div>) que encierre a cada uno de los campos del formulario (<label> y <input>).

El código HTML del formulario anterior se añaden los elementos <div>:

<form>
  <fieldset>
  <legend>Alta en el servicio</legend>

  <div>
    <label for="nombre">Nombre</label>
    <input type="text" id="nombre" />
  </div>

  <div>
    <label for="apellidos">Apellidos</label>
    <input type="text" id="apellidos" size="35" />
  </div>
  ...
</fieldset>
</form>

Y en el código CSS se añaden las reglas necesarias para alinear los campos del formulario:

div {
  margin: .4em 0;
}
div label {
  width: 25%;
  float: left;
}

get the text of the selected option in PHP - MySQL

Example

<select name="pais">
<option value="USA">USA</option>
<option value="Canada">Canada</option>
</select>

< ?
$pais = strip_tags($_POST['pais']);
? >

Reset MySQL Autoincrement Column

Directly Reset Autoincrement Value
Alter table syntax provides a way to reset autoincrement column. Take a look at following example.

ALTER TABLE `table_name` AUTO_INCREMENT=1

Example

ALTER TABLE `id_estudiantes` AUTO_INCREMENT=1

sábado, 21 de diciembre de 2013

Get File size in bytes

Obtener el tamaño de un archivo en bytes, KB y MB utilizando el método length de la clase File de Java.
import java.io.*;
 
public class GetFileSizeInByetes {
 
  public static void main(String[] args) {
   
    //create file object
    File file = new File("C:\Users\Delfi\Desktop\Aplicacion.java");
   
    /*
     * To get the size of a file, use
     * long length() method of Java File class.
     *
     * This method returns size of a particular file in bytes. It returns 0L
     * if file does not exists, and unspecified if file is a directory.
     *
     */
   
     long fileSize = file.length();
   
     System.out.println("File size in bytes is: " + fileSize);
     System.out.println("File size in KB is : " + (double)fileSize/1024);
     System.out.println("File size in MB is :" + (double)fileSize/(1024*1024));
  }
}
Output:
File size in bytes is: 492480
File size in KB is : 480.9375
File size in MB is :0.46966552734375

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:

jueves, 18 de abril de 2013

Archivos de Texto: Vocales y Consonantes

Diseñar un programa que solicite desde el teclado el nombre del archivo de texto cuyo contenido debera procesar de la siguiente manera:crear un archivo de texto con todas las vocales que contenga y crear un archivo de texto con todas las consonantes que contenga. exhibir los archivos resultantes.
import java.io.*;

public class Vocal_Consonantes
{
    public static void main(String[] args) throws IOException{

        FileReader lee=null;
        FileOutputStream escribe=null;
        
        try
        {
            lee=new FileReader("texto.txt");
            int dato= lee.read();
            
            while(dato!=-1)
            {
                System.out.print((char)dato);
                dato=lee.read();
                
                // Devuelve una copia de esta cadena con todos los caracteres en mayúsculas convertidos en minúsculas.
                if((Character.toLowerCase(dato)=='a') || (Character.toLowerCase(dato)=='e') || (Character.toLowerCase(dato)=='i') || (Character.toLowerCase(dato)=='o') || (Character.toLowerCase(dato)=='u'))
                {
                    escribe = new FileOutputStream("vocales.txt",true);
                    DataOutputStream din = new DataOutputStream(escribe);
                    din.writeChar(dato);
                }
                else
                {
                    escribe = new FileOutputStream("consonantes.txt",true);
                    DataOutputStream din = new DataOutputStream(escribe);
                    din.writeChar(dato);
                }
            }
            lee.close();
            escribe.close();
        }
        finally
        {
            System.out.println("\n\nArchivos Creados...");
        }
        
        System.out.println("Exibiendo archivo vocales.txt\n");
        FileReader vocales = null;
        try
        {
            vocales = new FileReader("vocales.txt");
            int dato2 = 0;
            while(dato2 != -1)
            {
                dato2 = vocales.read();
                System.out.print((char)dato2);
            }
            vocales.close();
        }
        finally
        {
            System.out.println("\n\nArchivo leido.");
        }
        
        System.out.println("Exibiendo archivo consonantes.txt.\n");
        FileReader consonantes = null;
        try
        {
            consonantes = new FileReader("consonantes.txt");
            int dato3 = 0;
            while(dato3 != -1)
            {
                dato3 = consonantes.read();
                System.out.print((char)dato3);
            }
            consonantes.close();
        }catch(IOException e){}
        finally
        {
            System.out.println("\n\nArchivo leido.\nfin");
        }
    }
}
Output:
PrUeBa dE TexTO

Archivos Creados...
Exibiendo archivo vocales.txt

U e a E e O

Archivo leido.
Exibiendo archivo consonantes.txt.

r B d T x T

Archivo leido.
fin

jueves, 21 de marzo de 2013

Operadores en Java

Operadores Aritméticos: Los habituales

Suma + .
Resta - .
Multiplicación * .
División / .
Resto de la División % .

  • ! Negacion Logica
  • + Suma o Concatenacion de cadenas
  • -    resta
  • < menor que
  • <= menor o igual que
  • > mayor que
  • >= mayor o igual que
  • == es igual a
  • != no es igual a
  • & AND a nivel de bit
  • AND logico booleano
  • ^ OR excluyente a nivel de bits
  • OR excluyente lógico booleano
  • | OR incluyente a nivel de bits
  • OR incluyente lógico booleano
  • && AND condicional
  • || OR condicional
  • ?: condicional
  • = asignación
  • +=        asignación, suma
  • -= asignación, resta
  • *= asignación, multiplicación
  • /= asignación, división
  • %= asignación, residuo
  • &= asignación, AND a nivel de bits
  • ^= asignación, OR excluyente a nivel de bits
  • |= asignación, OR incluyente a nivel de bits
  • <<=      asignación, desplazamiento a la izquierda a nivel de bits
  • >>= asignación, desplazamiento a la derecha a nivel de bits con signo
  • >>>= asignación, desplazamiento a la derecha a nivel de bits sin signo

miércoles, 20 de marzo de 2013

Contar palabras que contiene un Archivo de Texto

Diseñar un programa que solicite desde el teclado el nombre del archivo de texto el cual deberá contar todas las palabras que contiene el archivo.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

class Cont_Palabras
{
    public static void main(String [] arg)
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el nombre del archivo de texto: ");
        String archivo = teclado.next();
        
        try 
        {            
            BufferedReader lee = new BufferedReader(new FileReader(archivo));
            
            String linea;
            int i, a = 0;            
            while((linea = lee.readLine()) != null)
            {
                System.out.println(linea);
                for(i=0; i < linea.length(); i++)
                {
                    if(i==0)
                    {
                        if(linea.charAt(i)!=' ')
                            a++;
                    }
                    else
                    {
                        if(linea.charAt(i-1)==' ')
                            if(linea.charAt(i)!=' ')
                                a++;
                    }
                }
            }
            System.out.println("\nEL archivo contiene "+a+" palabras");
            lee.close();
        }
        catch(IOException a)
        {
            System.out.println(a);
        }
    }
}
Output:

Escribe el nombre del archivo de texto: vida.txt
Cuando me hallaba en clase de geometría me decían que solo había tres dimensiones y siempre lo acepte. Estaban equivocados. Hay mas. Nuestro mundo, en el que ahora vivimos, es tridimensional, pero el próximo no lo es. Por eso es tan difícil contárselo.

EL archivo contiene 43 palabras

Comparar dos Archivos Binarios byte por byte

Diseñar una aplicacion que solicite desde teclado el nombre de dos archivo binarios y cuyo contenidos deberá comparar byte por byte.
import java.io.DataInputStream;
import java.io.IOException;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.util.Scanner;

public class Compara_BytexByte
{
    public static void main(String[] args) throws IOException
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el primer archivo binario a comparar: ");
        String bin1 = teclado.next();
        System.out.print("Escribe el segundo archivo binario a comparar: ");
        String bin2 = teclado.next();

        try 
        {
            DataInputStream x = new DataInputStream(new BufferedInputStream(new FileInputStream(bin1)));
            DataInputStream y = new DataInputStream(new BufferedInputStream(new FileInputStream(bin2)));            
            
            int dato1=0, dato2=0;
            int cont1=0, cont2=0;            
            while(dato1 !=-1 || dato2 != -1)
            {
              dato1=x.read();
              dato2=y.read();              
              if(dato1!=-1)
              {  
                  cont1++;  
              }  
              if(dato2!=-1)
              {
                  cont2++;
              }
            }
            System.out.println("\nEl primer archivo binario tiene "+cont1+" Bytes");  
            System.out.println("El segundo archivo binario tiene "+cont2+" Bytes");
            if(cont1 == cont2)
            {
                System.out.println("Los archivos comparardos son iguales");
            }
            else
            {
                System.out.println("Los archivos comparados son diferentes");
            }
            x.close();
            y.close();
        }catch(IOException e)
        {
            System.out.println("Error:");
        }
    }
}
Output:
Escribe el primer archivo binario a comparar: databin.bin
Escribe el segundo archivo binario a comparar: datos.bin

El primer archivo binario tiene 120 Bytes
El segundo archivo binario tiene 118 Bytes
Los archivos comparados son diferentes

Exhibir la linea mas larga del contenido de un Archivo de Texto

Diseñar una aplicación de consola en Java, el cual solicite desde el teclado un archivo de texto del cual deberá de exhibir solo la linea de mayor magnitud y el total de caracteres que contiene la linea.
import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.util.Scanner;

public class Linea_Mayor
{
    public static void main(String[] args) throws IOException
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el archivo de texto a procesar: ");
        String archivo = teclado.next();
        try 
        {
            BufferedReader lee1 =new BufferedReader(new FileReader(archivo));
            
            String linea = "", maslarga = "";
            System.out.println("Comprobando archivo...");
            int i = 0;
            while((linea = lee1.readLine())!=null)
            {
                i++;
                System.out.println(linea);
                if (linea.length() > maslarga.length())
                {
                    maslarga = linea;
                }
            }
            System.out.println("\nEl Archivo tiene "+i+" Lineas");
            System.out.println("La linea mas larga es:\n" + maslarga);
            System.out.println("Y tiene " + maslarga.length() + " caracteres");
            lee1.close();
        }catch(IOException e)
        {
            System.out.println("Ha ocurrido un error:");
        }
        finally
        {
          System.out.println("fin...");
        }
    }
}
Output:
Escribe el archivo de texto a procesar: texto.txt
Comprobando archivo...
El que esta al final del camino,
Conoce el principio y conoce el final,
El que esta al principio, solo ha
Andado unos pocos pasos, el resto le
Es desconocido.

El Archivo tiene 5 Lineas
La linea mas larga es:
Conoce el principio y conoce el final,
Y tiene 38 caracteres
fin...

Comparar dos Archivos de Texto linea por linea

Diseñar una aplicación en java que solicite desde el teclado, el nombre de dos archivo de texto y cuyo contenidos deberá comparar linea por linea.
import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.util.Scanner;

public class Compara_LineaxLinea
{
    public static void main(String[] args) throws IOException
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el primer archivo de texto a comparar: ");
        String archivo1 = teclado.next();
        System.out.print("Escribe el segundo archivo de texto a comparar: ");
        String archivo2 = teclado.next();
        
        try 
        {           
            BufferedReader lee1 =new BufferedReader(new FileReader(archivo1));
            BufferedReader lee2 =new BufferedReader(new FileReader(archivo2));
            
            String linea1="", linea2 = "";
            System.out.println("Comparando Archivos...");
            int cont1=0, cont2=0;
            
            while(linea1!=null || linea2!=null)
            {
              linea1=lee1.readLine();
              linea2=lee2.readLine();
              
              if(linea1!=null)
              {
                  cont1++;  
              }  
              if(linea2!=null)
              {
                  cont2++;
              }
            }
            System.out.println("Fin de comparacion de los archivos...\n");  
            System.out.println("El primer archivo tiene "+cont1+" Lineas");  
            System.out.println("El segundo archivo tiene "+cont2+" Lineas");
            if(cont1 == cont2)
            {
                System.out.println("Los archivos comparardos son iguales");
            }
            else
            {
                System.out.println("Los archivos comparados son diferentes");
            }
            lee1.close();
            lee2.close();
        }catch(IOException e)
        {
            System.out.println("Ha ocurrido un error:");
        }
        finally
        {
          System.out.println("fin...");
        }
    }
}

Output:
Escribe el primer archivo de texto a comparar: aprobados.txt
Escribe el segundo archivo de texto a comparar: reprobados.txt
Comparando Archivos...
Fin de comparacion de los archivos...

El primer archivo tiene 6 Lineas
El segundo archivo tiene 4 Lineas
Los archivos comparados son diferentes
fin...

lunes, 18 de marzo de 2013

Desde un Archivo Binario de objetos obtener un Archivo de Texto

Desde un archivo Binario de objetos obtener un archivo de texto con el siguiente formato: nombre\n edad\n sexo\n y exhibir el archivo de texto.
import java.io.ObjectInputStream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.EOFException;
import java.io.Serializable;

class Persona implements Serializable
{
 String nomb;
 int ed;
 char sexo;
}

public class Bin_Text {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        
        ObjectInputStream lee=null;
        
        String nomb="";
        int ed=0;
        char sexo =0;
        
        try
        {
         lee=new ObjectInputStream(new BufferedInputStream(new FileInputStream("persona.bin")));
         FileOutputStream e = new FileOutputStream("NuevoArchivo.txt");
         DataOutputStream escribe = new DataOutputStream(e);

         for (int i=0;i < 5 ; i++)
         {
             nomb=lee.readUTF();
             ed=lee.readInt();
             sexo=lee.readChar();
             
             escribe.writeUTF(nomb);
             escribe.writeInt(ed);
             escribe.writeChar(sexo);
             
         }escribe.close();
        }
        finally
        {
            System.out.println("Archivo creado...");
            lee.close();
        }
        
        System.out.println("Leyendo archivo creado...");
        System.out.println("\n   Nombre\t\tEdad\tSexo");
        DataInputStream lee2 =null;
        try
        {
            lee2 =new DataInputStream(new BufferedInputStream(new FileInputStream("NuevoArchivo.txt")));
            while(true)
            {
                nomb=lee2.readUTF();
                ed=lee2.readInt();
                sexo=lee2.readChar();
                System.out.printf("%s\t%d\t%c\n",nomb,ed,sexo);
            }
        }
        catch (EOFException e)
        {
            System.out.println("\nSe alcanzo el fin del archivo...");
        }
        finally
        {
            lee2.close();
        }
    }
}
Output:
Archivo creado...
Leyendo archivo creado...

     Nombre                      Edad Sexo
0  Jose Manuel Sanchez  23    M
1  Jose Manuel Sanchez 23  M
2  Jose Manuel Sanchez 23  M
3  Jose Manuel Sanchez 23  M
4  Jose Manuel Sanchez 23  M

Se alcanzo el fin del archivo...

Caracteres y Cadenas

Un programa puede contener literales de carácter. Una literal de carácter es un valor entero represen-tado como un carácter entre comillas simples. Por ejemplo, ‘z’representa el valor entero de z, y ‘\n’representa el valor entero de una nueva línea. El valor de una literal de carácter es el valor entero del carácter en el conjunto de caracteres Unicode.

Cadena:
Cadena es una secuencia de caracteres que se trata como una sola unidad. Una cadena puede incluir letras, dígitos y varios caracteres especiales, tales como +, -, *, Una cadena es un objeto de la clase String.

Las literales de cadena(que se almacenan en memoria como objetos String) se escriben como una secuencia de caracteres entre comillas dobles, como en:

“Juan E. Pérez”
“Calle Zapata 949”
“Monterrey, Nuevo León” 
“(201) 565-12112” 

Una cadena puede asignarse a una referencia String. La declaración

String color = “azul”;

inicializa la variable String de nombre color para que haga referencia a un objeto String que contiene
la cadena “azul”.

Clase String
La clase Stringse utiliza para representar cadenas en Java.

El método charAt de String devuelve el carácter ubicado en una posición específica en el objeto String. El método charAt recibe un argumento entero que se utiliza como el índice, y devuelve el carácter en esa posición. Al igual que los arreglos, se considera que el primer elemento de un objeto Stringestá en la posición 0.

Método equalsde Strin
El método equals(un método de la clase Object, sobrescrito en String) prueba la igualdad entre dos objetos (es decir, que las cadenas contenidas en los dos objetos sean idénticas). El método devuelve true si el contenido de los objetos es igual y false en caso contrario.

Método equalsIgnoreCasede String
Si va a ordenar objetos String, puede comparar si son iguales con el método equalsIgnoreCase, el cual  ignora si las letras en cada objeto Stringson mayúsculas o minúsculas al realizar la comparación. Por lo tanto, la cadena “hola”y la cadena “HOLA”se consideran iguales.

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:
 

Imprimir los elementos de un Arreglo en Orden Inverso

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

public class Orden_Inverso
{
    public static void main ( String args[] )
    {
        int arreglo1[];     // Declaramos arreglo1[]
        int introducido;    // Variable que controla el tamaño del arreglo
        int elemento;       // Varibale que nos servira para contar
        // Creamos dos variables String para la entrada de datos
        String entrada1, entrada2;
       
        // Creamos un objeto JTextArea con nombre areaSalida
        JTextArea areaSalida = new JTextArea();
        // Colocamos texto con setText
        areaSalida.setText( "                     Arreglo Unidimensional\n");
       
        // Pedimos al usuario que introduzca el tamaña del Arreglo
        entrada1 = JOptionPane.showInputDialog( "Introduce el Tamaño del Arreglo ");
        // Convertimos la entrada del usuario en valor int
        introducido = Integer.parseInt( entrada1 );
        // Creamos el arreglo1 con elementos del valor de "introducido"
        arreglo1 = new int [ introducido ];
       
        // Concatenamos el texto y mostramos en pantalla
        areaSalida.append("\nEl tamaño del Arreglo es de:\n  " + entrada1 );
        areaSalida.append("\nElementos del Arreglo A introducidos son: \n");
       
        // Ciclo que controla el numero de pasadas del valor "introducido"
        for(elemento = 0; elemento &lt; introducido; elemento++)
        {
            // En cada pasada se pedira al usuario que introduzca los elementos del arreglo
            entrada2 = JOptionPane.showInputDialog(  "Introduce el elemento " + ( elemento + 1 ) + " para el Arreglo" );
            // En cada pasada los elementos se iran convirtiendo a int y colando en arreglo1
            arreglo1[ elemento ] = Integer.parseInt( entrada2 );
            // En cada pasada se iran mostrando en pantalla los elementos introducidos
            areaSalida.append("  " + arreglo1[ elemento ] + ",");
        }
       
        // Creamos una variable temp y lo inicializamos, tambien una variable inicio y fin     
        int temp = 0, inicio, fin;       
        // Ciclo que controla y mueve los elementos del arreglo1 en orden inverso
        for(inicio = 0, fin = arreglo1.length-1; inicio &lt; fin; inicio++, fin--)
        {
            temp = arreglo1[ inicio ];
            arreglo1[ inicio ] = arreglo1[ fin ];
            arreglo1[ fin ] = temp;
        }
        areaSalida.append("\nElementos del Arreglo A (en Orden Inverso) son: \n");
        // Ciclo que muestra en pantalla los elementos en orden inverso del arreglo1
        for(elemento = 0; elemento &lt; arreglo1.length ; elemento++)
        {
            areaSalida.append("  " + arreglo1[ elemento ] + ",");
        }
       
        // Mostramos los resultados en pantalla
        JOptionPane.showMessageDialog( null, areaSalida, "Arreglo Unidimensional", JOptionPane.INFORMATION_MESSAGE);
    }
}

Salida:

Entradas populares