Lista enlazada Java LinkedList

package listaenlazada;
import java.util.*;


/**
 *
 * @author Josue
 */
public class ListaEnlazada {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       
        //crear o unicializar una lista enlazada
       
        LinkedList<Integer> l1=new LinkedList<Integer>();
       
       
        l1.add(3);
        l1.add(1);
        l1.add(9);
        l1.add(6);
        l1.add(10);
     
       
       
         //creamos un comparador de orden inverso
       
        Comparator<Integer> r=Collections.reverseOrder();
       
        //ordenar lal ista utilizando el comparador
       
        Collections.sort(l1,r);
       
        System.out.println("Lista en orden inverso decreciente:");
        for(int i:l1)
            System.out.print(i+"-");
       
        System.out.println();
       
        //mezclar lista
       
        Collections.shuffle(l1);
       
        //mostrar la lista aleatoriamente
        System.out.println("Aleatoriamente:");
        for(int i:l1)
            System.out.print(i+"-");
       
        System.out.println();
       
        System.out.println("Minimo:"+Collections.min(l1));
        System.out.println("Maximo: "+Collections.max(l1));
       

       
    }
}

Convertidor de grados Java

import javax.swing.*;


public class Conversor extends javax.swing.JFrame {
    private Object objJTextField;

 
    public Conversor() {
        initComponents()
               
                ;
    }

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

        etGradosC = new javax.swing.JLabel();
        etGradosF = new javax.swing.JLabel();
        ctGradosC = new javax.swing.JTextField();
        ctGradosF = new javax.swing.JTextField();
        btAceptar = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Conversion De Temperaturas");

        etGradosC.setFont(new java.awt.Font("Tahoma", 0, 24)); // NOI18N
        etGradosC.setText("Grados Centigrados");

        etGradosF.setFont(new java.awt.Font("Tahoma", 0, 24)); // NOI18N
        etGradosF.setText("Grados Fahrenheit");

