Programación JAVA: Hacemos tus proyectos de Sistemas

lunes, septiembre 09, 2013

Convertidor Decimal - Binario en Java (Punto Flotante)

Convertidor Decimal - Binario

Convertidor hecho en java.

Decimal a Binario
Binario a Decimal
Decimal a Binario en Punto Flotante
Binario en Punto Flotante a Decimal

Les dejo el ejecutable en Windows.
Codigo:

Si quieres el código completo escríbeme a mi email: desarrolloenjava@gmail.com y negociamos ($)... Lo reestructuro para que lo presentes como tuyo.

Actividad de Métodos Numéricos (Análisis Numérico) - Universidad Simón Bolívar - Barranquilla, Colombia

DESCARGAR CONVERTIDOR

Tomar foto con webcam en Java: JCameraPlus Lite

Tomar foto con webcam en Java: JCameraPlus Lite (Java Media Framework)
Esta es una aplicación realizada en netbeans con la librería JMF que permite captura una foto con tu webcam si la tienes. También cuenta con una galería donde se muestran las fotos que se han tomado y hace capturas de la pantalla, es muy sencillo y dinámico.

Nota: Obviamente necesitas tener instalado Java y la librería JMF

Les dejo el código fuente de la aplicación y su ejecutable para windows, tambien el instalador de JMF.

DESCARGAR JCAMERAPLUS

DESCARGAR CÓDIGO FUENTE

DESCARGAR INSTALADOR JMF

viernes, agosto 16, 2013

Reproductor de Audio hecho en Java

Reproductor de Audio hecho en Java

JPLAYER MAX 1.0
Simple
Sencillo
Dinámico
Lista de Reproducción
Skins intercambiables

By Jose Meza Meza

Les dejo el link con el proyecto de netbeans y un ejecutable (.exe) windows

DESCARGAR

lunes, agosto 05, 2013

Poner Icono a un JFrame en una Aplicación Java

Poner Icono a un JFrame en una Aplicación Java
Solo colocas esto en tu constructor.
Icon.png es la dirección de la imagen y debe estar dentro de la carpeta de tu aplicación, si es netbeans debe estar en la carpeta src.

this.setIconImage (new ImageIcon(getClass().getResource("Icon.png")).getImage());

Captura de Pantalla en Java

Captura de Pantalla en Java

import java.awt.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileNameExtensionFilter;

public class Capture {

private BufferedImage image;
private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivos de Imagen","jpg");
private JFileChooser fileChooser = new JFileChooser();
/* CAPTURA LA PANTALLA */
public boolean captureScreen() {
try {
//crea el area de captura
Robot robot = new Robot();

image = robot.createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));
return getImage();
} catch (Exception ex) {
}
return false;
}

private boolean getImage(){
String file=null;
fileChooser = new JFileChooser();
fileChooser.setFileFilter(filter);
int result = fileChooser.showSaveDialog(null);
if ( result == JFileChooser.APPROVE_OPTION ){
file = fileChooser.getSelectedFile().toString();

return SaveImage(file + ".jpg");
}
return false;
}

/* guarda la imagen en disco*/
private boolean SaveImage(String f){
try {
//se escribe en disco en formato JPG
ImageIO.write(image, "jpg", new File(f));
return true;
} catch (IOException e) {

}
return false;
}

}

Obtener las propiedades de Sistema en Java

Propiedades de Sistema en Java
Esta es una clase muy sencilla que los guiará sobre como obtener algunas de las propiedades del sistema mas importantes como sistema operativo, arquitectura del sistema, nombre de usuario, procesador, versión del JDK, etc.

Código

class InfoCompu
{
public static void main(String args[])
{
System.out.println("Nombre del PC: " + nombrePC());
System.out.println("Nombre usuario: " + usuario());
System.out.println("Procesador: " + procesador());
System.out.println("Sistema operativo: " + SO());
System.out.println("Version JDK: " + JDK());
System.out.println("Directorio actual: " + dir());
}
public static String nombrePC()
{
return System.getenv("COMPUTERNAME");
}

public static String usuario()
{
return System.getProperty("user.name");
}

public static String procesador()
{
return System.getenv("PROCESSOR_IDENTIFIER");
}

public static String SO()
{
return System.getProperty("os.name");
}

public static String JDK()
{
return System.getProperty("java.version");
}

public static String dir()
{
return System.getProperty("user.dir");
}
}

Texto Encriptado con AES y DES

AES y DES
Los siguientes códigos que implementé para codificar datos importantes en un proyecto con base de datos, estos son estándares muy conocidos y seguros. Estos 2 algoritmos servirán para encriptar datos como contraseñas de usuario y otros datos que no queremos sean vistos por intrusos o hackers en caso de ataques a nuestra base de datos. Es una medida de seguridad que nunca esta de mas.
Diseñados por JJMM

