Emular una consola (terminal) en Java

Un terminal, conocido también como consola, es un dispositivo electrónico o electromecánico de hardware usado para introducir o mostrar datos de una computadora o de un sistema de computación.

Este programa permite manejar los comandos de MS-DOS o de UNIX, aunque en realidad no funciona como la consola en si, ya que no permite navegar entre carpetas, pero de ahí en mas puedes hacer muchas, como abrir programas, procesos, apagar la maquina, compilar programas, hacer carpetas, renovar la red y mas cosas. Claro que para eso solo necesitas saber usar los comandos correspondientes, en mi caso solo tuve la oportunidad de ejecutarlo en Windows, pero aquellos que puedan utilizarlo en Linux espero y no les falle.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public final class Consola extends JFrame implements KeyListener{
    private JPanel panel = new JPanel();
    private JLabel label = new JLabel();
    private JLabel labelTitulo = new JLabel("Consola de Comandos en Java");
    private JTextField texto = new JTextField();
    private JLabel label2 = new JLabel("Ingresa el comando: ");
    private JTextArea areaTerminal = new JTextArea("");
    private boolean metalera =  false;
    private Process p;
    private String textoTerminal = "";
    public Consola(){
        initComponents();
        setIconImage(getIconImage());
        setTitle("NIMADRES");
        setLayout(new GridLayout(2,1));
        setBounds(200,50,600,350);
        //setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }
    public void initComponents(){
        panel.setLayout(null);
        panel.setBackground(Color.black);
        label.setIcon(new ImageIcon(getClass().getResource("terminal.jpg")));
        label.setBackground(Color.black);
        label.setBounds(0, 0, 100, 90);
        label2.setBackground(Color.black);
        label2.setForeground(Color.green);
        label2.setFont(new Font("consolas",1,12));
        label2.setBounds(0, 50, 150, 100);
        labelTitulo.setBounds(200,10,300,20);
        labelTitulo.setBackground(Color.black);
        labelTitulo.setForeground(Color.red);
        labelTitulo.setFont(new Font("consolas",1,20));
        texto.setBounds(150,90,400,20);
        texto.setForeground(Color.green);
        texto.setBackground(Color.black);
        texto.setSelectionColor(Color.red);
        texto.setFont(new Font("consolas",1,12));
        areaTerminal.setBounds(0,150,300,300);
        areaTerminal.setBackground(Color.black);
        areaTerminal.setForeground(Color.green);
        areaTerminal.setSelectionColor(Color.red);
        areaTerminal.setFont(new Font("consolas",1,10));
        areaTerminal.setEnabled(false);
        panel.add(labelTitulo);
        panel.add(label);
        panel.add(label2);
        panel.add(texto);
        add(panel,BorderLayout.NORTH);
        add(new JScrollPane(areaTerminal),BorderLayout.SOUTH);
        texto.addKeyListener(new KeyAdapter(){
            @Override
            public void keyPressed(KeyEvent e) {
                if(e.getKeyCode()== KeyEvent.VK_ENTER){
                    if(texto.getText().equals(""))
                        metalera = false;
                    else
                        metalera = true;
                    if(metalera){
                        String cadena = texto.getText();
                        mensageSalida(cadena);
                    }
                    texto.setText("");
                }
            }
        });
    }
    public void keyTyped(KeyEvent e) {
    }
    public void keyPressed(KeyEvent e) {
    }
    public void keyReleased(KeyEvent e) {
    }
    public void mensageSalida(final String cadena){
        try {
            if(cadena.equals("cls") ||cadena.equals("clear"))
                textoTerminal = "";
            try {
                p = Runtime.getRuntime().exec(cadena);
            } catch (IOException iOException) {
                p = Runtime.getRuntime().exec("cmd /c " + cadena);
            }
            InputStream salida = p.getInputStream(); 
            BufferedReader leer;
            leer = new BufferedReader(new InputStreamReader(salida));
            String lectura = leer.readLine();             
            while (lectura != null) { 
                System.out.println (lectura);
                textoTerminal += lectura + "\n";
                 areaTerminal.setText(textoTerminal);
                lectura = leer.readLine(); 
            } 
        }  
        catch (Exception e) { 
            areaTerminal.setText(e + ""); 
        }
    }
    public Image getIconImage() {
        Image iconoVentana = Toolkit.getDefaultToolkit().
        getImage(ClassLoader.getSystemResource("terminal.jpg"));
        return iconoVentana;
    }
}

Al final solo falta el Main para ejecutarlo

import javax.swing.UIManager;
public class Main{
    public static void main(String args[]){
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
            java.awt.EventQueue.invokeLater(new Runnable(){
                public void run(){
                    new Consola().setVisible(true);
                }
            });
        }
        catch(Exception e) {}
    }
}