        ctGradosC.setHorizontalAlignment(javax.swing.JTextField.RIGHT);
        ctGradosC.setText("0.00");
        ctGradosC.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyTyped(java.awt.event.KeyEvent evt) {
                ctGradosCKeyTyped(evt);
            }
        });

        ctGradosF.setHorizontalAlignment(javax.swing.JTextField.RIGHT);
        ctGradosF.setText("32.00");
        ctGradosF.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyTyped(java.awt.event.KeyEvent evt) {
                ctGradosFKeyTyped(evt);
            }
        });

        btAceptar.setMnemonic('A');
        btAceptar.setText("Aceptar");
        btAceptar.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btAceptarActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(22, 22, 22)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(btAceptar, javax.swing.GroupLayout.PREFERRED_SIZE, 126, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                        .addGroup(layout.createSequentialGroup()
                            .addComponent(etGradosC)
                            .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                            .addComponent(ctGradosC, javax.swing.GroupLayout.PREFERRED_SIZE, 140, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addGroup(layout.createSequentialGroup()
                            .addComponent(etGradosF)
                            .addGap(18, 18, 18)
                            .addComponent(ctGradosF, javax.swing.GroupLayout.PREFERRED_SIZE, 140, javax.swing.GroupLayout.PREFERRED_SIZE))))
                .addContainerGap(24, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(72, 72, 72)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(etGradosC)
                    .addComponent(ctGradosC, javax.swing.GroupLayout.PREFERRED_SIZE, 29, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(60, 60, 60)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                    .addComponent(etGradosF, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .addComponent(ctGradosF))
                .addGap(28, 28, 28)
                .addComponent(btAceptar, javax.swing.GroupLayout.PREFERRED_SIZE, 47, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(29, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    private void btAceptarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btAceptarActionPerformed
       
        try
        {
          double grados;
           
         
          if(objJTextField==ctGradosC)
          {
           grados=Double.parseDouble(ctGradosC.getText())*9.0/5.0+32.0;
           String texto=String.format("%.2f",grados);   //redondear a decimales
           ctGradosF.setText(texto);
          }
         
          if(objJTextField==ctGradosF)
          {
              grados=(Double.parseDouble(ctGradosF.getText())-32.0)*5.0/9.0;
              String texto=String.format("%.2f",grados);
              ctGradosC.setText(texto);
          }
        }
       
        catch(NumberFormatException e)
        {
            ctGradosC.setText(".00");
                   
           ctGradosF.setText("32.00");
         
           
        }
       
       
       
    }//GEN-LAST:event_btAceptarActionPerformed

    private void ctGradosCKeyTyped(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_ctGradosCKeyTyped
        // TODO add your handling code here:
        objJTextField=evt.getSource();
       
    }//GEN-LAST:event_ctGradosCKeyTyped

    private void ctGradosFKeyTyped(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_ctGradosFKeyTyped
        // TODO add your handling code here:
        objJTextField=evt.getSource();
       
    }//GEN-LAST:event_ctGradosFKeyTyped

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

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new Conversor().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JButton btAceptar;
    private javax.swing.JTextField ctGradosC;
    private javax.swing.JTextField ctGradosF;
    private javax.swing.JLabel etGradosC;
    private javax.swing.JLabel etGradosF;
    // End of variables declaration//GEN-END:variables
}

Calculadora en JAVA

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

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

/**
 *
 * @author JOSUE
 */

public class Calculadora extends javax.swing.JFrame {

    private Entrada ultimaEntrada;
    private boolean puntoDecimal;
    private char operador;
    private byte numOperandos;
    private double operando1,operando2;
   
    private enum Entrada{NINGUNA,DIGITO,OPERADOR,CE};
    /**
     * Creates new form Calculadora
     */
    public Calculadora()
    {
   
        initComponents();
        ultimaEntrada=  Entrada.NINGUNA;
        puntoDecimal=false;
        numOperandos=0;
        operando1=0;
        operando2=0;
       
    }
   
   
   
    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jbtDigito18 = new javax.swing.JButton();
        jtfPantalla = new javax.swing.JTextField();
        jbtDigito8 = new javax.swing.JButton();
        jbtDigito7 = new javax.swing.JButton();
        jbtDigito9 = new javax.swing.JButton();
        jbtDigito4 = new javax.swing.JButton();
        jbtDigito5 = new javax.swing.JButton();
        jbtDigito6 = new javax.swing.JButton();
        jbtDigito2 = new javax.swing.JButton();
        jbtDigito3 = new javax.swing.JButton();
        jbtDigito1 = new javax.swing.JButton();
        jbtDigito0 = new javax.swing.JButton();
        jbtDigitoPunto = new javax.swing.JButton();
        jbtDividir = new javax.swing.JButton();
        jbtInicial = new javax.swing.JButton();
        jbtMenos = new javax.swing.JButton();
        jbtMas = new javax.swing.JButton();
        jbtBorrarEntrada = new javax.swing.JButton();
        jbtIgual = new javax.swing.JButton();
        jbtPor = new javax.swing.JButton();
        jbtTantoPorCiento = new javax.swing.JButton();

        jbtDigito18.setText("9");

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Calculadora");
        setBackground(new java.awt.Color(204, 255, 255));
        setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));

        jtfPantalla.setEditable(false);
        jtfPantalla.setFont(new java.awt.Font("Arial", 1, 24)); // NOI18N
        jtfPantalla.setHorizontalAlignment(javax.swing.JTextField.RIGHT);
        jtfPantalla.setText("0.");

        jbtDigito8.setText("8");
        jbtDigito8.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito7.setText("7");
        jbtDigito7.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito9.setText("9");
        jbtDigito9.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito4.setText("4");
        jbtDigito4.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito5.setText("5");
        jbtDigito5.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito6.setText("6");
        jbtDigito6.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito2.setText("2");
        jbtDigito2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito3.setText("3");
        jbtDigito3.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito1.setText("1");
        jbtDigito1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigito0.setText("0");
        jbtDigito0.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoActionPerformed(evt);
            }
        });

        jbtDigitoPunto.setText(".");
        jbtDigitoPunto.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtDigitoPuntoActionPerformed(evt);
            }
        });

        jbtDividir.setText("/");
        jbtDividir.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtOperacionActionPerformed(evt);
            }
        });

        jbtInicial.setText("C");
        jbtInicial.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtInicialActionPerformed(evt);
            }
        });

        jbtMenos.setText("-");
        jbtMenos.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtOperacionActionPerformed(evt);
            }
        });

        jbtMas.setText("+");
        jbtMas.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtOperacionActionPerformed(evt);
            }
        });

        jbtBorrarEntrada.setText("CE");
        jbtBorrarEntrada.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtBorrarEntrada(evt);
            }
        });

        jbtIgual.setText("=");
        jbtIgual.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtOperacionActionPerformed(evt);
            }
        });

        jbtPor.setText("X");
        jbtPor.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtOperacionActionPerformed(evt);
            }
        });

        jbtTantoPorCiento.setText("%");
        jbtTantoPorCiento.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jbtTantoPorCientoActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup()
                        .addGap(21, 21, 21)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER)
                            .addGroup(javax.swing.GroupLayout.Alignment.LEADING, layout.createSequentialGroup()
                                .addComponent(jbtDigito0, javax.swing.GroupLayout.PREFERRED_SIZE, 118, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(jbtDigitoPunto, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE))
                            .addGroup(layout.createSequentialGroup()
                                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                                    .addGroup(layout.createSequentialGroup()
                                        .addComponent(jbtDigito7, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                        .addComponent(jbtDigito8, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE))
                                    .addGroup(layout.createSequentialGroup()
                                        .addComponent(jbtDigito4, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                        .addComponent(jbtDigito5, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE))
                                    .addGroup(layout.createSequentialGroup()
                                        .addComponent(jbtDigito1, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                                        .addComponent(jbtDigito2, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)))
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                                    .addComponent(jbtDigito6, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                    .addComponent(jbtDigito9, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                    .addComponent(jbtDigito3, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE))))
                        .addGap(54, 54, 54)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(jbtDividir, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(jbtMenos, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE))
                            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER)
                                .addGroup(layout.createSequentialGroup()
                                    .addComponent(jbtPor, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                    .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                                    .addComponent(jbtMas, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE))
                                .addGroup(layout.createSequentialGroup()
                                    .addGap(0, 0, Short.MAX_VALUE)
                                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER)
                                        .addComponent(jbtTantoPorCiento, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                        .addGroup(layout.createSequentialGroup()
                                            .addComponent(jbtInicial, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)
                                            .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                            .addComponent(jbtBorrarEntrada, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)))))
                            .addComponent(jbtIgual, javax.swing.GroupLayout.PREFERRED_SIZE, 56, javax.swing.GroupLayout.PREFERRED_SIZE)))
                    .addGroup(layout.createSequentialGroup()
                        .addGap(19, 19, 19)
                        .addComponent(jtfPantalla, javax.swing.GroupLayout.PREFERRED_SIZE, 348, javax.swing.GroupLayout.PREFERRED_SIZE)))
                .addContainerGap(22, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(33, 33, 33)
                .addComponent(jtfPantalla, javax.swing.GroupLayout.PREFERRED_SIZE, 35, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                        .addComponent(jbtDigito7, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addComponent(jbtDigito8, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addComponent(jbtDigito9, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE))
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                        .addComponent(jbtBorrarEntrada, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addComponent(jbtInicial, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)))
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup()
                        .addGap(10, 10, 10)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jbtDigito6, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtDigito5, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtDigito4, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)))
                    .addGroup(layout.createSequentialGroup()
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jbtMenos, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtDividir, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE))))
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup()
                        .addGap(10, 10, 10)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jbtDigito3, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtDigito2, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtDigito1, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(jbtDigito0, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtDigitoPunto, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)))
                    .addGroup(layout.createSequentialGroup()
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jbtMas, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtPor, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jbtTantoPorCiento, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jbtIgual, javax.swing.GroupLayout.PREFERRED_SIZE, 45, javax.swing.GroupLayout.PREFERRED_SIZE))))
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    private void jbtDigitoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jbtDigitoActionPerformed
        // TODO add your handling code here:
       
       
     
       
       
         JButton objJBT=(JButton)evt.getSource();
         String textoBoton=objJBT.getText();
       
         if(ultimaEntrada !=Entrada.DIGITO)
         {
             if(textoBoton.compareTo("0")==0)return;
             jtfPantalla.setText("");
             ultimaEntrada=Entrada.DIGITO;
         }
       
  jtfPantalla.setText(jtfPantalla.getText() + textoBoton);
 
       
    }//GEN-LAST:event_jbtDigitoActionPerformed

    private void jbtDigitoPuntoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jbtDigitoPuntoActionPerformed
        // TODO add your handling code here:
        if(ultimaEntrada !=Entrada.DIGITO)
        {
            jtfPantalla.setText("0.");
            ultimaEntrada=Entrada.DIGITO;
        }
       
        else if(puntoDecimal==false)
       
            jtfPantalla.setText(jtfPantalla.getText()+ ".");
        puntoDecimal=true;
     
    }//GEN-LAST:event_jbtDigitoPuntoActionPerformed

    private void jbtOperacionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jbtOperacionActionPerformed
        // TODO add your handling code here:
       
        JButton objJBT=(JButton)evt.getSource();
        String textoBoton=objJBT.getText();
       
        if((numOperandos == 0) && (textoBoton.compareTo("-")==0))
         ultimaEntrada = Entrada.DIGITO;
       
          if (ultimaEntrada == Entrada.DIGITO)
      numOperandos++;
     
         
               
       
        if(numOperandos==1)
            operando1=Double.parseDouble(jtfPantalla.getText());
        else if(numOperandos==2)
        {
            operando2=Double.parseDouble(jtfPantalla.getText());
           
            switch (operador)
            {
                case '+':
                    operando1 +=operando2;
                    break;
                   
                   
                case '-':
                    operando1 -=operando2;
                    break;
                   
                   
                case 'X':
                   
                    operando1 *= operando2;
                    break;
                   
                   
                case '/':
                    operando1/=operando2;
                    break;
                   
                   
                   
                case '=':
                    operando1=operando2;
                    break;  
            }
           
            jtfPantalla.setText(Double.toString(operando1));
            numOperandos=1;
           
        }
       
        operador=textoBoton.charAt(0);
        ultimaEntrada=Entrada.OPERADOR;
   
    }//GEN-LAST:event_jbtOperacionActionPerformed

    private void jbtTantoPorCientoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jbtTantoPorCientoActionPerformed
        // TODO add your handling code here:
       
        double resultado;
       
        if(ultimaEntrada==Entrada.DIGITO)
        {
            resultado=operando1*Double.parseDouble(jtfPantalla.getText())/100;
            jtfPantalla.setText(Double.toString(resultado));
           
            jbtIgual.doClick();
           jbtTantoPorCiento.requestFocus();
        }
       
       
    }//GEN-LAST:event_jbtTantoPorCientoActionPerformed

    private void jbtInicialActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jbtInicialActionPerformed
        // TODO add your handling code here:
       
        jtfPantalla.setText("0.");
        ultimaEntrada=Entrada.NINGUNA;
        puntoDecimal=false;
        operador=0;
        numOperandos=0;
        operando1=0;
        operando2=0;
    }//GEN-LAST:event_jbtInicialActionPerformed

    private void jbtBorrarEntrada(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jbtBorrarEntrada
        // TODO add your handling code here:
        jtfPantalla.setText("0.");
        ultimaEntrada=Entrada.CE;
        puntoDecimal=false;
       
    }//GEN-LAST:event_jbtBorrarEntrada

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

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new Calculadora().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JButton jbtBorrarEntrada;
    private javax.swing.JButton jbtDigito0;
    private javax.swing.JButton jbtDigito1;
    private javax.swing.JButton jbtDigito18;
    private javax.swing.JButton jbtDigito2;
    private javax.swing.JButton jbtDigito3;
    private javax.swing.JButton jbtDigito4;
    private javax.swing.JButton jbtDigito5;
    private javax.swing.JButton jbtDigito6;
    private javax.swing.JButton jbtDigito7;
    private javax.swing.JButton jbtDigito8;
    private javax.swing.JButton jbtDigito9;
    private javax.swing.JButton jbtDigitoPunto;
    private javax.swing.JButton jbtDividir;
    private javax.swing.JButton jbtIgual;
    private javax.swing.JButton jbtInicial;
    private javax.swing.JButton jbtMas;
    private javax.swing.JButton jbtMenos;
    private javax.swing.JButton jbtPor;
    private javax.swing.JButton jbtTantoPorCiento;
    private javax.swing.JTextField jtfPantalla;
    // End of variables declaration//GEN-END:variables
}