AES

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
public class AESBasic {

private String KeyPass="";
private String ALGORITHM = "AES";
private int LENGTH = 128;
private String TEXTFORMAT = "UTF-8";
private AESKey AESK=new AESKey();

public AESBasic() {
        try {
            AESK=this.KeyGenerate();
        } catch (Exception ex) {
            Logger.getLogger(AESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }
}

public AESBasic(String Pass) {
        try {
            AESK=this.KeyGenerate();
            KeyPass=this.genKey(Pass);
            AESK.setEncoded(KeyPass);
        } catch (Exception ex) {
            Logger.getLogger(AESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }
}

private AESKey KeyGenerate(){
        try {
            KeyGenerator Keygen = KeyGenerator.getInstance(ALGORITHM);
            Keygen.init(LENGTH);
            SecretKey SecKey = Keygen.generateKey();
            AESKey aesKey = new AESKey();
            aesKey.setEncoded(HexToString(SecKey.getEncoded()));
            KeyPass=aesKey.getEncoded();
            return aesKey;
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(AESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
}

public String genKey(String pass){
        return KeyPass=getStringBytes(StringToBytes(pass));
    }
 
    private byte[] StringToBytes(String str){
        try {
            byte [] b;
            byte [] Baux;
            b=str.getBytes("UTF-8");
            while(b.length<32){
                Baux=new byte[(32-b.length)+b.length];
                for(int i=0;i<Baux.length;i++){
                    if(i<b.length){
                        Baux[i]=b[i];
                    }else{
                        if(i%2==0){
                        Baux[i]="JJMMAES".getBytes()[2];
                        }else{
                        Baux[i]="AESJJMM".getBytes()[0];
                        }
                    }
                }
                b=Baux;
            }
         
            return b;
        } catch (UnsupportedEncodingException ex) {
        }
        return null;
    }
 
    private String getStringBytes(byte [] b){
       String str="";
       for(int i=0;i<b.length;i++){
           str=str+b[i];
       }
       return str.substring(0,32);
    }

public String Encode(String str){
        try {
            byte[] raw = StringToHex(KeyPass);
            SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
            byte[] encrypted = cipher.doFinal(str.getBytes(TEXTFORMAT));
            String encript = HexToString(encrypted);
            return encript;
        } catch (Exception ex) {
            return null;
        }
}

public String Decode(String str){
        try {
            byte[] raw = StringToHex(KeyPass);
            SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            byte[] original = cipher.doFinal(StringToHex(str));
            String originalString = new String(original);
            return originalString;
        } catch (Exception ex) {
            return null;
        }
}

public String getKey(){
    return AESK.getEncoded();
}

public void setKey(String K){
    AESK.setEncoded(K);
}

private String HexToString(byte[] array) {
 
    String text = "";
    for (int i = 0; i < array.length; i++) {
        int aux = array[i] & 0xff;
        if (aux < 16) {
        text = text.concat("0");
        }
        text = text.concat(Integer.toHexString(aux));
    }
 
    return text;
}

private byte[] StringToHex(String text) {
    byte[] array = new byte[text.length() / 2];
    for (int i = 0; i < array.length; i++) {
        int index = i * 2;
        String aux = text.substring(index, index + 2);
        int v = Integer.parseInt(aux, 16);
        array[i] = (byte) v;
    }
 
    return array;
}

private class AESKey {
 
    private String encoded;
     
    public String getEncoded() {
            return encoded;
    }

public void setEncoded(String encoded) {
    this.encoded = encoded;
    }
 
 
}
 
 
 
}

DES

import java.io.UnsupportedEncodingException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;

public class DESBasic {

private Cipher Encipher;
private Cipher Decipher;
private String Algorithm = "DESede";
private String Transformer = "DESede/CBC/PKCS5Padding";
private String SKeyPass = "123456789012345678901234"; //your SKeyPass 24 bit
private SecretKey SKey;
private IvParameterSpec IV;

public DESBasic(String pass) {
        try {
            SKeyPass=this.genSKey(pass);
            DESedeKeySpec SKeySpec = new DESedeKeySpec(SKeyPass.getBytes());
            SKey = SecretKeyFactory.getInstance(Algorithm).generateSecret(SKeySpec);
            IV = new IvParameterSpec(new byte[8]);
            Encipher = Cipher.getInstance(Transformer);
            Decipher = Cipher.getInstance(Transformer);
            Encipher.init(Cipher.ENCRYPT_MODE, SKey, IV);
            Decipher.init(Cipher.DECRYPT_MODE, SKey, IV);
        } catch (Exception ex) {
            Logger.getLogger(DESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }

}

public String Encode(String str) {
try {
byte[] enc = Encipher.doFinal(str.getBytes());
return this.HexToString(enc);
} catch (Exception e) {
}
return null;
}

public String Decode(String str) {
try {
byte[] utf8 = Decipher.doFinal(StringToHex(str));
return new String(utf8, "UTF8");
} catch (Exception e) {
}
return null;
}

public String genSKey(String pass){
        return this.getStringBytes(StringToBytes(pass));
    }

private byte[] StringToBytes(String str){
        try {
            byte [] b;
            byte [] Baux;
            b=str.getBytes("UTF-8");
            while(b.length<32){
                Baux=new byte[(32-b.length)+b.length];
                for(int i=0;i<Baux.length;i++){
                    if(i<b.length){
                        Baux[i]=b[i];
                    }else{
                        if(i%2==0){
                        Baux[i]="JJMMDES".getBytes()[1];
                        }else{
                        Baux[i]="JJMMDES".getBytes()[5];
                        }
                    }
                }
                b=Baux;
            }
         
            return b;
        } catch (UnsupportedEncodingException ex) {
            Logger.getLogger(SuperDecrypt.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }
 
    private String getStringBytes(byte [] b){
       String str="";
       for(int i=0;i<b.length;i++){
           str=str+b[i];
       }
       return str.substring(0,48);
    }

}