Esta fue la imagen que yo utilice para los iconos 

Reproductor de Audio en Java (Gráfico)

Un reproductor de audio digital es un dispositivo que no almacena , organiza y reproduce archivos de audio digital. Comúnmente se le denomina reproductor de MP3, reproductor MP3, o simplemente MP3 (debido a la ubicuidad del formato *.mp3), pero los reproductores de audio digital reproducen a menudo otros formatos de archivo como algunos otro formatos propietarios aparte de MP3, por ejemplo Windows Media Audio (WMA) y Advanced Audio Coding (AAC) así como formatos totalmente libres de patentes o son abiertos, como Ogg Vorbis, FLAC, y Speex (todo parte del proyecto abierto de multimedia Ogg). Algunos reproductores soportan tecnología DRM restrictiva que son parte de algunos formatos propietarios, como WMA DRM, que a menudo forman parte de ciertos sitios de descargas de pago.

En este caso El reproductor que hice solamente abre archivos con extencion "WAV" o "MID" entre otros, para poder hacer un reproductor de audio "MP3", "OGG", "WMA" se necesitan decargar API's de la libreria de Java, es por eso que solo hice este, el mas sencillo que solo reproduce los archivos y es de la libreria Estandard de Java, mismo que se puede compilar desde consola y no necesita nada mas.

Aunque esta simple, se puede empezar con este para después mejorarlo y hacer uno con una mayor estructura.

import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JOptionPane;

public final class Reproductor extends JFrame implements ActionListener{
    private JButton botonPlay = new JButton();
    private JButton botonStop = new JButton();
    private JButton botonBuscar = new JButton("buscar");
    private JPanel panel = new JPanel();
    private JTextArea area = new JTextArea();
    private Sonido musica = new Sonido();
    private String texto, cadena;
    private JLabel label = new JLabel("Reproductor de Audio Java");
    