Aprender a programar

La programación de computadoras es una actividad fascinante, el poder hacer una aplicación a la medida y de acuerdo a nuestras necesidades es una actividad interesante y llena de recompensas.

Mucha gente llega a pensar que solamente con aprender la sintaxis de un lenguaje de programación es suficiente para poder hacer programas, pero se equivocan. Aun más importante que la sintaxis del lenguaje es la técnica de resolución del problema y el análisis adecuado.

El tener buenos hábitos de análisis y programación desde el inicio es fundamental para convertirnos en buenos programadores.

Utilizar una interfaz de nivel de llamada de SQL

Un programa puede acceder a una base de datos
SQL utilizando SQL incrustado y los módulos cliente SQL. En SQL incrustado, las instrucciones
SQL se insertan directamente en el lenguaje de programación host. Para los módulos cliente
de SQL, el programa host convoca los módulos que contienen instrucciones SQL ejecutables. Las
instrucciones están separadas del lenguaje host. SQL proporciona aún otro método para acceder a
los datos SQL desde dentro del lenguaje de programación (la interfaz de nivel de llamada), o CLI,
por sus siglas en inglés (call-level interface).

Una CLI es una interfaz de programación de aplicaciones (API, por sus siglas en inglés) que
soporta un conjunto de rutinas predefinidas que permiten que un lenguaje de programación se comunique
con una base de datos SQL. El lenguaje de programación convoca las rutinas, que luego se
conectan a la base de datos. Las rutinas acceden a los datos y a la información de estatus de la base de
datos, según se requiera, y arrojan esa información al programa. La figura 17-3 proporciona la idea
general de cómo una CLI permite que un programa se comunique con una base de datos SQL.
El programa invoca rutinas CLI a través del uso de funciones. Cuando se convoca una función,
el programa debe especificar valores para los argumentos de la función. Estos valores definen
qué acciones y cuáles datos serán accedidos. La función pasa los valores a la rutina designada, que
actúa como una interfaz entre el programa y la base de datos SQL. La CLI, en efecto, oculta los
detalles de acceder a la base de datos desde el programa, haciendo posible para el programa el acceso
a las bases de datos en diferentes sistemas de administración.


Una de las implementaciones mejor conocidas del modelo CLI es la interfaz de programación
Open Database Connectivity de Microsoft (ODBC), a pesar de que otros fabricantes han sacado al
mercado productos del tipo CLI que soportan tipos similares de acceso a la base de datos. Además,
nuevas generaciones de API de acceso de datos están ganando popularidad, por ejemplo, OLE-DB

de Microsoft, que es más eficiente que ODBC y soporta acceso tanto a las fuentes de datos SQL
como a otros tipos de fuentes de datos. Para los programadores de Java existe una API similar llamada
JDBC. También encontrará que tales productos, como ActiveX Data Object (ADO), proporcionan
una interfaz orientada a objetos entre los lenguajes de conjunto de instrucciones o lenguajes
orientados a objetos y la API OLE-DB. Muchas herramientas de desarrollo también han hecho
que acceder a una fuente de datos SQL sea más fácil que nunca. Por ejemplo, Visual Studio .NET
permite construir aplicaciones de manejo de datos en lenguajes como Visual Basic, C++ y C#. Al
utilizar las herramientas integradas ADO.NET se pueden crear aplicaciones que puedan acceder a
una variedad de fuentes de datos, por ejemplo SQL Server y Oracle.

¿A qué se refiere el término modelo de datos?

Con modelo de datos me refiero al diseño, presentado a menudo usando diagramas, que representan
la estructura de la base de datos. El modelo identifica las relaciones, atributos, claves,
dominios y relaciones dentro de la base de datos. Algunos diseñadores de bases de datos crean
un modelo lógico y un modelo físico. El modelo lógico se basa más en la teoría relacional y
aplica los principios de normalización apropiados a los datos.

El modelo físico, por otro lado,
se refiere a la aplicación real, ya que los datos se almacenan en un RDBMS. Basado en el diseño
lógico, el diseño físico trae la estructura de datos al mundo real de la implementación.

¿Que son las bases de datos relacionales¨?

El lenguaje estructurado de consultas (SQL, Structured Query Language) apoya la creación y mantenimiento
de la base de datos relacional y la gestión de los datos dentro de la base de datos. Sin
embargo, antes de entrar en discusión acerca de las bases de datos relacionales, quiero explicar el
significado del término base de datos. El término ha sido utilizado para referirse a cualquier cosa,
desde una colección de nombres y direcciones hasta un complejo sistema de recuperación y almacenamiento
de datos que se basa en interfaces de usuarios y una red de computadoras y servidores.

Hay tantas definiciones para la palabra base de datos como libros sobre éstas. Por otra parte, los
distintos proveedores de DBMS han desarrollado diferentes arquitecturas, por lo que no todas las
bases de datos están diseñadas de la misma manera. A pesar de la falta de una definición absoluta,
la mayoría de las fuentes coinciden en que una base de datos, por lo menos, es una colección de
datos organizada en un formato estructurado que es definido como metadatos que describe esa
estructura. Puede pensar en los metadatos como información sobre los datos almacenados, que define
cómo se almacenan éstos en una base de datos.


A lo largo de los años se ha implementado una serie de modelos de base de datos para almacenar
y administrar la información. Varios de los modelos más comunes incluyen los siguientes:
Jerárquico Este modelo tiene una estructura primario y secundario que es similar a un árbol
invertido, que es lo que constituye la jerarquía. Los datos están organizados en nodos, el equivalente
lógico de tablas en una base de datos relacional. Un nodo principal puede tener muchos
nodos secundarios, pero un nodo secundario sólo puede tener un nodo principal. Aunque
el modelo ha sido muy utilizado, a menudo se considera inadecuado para muchas aplicaciones
debido a su estructura inflexible y la falta de apoyo de relaciones complejas. Aun algunas
implementaciones como IMS de IBM han introducido características que trabajan en torno a
estas limitaciones.