    public Reproductor(){
        initComponents();
        setTitle("NIMADRES");
        setBounds(150, 150, 550, 170);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }
    public void initComponents(){
        label.setBounds(60, 0, 300, 50);
        label.setFont(new Font("chiller",1,30));
        label.setForeground(Color.red);
        panel.setLayout(null);
        botonPlay.setBounds(50, 50, 60, 60);
        botonStop.setBounds(130, 50, 60, 60);
        botonPlay.setIcon(new ImageIcon(getClass().getResource("play.png")));
        botonPlay.setBackground(Color.black);
        botonStop.setIcon(new ImageIcon(getClass().getResource("stop.png")));
        botonStop.setBackground(Color.black);
        botonBuscar.setBounds(200, 50, 90, 60);
        botonBuscar.setBackground(Color.black);
        botonBuscar.setForeground(Color.red);
        botonBuscar.setFont(new Font("chiller",1,25));
        panel.setBackground(Color.black);
        area.setBounds(380, 20, 200, 100);
        area.setEditable(false);
        area.setBackground(Color.black);
        area.setForeground(Color.red);
        area.setFont(new Font("chiller",1,20));
        panel.add(label);
        panel.add(botonPlay);
        panel.add(botonStop);
        panel.add(botonBuscar);
        panel.add(area);
        add(panel);
        botonPlay.addActionListener(this);
        botonStop.addActionListener(this);
        botonBuscar.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        if(e.getSource().equals(botonPlay)){
            area.setText("Reproduciendo:\n"+ texto);
            musica.playSound(cadena);
        }
        if(e.getSource().equals(botonStop)){
            area.setText("Stop");
            musica.Stop();
        }
        if(e.getSource().equals(botonBuscar)){
            JFileChooser fileChooser = new JFileChooser();
            int returnValue = fileChooser.showOpenDialog(null);
            if (returnValue == JFileChooser.APPROVE_OPTION) {
                File selectedFile = fileChooser.getSelectedFile();
                texto = selectedFile.getName();
                try {
                    cadena = selectedFile.getAbsolutePath();
                } catch (Exception ex) {
                    Logger.getLogger(Reproductor.class.getName()).
                            log(Level.SEVERE, null, ex);
                }
                System.out.println(selectedFile.getName());
                area.setText("Reproduciendo: \n" + texto);
                System.out.println(cadena);
            }
        }
    }
    class Sonido{
        Clip clip;
        AudioInputStream inputStream;
        public Sonido(){
        }
        public synchronized void playSound(final String url){
            new Thread(new Runnable() { 
                public void run() {
                    try {
                        clip = AudioSystem.getClip();
                        inputStream = AudioSystem.
                                getAudioInputStream(new File(url));
                        clip.open (inputStream);
                        clip.start();
                    }
                    catch (Exception e) {
                        if(e.getMessage() != null){
                            JOptionPane.showMessageDialog(null
                                ,"Archivo no Compatible"
                                ,"Fatal Error"
                            ,JOptionPane.ERROR_MESSAGE);
                            System.err.println(e.getMessage());
                        }
                        else{
                            JOptionPane.showMessageDialog(null
                                ,"No hay Archivo seleccionado"
                                ,"Fatal Error"
                            ,JOptionPane.ERROR_MESSAGE);
                            System.err.println(e.getMessage());
                        }
                    }
                }
            }).start();
        }
        public void Stop(){
            try {
                clip.stop();
                clip.close();
            } catch (Exception e){
            }
        }
    }
}

Ahora solo falta el archivo "Main.java" para finalizar.

import javax.swing.JFrame;
public class Main {

    public static void main(String[] args) {
        JFrame.setDefaultLookAndFeelDecorated(true);
        Reproductor r = new Reproductor();
    }
}

Estas son las imágenes que utilice para hacer los botones.

Listas Enlazadas en C++ Orientado a Objetos