Red:
 Este modelo aborda algunas de las limitaciones del modelo jerárquico. Los datos están
organizados en tipos de registro, el equivalente lógico de tablas en una base de datos relacional.
Al igual que el modelo jerárquico, el modelo de red usa la estructura de un árbol invertido,
pero los tipos de registro se organizan en una estructura que relaciona pares de tipos de registro
en propietarios y miembros. Cualquier tipo de registro puede participar en cualquier conjunto
con otros tipos de registro en la base de datos, que apoya a las consultas y relaciones más
complejas de lo que es posible en el modelo jerárquico. Hasta el modelo de red tiene sus limitaciones,
y la más seria es la complejidad. Al acceder a la base de datos, el usuario debe estar
familiarizado con la estructura y mantener un seguimiento cuidadoso de dónde está y cómo
llegó ahí. También es difícil cambiar la estructura sin afectar las aplicaciones que interactúan
con la base de datos.


Relacional :
Este modelo aborda algunas de las limitaciones de los modelos jerárquicos y de
red. En una base de datos de modelo jerárquico o de red, la aplicación se basa en una implementación
determinada de esa base de datos, que luego es codificada en la aplicación. Si agrega
un nuevo atributo (elemento de datos) a la base de datos, debe modificar la aplicación, aun
cuando no se use ese atributo. Sin embargo, una base de datos relacional es independiente de
la aplicación; puede hacer modificaciones no destructivas a la estructura sin afectar la aplicación.
Además, la estructura de la base de datos relacional se basa en la relación, o tabla, junto
con la habilidad de definir relaciones complejas entre ellas. Se puede acceder directamente
a cada relación sin la lentitud de las limitaciones de los modelos jerárquicos o propietario/
miembro que requiere de una navegación a través de una estructura compleja de datos. En la
siguiente sección, “El modelo relacional”, se verá con mayor detalle este modelo.
Aunque aún se usan en muchas organizaciones, las bases de datos de modelo jerárquico y de
red ahora se consideran como soluciones heredadas. El modelo relacional es el más ampliamente
aplicado en los sistemas de negocios modernos, y es el modelo relacional el que proporciona la
base para SQL.

Historia de Visual Basic Microsoft

Reseña del lenguaje:

En 1964, John Kemeny y Thomas Kurtz se propusieron crear una variante del
lenguaje de programación denominado BASIC (Beginners All-Purpose Symbolic
Instruction Code, Código de instrucciones simbólicas para principiantes orientado
a todo propósito). Si bien ya había en el mercado varias versiones de BASIC, la
generada en Dartmouth College por Kemeny y Kurtz fue la que más se popularizó.
BASIC llegó para reducir de una manera notable los tiempos de aprendizaje y
de escritura de un programa para computadoras. Así, gracias a la visión de futuro
de sus propulsores, muchos estudiantes pudieron desarrollar aplicaciones en tiempo
récord, algo muy valioso para esa época.
Al momento de diseñar el lenguaje, sus creadores tomaron como filosofía ocho principios
que debían destacar a BASIC por sobre los demás:

1. Ser fácil de usar.
2. Ser un lenguaje de propósito general.
3. Permitir la incorporación de características avanzadas por expertos, priorizando
su facilidad para principiantes.
4. Gozar de interactividad.
5. Ofrecer claros mensajes de error.
6. Brindar rápida respuesta en programas pequeños.
7. No requerir que los usuarios tengan conocimientos sobre hardware.
8. Alejar al usuario de la complejidad del sistema operativo.

Hacia 1975, la empresa fundada por Bill Gates y Paul Allen lanzó su propia versión
de BASIC, inspirada en una de las alternativas del lenguaje, creada por Alan Cooper,
denominada Altair BASIC. El mercado siguió inundándose con más versiones
opcionales, y para fines de la década del 70, apareció la primera adaptada a la plataforma
Apple II. En 1979, Microsoft negoció vender su licencia de BASIC a varias
empresas que comercializaban microcomputadoras, incluyendo a IBM, creadora en
ese entonces de la computadora personal. BASIC se incorporó en los chips ROM
de las IBM PC, con lo cual se puso una versión innovadora en equipos que no
contaban con disco rígido, pero que sí disponían ya de una unidad de disquete.



Años más tarde, Microsoft siguió distribuyendo una versión reducida de BASIC
junto a su popular sistema operativo MS DOS, la cual permitía a los programadores
diseñar aplicaciones que sólo podían ejecutarse a través del entorno de desarrollo
utilizando una serie de instrucciones BATCH, para que el programa se
ejecutara casi sin intervención de los usuarios poco expertos. En la entrada era
donde DOS pasaba a un segundo plano. Luego la firma lanzó al mercado Visual
Basic 1.0, un entorno de desarrollo que facilitaba la creación de aplicaciones con
menús, ventanas y botones, pero que aún corría bajo DOS. Recién en la versión
2.0, desarrollada para Windows 3.0/3.1, Microsoft dejó de lado el entorno gráfico
construido mediante caracteres ASCII, para dar inicio a una era distinta: la era
RAD de desarrollo de aplicaciones para Windows.


Desde Visual Basic 3.0, Microsoft fortaleció el desarrollo de aplicaciones RAD
orientado a bases de datos y dio un gran soporte al lenguaje para conectarse a
cualquier base entre las más populares del mercado (Dbase, Paradox, Fox Pro),