Una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias, enlaces o punteros al nodo anterior o posterior. 
El principal beneficio de las listas enlazadas respecto a los vectores convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento.
Una lista enlazada es un tipo de dato autoreferenciado porque contienen un puntero o enlace a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminación de nodos en cualquier punto de la lista en tiempo constante (suponiendo que dicho punto está previamente identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares.

En este programa se utiliza memoria dinámica y una función add(), donde  busca el lugar de la inserción, ya sea automáticamente por el inicio, a la mitad o al final de la lista, misma que se puede utilizar las veces que sean necesarias. También tiene funciones en las que permite buscar algún dato anteriormente insertado, vaciar la lista e imprimir.

#ifndef __SLLIST_
#define __SLLIST_

typedef class snode{
    public:
        bool add(int);
        void printList();
        int leer(int);
        bool search(int);
        bool erase(int);
        bool clear();
        bool empty();
        int Menu(int);
        int data;
        class snode * next;
}node;
#endif

Este es el archivo de cabecera que se guarda con la extensión ".h" donde se declara la clase

#include "sllist.h"
#include <iostream>
#include <iomanip>

using namespace std;

node *list = NULL;

bool node::add(int x){
    if(list == NULL){//lista vacia
        list = new node;
        list -> data = x;
        list -> next = NULL;
        return true;
    }
    node *p = list;//lista no vacia
    node *q;
    //buscar lugar de la insercion
    while(p != NULL && p -> data < x){
         q = p;
         p = p -> next;
    }//insercion por el final de la lista
    if(p == NULL){
        node *aux = new node;
        aux -> data = x;
        aux -> next = NULL;
        q -> next = aux;
    }//insercion
    //el nuevo dato ya existente
    else{
        if(p -> data == x)
            return false;
        if(p == list){//agregacion por el inicio
            node *aux = new node;
            aux -> data = x;
            list = aux;
            aux -> next = p;
        }
        else{//gregacion a la mitad de la lista
            node *aux = new node;
            aux -> data = x;
            q -> next = aux;
            aux ->next = p;
        }
    }
    return true;
}

int node::leer(int dato){    
    cin>>dato;
    return dato;
}

void node::printList(){
    node *p = list;
    while (p != NULL){
        cout<<setw(4)<<p -> data;
        p = p ->next;
    }
    cout<<endl;
}

bool node::search(int x){
     node *p = list;
     while(p != NULL && p -> data <= x){
         if(p -> data == x)
             return true;
         else
             p = p -> next;
     }
     return false;
}    

bool node::erase(int x){//Mal
    node *p = list;
    node *q;
    while((p != NULL) && (p -> data <= x)){
        if(p -> data == x){
            if(p == list)
                list = p -> next;                
            else{
                q -> next = p -> next;
                delete p;
                return true;
            }
        }
        else{
            q = p;
            p = p -> next;
        }   
    }
    return false;   
}

bool node::clear(){
    node *q;
    while(list != NULL){
        q = list;
        list = list -> next;
        delete q;
    }
    list = NULL;
    return true;
}

bool node::empty(){
     return list == NULL; 
}

En este archivo se hacen los métodos para la inserción, búsqueda, eliminación y vaciado de la lista.

#include "sllist.h"
#include <cstdlib>
#include <iostream>

using namespace std;

int Menu(int opcion){
     cout<<"1)agregar\n";
     cout<<"2)buscar\n";
     cout<<"3)eliminar\n";
     cout<<"4)vaciar lista\n";
     cout<<"5)verificar si la lista esta vacia\n";
     cout<<"6)Imprimir Lista\n";
     cout<<"7)Salir\n"; 
     cout<<"\n\nOpcion: ";
     cin>>opcion;
     return opcion;
}

int main(){
    node n;
    int x;
    int opcion;
    do{
        opcion = Menu(opcion);
        switch(opcion){
            case 1:
                 cout<<"Ingresa el dato: ";
                 x = n.leer(x);
                 if(n.add(x)){       
                     cout<<"El dato fue insertado";
                     n.printList();
                 }
                 else
                     cout<<"el dato no fue insertado\n";
                 break;
            case 2:
                 x = n.leer(x);
                 if(n.search(x)){ 
                     cout<<"El dato fue encontrado";
                     n.printList();
                 }
                 else
                     cout<<"el dato no fue encontrado\n";
                 break;
            case 3:
                 x = n.leer(x);
                 if(n.erase(x)){
                     cout<<"El dato fue eliminado";
                     n.printList();
                 }
                 else
                     cout<<"el dato no fue encontrado\n";
                 break;
            case 4:
                 if(n.clear()){ 
                     cout<<"la lista esta vacia";
                     n.printList();
                 }
                 else
                     cout<<"la lista aun no esta vacia";
                 break;
            case 5:
                 if(n.empty()){ 
                     cout<<"la lista esta vacia";
                     n.printList();
                 }
                 else
                     cout<<"la lista no esta vacia";
                 break;
            case 6:
                 n.printList();
                 break;
            case 7:
                 n.clear();
                 return 0;
                 break;    
            default: 
                 cerr<<"Error";
                 break;
        }
        cin.get();
        cin.get();
        system("cls"); 
    }while(opcion != 7);    
    return EXIT_SUCCESS;
}

Al final el archivo Main donde se muestra un ejemplo del uso de esta lista.