al utilizar las librerías de enlace dinámico a través de ODBC (Open Data Base
Connectivity). Para las bases de datos que no eran tan difundidas en ese momento,
solo restaba que la empresa que las soportaba creara una librería DLL para que
Visual Basic pudiera conectarse e interactuar con ellas y, así, leer, mostrar y
escribir información en sus archivos.
La versión 4.0 llegó al mercado casi al mismo tiempo que Windows 95, con lo cual
se lanzó una edición doble, para 16 y 32 bits, que podía instalarse en Windows 3.1x
o Windows 95, con la diferencia de que todos los proyectos creados en 16 bits
podían ser portados a 32 bits, pero no a la inversa.
Visual Basic 5.0 contó con una versión lite denominada CCE (Control Creation
Edition), en la que no solo era posible crear librerías DLL y archivos ejecutables,
sino que también se habilitaba a los programadores a generar controles personalizados,
combinando dos o más controles ActiveX existentes. También se facilitaba la
incorporación de nuevos eventos y propiedades a los controles predefinidos que se
incluían con el entorno de desarrollo.


En 1998 Microsoft introdujo Visual Basic 6.0. En la era donde Internet se devoraba
cualquier mercado, esta versión tuvo que aportar flexibilidad para dar paso al
desarrollo de aplicaciones web y no solo de escritorio. Con Visual Basic 6 se podían
crear controles personalizados, programas ejecutables bajo la plataforma Windows,
librerías DLL y aplicaciones web, incluyendo soporte para el lenguaje ASP (Active
Server Pages), que permitía generar páginas web dinámicas que se compilaban al
momento de ser solicitadas en el servidor.
El nuevo milenio trajo consigo un giro total de sus lenguajes de programación, que
se orientaron al framework .NET. Los ActiveX pasaron a segundo plano, y con esto,
también varios problemas de seguridad que sufría Microsoft Windows.


Información extraída de :Mi libro red-user que compre Xd

Obtener la curp Java

Pídemelo por estos medios y con mucho gusto te paso el código.

@PLAYGROUND_1000
http://www.facebook.com/Josue.Developer
JOSUE_X5@HOTMAIL.COM

JOptionPane Java

Flujos ObjectInputStream Java

Los objetos guardados en archivos con flujos de la clase ObjectOutputStream se recuperan, se
leen, con flujos de entrada del tipo ObjectInputStream. Esta clase es una extensión de InputStream,
además implementa la interfaz DataInput; por ello dispone de los diversos métodos de entrada
(read) para cada uno de los tipos de datos, readInt( )… El método más interesante definido
por la clase ObjectInputStream es readObject( ); lee un objeto del flujo de entrada (del archivo
asociado al flujo de bajo nivel). Este objeto se escribió en su momento con el método writeObject(
).
public Object readObject( ) throws IOException;
El constructor de flujos ObjectInputStream tiene como entrada otro flujo, de bajo nivel, de
cualquier tipo derivado de InputStream, por ejemplo FileInputStream, asociado con el archivo
de objetos. A continuación se crea un flujo de entrada para leer los objetos del archivo "archivoObjets.
dat":
ObjectInputStream obje = new ObjectInputStream(
new FileInputStream("archivoObjets.dat "));
El constructor levanta una excepción si, por ejemplo, el archivo no existe,..., del tipo ClassNotFoundException,
o bien IOException; es necesario poder capturar estas excepciones.




EJEMPLO PRACTICO:


Se desea guardar en un archivo los libros y discos de que disponemos. Los datos de interés para un
libro son: título, autor, editorial, número de páginas; para un disco: cantante, título, duración en minutos,
número de canciones y precio.
Se podría diseñar una jerarquía de clases que modelase los objetos libro, disco,… Sin embargo, el
ejercicio sólo pretende mostrar cómo crear objetos persistentes; declara directamente la clase Libro
y Disco con la propiedad de ser “serializables” (implementan la interfaz java.io.Serializable).
La clase principal crea un flujo de salida para objetos; según los datos que introduce el usuario se instancia
un tipo de objeto Disco o Libro y con el método writeObject( ) se escribe en el flujo.


import java.io.*;
class Libro implements Serializable
{
private String titulo;
private String autor;
private String editorial;
private int pagina;
public Libro( )
{
titulo = autor = editorial = null;
}
public Libro(String t, String a, String e, int pg)
{
titulo = t;
autor = a;
editorial = e;
pagina = pg;
}
public void entrada(BufferedReader ent) throws IOException
{
System.out.print("Titulo: "); titulo = ent.readLine( );
System.out.print("Autor: "); autor = ent.readLine( );
System.out.print("Editorial: "); editorial = ent.readLine( );
System.out.print("Páginas: ");
pagina = Integer.parseInt(ent.readLine( ));
}
}


class Disco implements Serializable
{
private String artista;
private String titulo;
private int numCancion, duracion;
private transient double precio;
public Disco( )
{
artista = titulo = null;
}
public Disco(String a, String t, int n, int d, double p)
{
titulo = t;
artista = a;
numCancion = n;
duracion = d;
precio = p;
}
public void entrada(BufferedReader ent) throws IOException
{
System.out.print("Cantante: "); artista = ent.readLine( );
System.out.print("Titulo: "); titulo = ent.readLine( );


System.out.print("Canciones: ");
numCancion = Integer.parseInt(ent.readLine( ));
System.out.print("Duración(minutos): ");
duracion = Integer.parseInt(ent.readLine( ));
System.out.print("Precio: ");
precio = Double.valueOf(ent.readLine( )).doubleValue( );
}
}
public class Libreria
{
public static void main (String [ ] a)
{
BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
File mf = new File("libreria.dat");
ObjectOutputStream fobj = null;
Libro libro = new Libro( );
Disco disco = new Disco( );
int tipo;
boolean mas = true;
try {
fobj = new ObjectOutputStream(new FileOutputStream(mf));
do {
System.out.println
("Pulsa L(libro), D(disco), F(finalizar)");
tipo = System.in.read( );
System.in.skip(2); // salta caracteres fin de línea
switch (tipo) {
case 'L':

case 'l': libro = new Libro( );
libro.entrada(br);
fobj.writeObject(libro);
break;
case 'D':
case 'd': disco = new Disco( );
disco.entrada(br);
fobj.writeObject(disco);
break;
case 'F':
case 'f': fobj.close( );
mas = false;
}
} while (mas);
}
catch (IOException e)
{
e.printStackTrace( );
}
}
}

BufferedReader Java

La lectura de archivos de texto se realiza con un flujo que almacena los caracteres en un búfer intermedio.
Los caracteres no se leen directamente del archivo sino del búfer; con esto se consigue más
eficiencia en las operaciones de entrada. La clase BufferReader permite crear flujos de caracteres
con búfer, es una forma de organizar el flujo básico de caracteres del que procede el texto; esto se
manifiesta
en que al crear el flujo BufferReader se inicializa con un flujo de caracteres de tipo
InputStreamReader.


El constructor de la clase tiene un argumento de tipo Reader, un FileReader o un InputStreamReader.
El flujo creado dispone de un búfer de un tamaño, normalmente suficiente; el tamaño
del búfer se puede especificar en el constructor con un segundo argumento aunque no resulta
necesario. Ejemplos de flujos con búfer:
File mf = new File("C:\listados.txt");
FileReader fr = new FileReader(mf);
BufferedReader bra = new BufferedReader(fr);
File mfz = new File("Complejo.dat");
BufferedReader brz = new BufferedReader(
new InputStreamReader(
new FileInputStream(mfz)));

La clase BufferedReader deriva directamente de la clase Reader. Entonces, dispone de los
métodos read( ) para leer un carácter, o bien un arreglo de caracteres. El método más importante es
readLine( ):
public String readLine( ) throws IOException;
El método lee una línea de caracteres, termina con el carácter de fin de línea, y devuelve una cadena
con la línea leída (no incluye el carácter fin de línea). Puede devolver null si lee la marca de fin
de archivo.


Otro método interesante es close( ), cierra el flujo y libera los recursos asignados. El fin de la
aplicación Java también cierra los flujos abiertos, aunque es recomendable cerrar un flujo que no se
va a utilizar.
public void close( ) throws IOException

Flujos PrintStream Java

La clase PrintStream deriva directamente de FilterOutputStream. La característica más importante
es que dispone de métodos que añaden la marca de fin de línea. Los flujos de tipo PrintStream
son de salida, se asocian con otro flujo de bajo nivel, de bytes, que a su vez se crea asociado a un archivo
externo. Por ejemplo, mediante el flujo fjp se puede escribir cualquier tipo de dato; los bytes
que ocupa cada dato se vuelcan secuencialmente en Complex.dat
fjp = new PrintStream(new FileOutputStream("Complex.dat"));
Los métodos de esta clase, print( ) y println( ) están sobrecargados para poder escribir
desde cadenas hasta cualquiera de los datos primitivos; println( ) escribe un dato y a continuación
añade la marca de fin de línea.
A continuación están los métodos más importantes:
public PrintStream(OutputStream destino)
Crea un objeto asociado con cualquier objeto de salida pasado como argumento.
public PrintStream(OutputStream destino, boolean flag)
Crea un objeto asociado con objeto de salida pasado como argumento y si el segundo argumento
es true se produce un automático volcado al escribir el fin de línea.
public void flush( )
Vuelca el flujo actual.


public void print(Object obj)
Escribe la representación del objeto obj en el flujo.
public void print(String cad)
Escribe la cadena en el flujo.
public void print(char c)
Escribe el carácter c en el flujo.
método print( ) para cada tipo de dato primitivo.
public void println(Object obj)
Escribe la representación del objeto obj en el flujo y el fin de línea.
public void println(String cad)
Escribe la cadena en el flujo y el fin de línea.
catch (IOException io)
{
System.out.println("Anomalía al leer flujo de entrada, "
+ io.getMessage( ));
return; // termina la ejecución
}
finally {
try
{
obfl.close( );
}
catch (IOException er)
{
er.printStackTrace( );
}
}
// termina el proceso, escribe la temperatura máxima
System.out.println("\n La temperatura máxima: " + (float)mxt);
}
}


public void println(char c)
Escribe el carácter c en el flujo y el fin de línea.
método println( ) para cada tipo de dato primitivo


Nota de programación
El objeto definido en la clase System: System.out es de tipo PrintStream, asociado,
normalmente, con la pantalla. Por ello se han utilizado los métodos:
System.out.print( );
System.out.println( );

Archivos y flujos en Java

Los archivos tienen como finalidad guardar datos de forma permanente; una vez que acaba la aplicación,
los datos siguen disponibles para que otra aplicación pueda recuperarlos, para su consulta o modificación.
El proceso de archivos en Java se hace mediante el concepto de flujo (stream) o canal, o también
denominado secuencia. Los flujos pueden estar abiertos o cerrados, conducen los datos entre el programa
y los dispositivos externos. Con las clases y sus métodos proporcionados por el paquete java.io
se pueden tratar archivos secuenciales, de acceso directo, archivos indexados, etcétera.


Flujos y archivos

Un fichero (archivo) de datos, o simplemente un archivo, es una colección de registros relacionados
entre sí con aspectos en común y organizados para un propósito específico. Por ejemplo, un fichero
de una clase escolar contiene un conjunto de registros de los estudiantes de esa clase.
Un archivo en una computadora es una estructura diseñada para contener datos, los cuales están
organizados de tal modo que puedan ser recuperados fácilmente, actualizados o borrados y almacenados
de nuevo en el archivo con todos los cambios realizados.
Según las características del soporte empleado y el modo en que se han organizado los registros,
se consideran dos tipos de acceso a los registros de un archivo:
• acceso secuencial,
• acceso directo.

El acceso secuencial implica el acceso a un archivo según el orden de almacenamiento de sus registros,
uno tras otro.
El acceso directo implica el acceso a un registro determinado, sin que ello implique la consulta de
los registros precedentes. Este tipo de acceso sólo es posible con soportes direccionales.
En Java un archivo es, sencillamente, una secuencia de bytes, que son la representación de los datos
almacenados. Java dispone de clases para trabajar las secuencias de bytes como datos de tipos básicos
(int, double, String ...); incluso, para escribir o leer del archivo objetos. El diseño del archivo es el
que establece la forma de manejar las secuencias de bytes, con una organización secuencial, o bien de
acceso directo.
Un flujo (stream) es una abstracción que se refiere a una corriente de datos que fluyen entre un
origen o fuente (productor) y un destino o sumidero (consumidor). Entre el origen y el destino debe
existir una conexión o canal ( pipe) por la que circulen los datos. La apertura de un archivo supone establecer
la conexión del programa con el dispositivo que contiene el archivo; por el canal que comunica
el archivo con el programa van a fluir las secuencias de datos.
Abrir un archivo supone crear un objeto que queda asociado con un flujo. Al comenzar la ejecución
de un programa Java se crean automáticamente tres objetos de flujo, son tres canales por los que
pueden fluir datos, de entrada o de salida. Éstos son objetos definidos en la clase System:



• System.in; entrada estándar; permite la entrada al programa de flujos de bytes desde el teclado.
• System.out; salida estándar; permite al programa la salida de datos por pantalla.
• System.err; salida estándar de errores; permite al programa salida de errores por pantalla.
En Java, un archivo es simplemente un flujo externo, una secuencia de bytes almacenados en un
dispositivo externo (normalmente en disco). Si el archivo se abre para salida, es un flujo de archivo de
salida. Si el archivo se abre para entrada, es un flujo de archivo de entrada. Los programas leen o
escriben
en el flujo, que puede estar conectado a un dispositivo o a otro. El flujo es por tanto una abstracción
de tal forma que las operaciones que realizan los programas son sobre el flujo independientemente
del dispositivo al que esté asociado.


A tener en cuenta
El paquete java.io agrupa al conjunto de clases e interfaces necesarios para procesar archivos.
Es necesario utilizar clases de este paquete; por consiguiente, se debe incorporar al programa
con la sentencia import java.io.*.

Información de un archivo
Con los métodos de la clase File se obtiene información relativa al archivo o ruta con que se ha inicializado
el objeto. Así, antes de crear un flujo para leer de un archivo es conveniente determinar si el
archivo existe; en caso contrario no se puede crear el flujo. A continuación se exponen los métodos
más útiles para conocer los atributos de un archivo o un directorio.
public boolean exists( )
Devuelve true si existe el archivo (o el directorio).
public boolean canWrite( )
Devuelve true si se puede escribir en el archivo, si no es de sólo lectura.
public boolean canRead( )
Devuelve true si es de sólo lectura.
public boolean isFile( )
Devuelve true si es un archivo.
public boolean isDirectory( )
Devuelve true si el objeto representa a un directorio.
public boolean isAbsolute( )
Devuelve true si el directorio es la ruta completa.
public long length( )
Devuelve el número de bytes que ocupa el archivo. Si el objeto es un directorio devuelve cero.


public long lastModified( )
Devuelve la hora de la última modificación. El número devuelto es una representación interna
de la hora, minutos y segundos de la última modificación, sólo es útil para establecer
comparaciones con otros valores devueltos por el mismo método.
También dispone de métodos que modifican el archivo: cambiar de nombre, marcar de sólo lectura.
Para los directorios, tiene métodos para crear uno nuevo, obtener una lista de todos los elementos
(archivos o subdirectorios) del directorio. Algunos de estos métodos se escriben a continuación.
public String getName( )
Devuelve una cadena con el nombre del archivo o del directorio con que se ha inicializado
el objeto.
public String getPath( )
Devuelve una cadena con la ruta relativa al directorio actual.
public String getAbsolutePath( )
Devuelve una cadena con la ruta completa del archivo o directorio.
public boolean setReadOnly( )
Marca al archivo para que no se pueda escribir, de sólo lectura.
public boolean delete( )
Elimina el archivo o directorio (debe estar vacío).
public boolean renameTo(File nuevo)
Cambia el nombre del archivo con que ha sido inicializado el objeto por el nombre que contiene
el objeto pasado como argumento.
public boolean mkdir( )

Crea el directorio con el que se ha creado el objeto.
public String[ ] list( )
Devuelve un array de cadenas, cada una contiene un elemento (archivo o directorio) del directorio
con el que se ha inicializado el objeto.

Declaración de un tipo parametrizado

Al nombre de la colección le sigue el tipo de los elementos entre paréntesis angulares (< tipo>):
Coleccion<tipo> v;
Si se parametrizan dos tipos, como ocurre con los mapas, se separan con coma:
Coleccion<tipoClave,tipoValor> cc;
Por ejemplo:
Stack<Double> pila;
SortedMap<Integer,String> mapa;
Realmente con el tipo parametrizado es como si se hubiera declarado otra clase, en consecuencia
las instancias de colecciones parametrizadas se crean con esa clase, es decir new
Coleccion<tipo> crea la instancia. Por ejemplo:
pila = newStack<Double>();
mapa = newTreeMap<Integer,String>();