En esta guía aprenderemos a obtener información de los recursos sistema en Java, usando la librería Sigar. Los datos que podremos extraer son los siguientes:

• Información de la CPU.
• Espacio en disco disponible.
• Cantidad de espacio que consume un directorio en específico.
• Cantidad de memoria RAM disponible y en uso.
• Información de red (dirección IP, nombre de la NIC, puertos abiertos, tablas de enrutamiento, etc.)
• Información de los procesos que se están ejecutando en el sistema.
• Asignación de variables de entorno.
• Uptime, o cantidad de tiempo que el equipo ha estado encendido.
• Nombre y versión del sistema operativo.
• Usuarios logueados actualmente.

Resaltadas en negrita está la información en la que nos concentraremos en el ejemplo. Pero antes aclaremos un poco que es Sigar: el API de Sigar nos proporciona una serie de métodos que nos permiten obtener información del sistema operativo; consta de una librería de Java (.jar) y otras librerías nativas específicas para cada sistema operativo soportado (libsigar-amd64-linux.so, para Linux de 64 bits o sigar-x86-winnt.dll para Windows de 32 bits, por poner un ejemplo).

Teniendo esto en cuenta, para hacer funcionar dicha API en una de nuestras aplicaciones, bastaría con tener el archivo .jar y la librería específica de nuestro sistema operativo. En el desarrollo del ejemplo se usará Eclipse y, aunque se explicará cómo añadir las librerías en el proyecto, se da por conocido el funcionamiento del flag --classpath de los comandos javac y java (obligatorio si no se usa ningún IDE).

El resultado…

Siempre pongo primero el resultado ya que nos aclara la visión de hacia donde vamos, y de paso saber si lo que está aquí es lo que buscamos. Esta es la salida del programa en mi Gentoo Linux:

====Informacion del sistema====
Descripcion del SO	Gentoo 2.1.6
Nombre del SO		Linux
Arquitectura del SO	x86_64
Version del SO		2.6.31-gentoo
Nivel de parches	unknown
Fabricante		Gentoo
Version SO		2.1.6
Encendido durante:	6:15

==== Informacion de la CPU ====
Fabricante:		Intel
Modelo			Core(TM)2 Duo CPU     T5750  @ 2.00GHz
Mhz			1994
Total CPUs		2
CPUs fisiscas		1
Nucleos por CPU		2
Tamanio cache		2048

Consumo de CPU 0	22.0%
Consumo de CPU 1	2.0%
Consumo total de CPU	6.0%

====Informacion del sistema de archivos====

dispos.|total|usado|disponible|%uso|dir|tipo

/dev/root|24042944|10698228|12123376|47%|/|ext4
/dev/sda1|175457764|155825380|10719932|94%|/home|ext3

====Informacion de la memoria====
Cantidad de memoria RAM: 3968MB
Total: 4056984
Usada: 2307076
Disponible: 1749908
Memoria SWAP total: 1052248
Memoria SWAP usada: 0
Memoria SWAP libre: 1052248

Descargar Sigar

Puedes descargar Sigar de la página oficial: http://support.hyperic.com/display/SIGAR/Home que incluye además ejemplos para Java, Perl, C, Python, Ruby, y más. Puedes además descargar el código fuente que se encuentra licenciado bajo la GPL2.

Creación del proyecto en Eclipse

Voy a usar este ejemplo para además enseñar a manipular librerías externas en Eclipse; si lo que te interesa es conocer el código, puedes saltarte a dicha sección directamente.

Creamos un proyecto en Eclipse llamado InfoSistema:

Ahora creamos una carpeta dentro del proyecto llamada lib, en donde guardaremos las librerías de Sigar (.jar, .so, .dll, etc.):

Ahora descomprimimos el archivo que descargamos de Sigar, y copiamos los archivos que se encuentran en la carpeta sigar-bin/lib a la carpeta lib de nuestro proyecto. En mi caso la copia la hice con este comando:

Cabe resaltar que bastaría con copiar el archivo llamado sigar.jar y la librería del sistema donde vamos a correr nuestro programa (libsigar-amd64-linux.so en mi caso).

Una vez hecha la copia, hacemos clic en la raiz del proyecto en Eclipse y presionamos F5 para actualizar el árbol de ficheros; de esta manera Eclipse sabrá de los nuevos archivos que hemos copiado. Y lo que haremos a continuación será enlazar la librería sigar.jar a nuestro proyecto, para lo cual hacemos clic derecho en el mismo, Build Path -> Configure Build Path…

En la ventana que aparece, seleccionaremos la pestaña Libraries y hacemos clic en el botón Add JARs… Seleccionamos el archivo sigar.jar y hacemos clic en OK:

Ahora que la librería se encuentra añadida, podemos utilizar el API que Sigar nos ofrece. ¡Pasemos entonces al código!

Información del sistema…

La siguiente clase nos permite obtener información del sistema operativo, como el nombre, la versión, la arquitectura, etc. Creamos una nueva clase llamada InfoSO con el siguiente código:

import org.hyperic.sigar.OperatingSystem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoSO {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() {
		OperatingSystem sys = OperatingSystem.getInstance();
		System.out.println("Descripcion del SO\t" + sys.getDescription());
		System.out.println("Nombre del SO\t\t" + sys.getName());
		System.out.println("Arquitectura del SO\t" + sys.getArch());
		System.out.println("Version del SO\t\t" + sys.getVersion());
		System.out.println("Nivel de parches\t" + sys.getPatchLevel());
		System.out.println("Fabricante\t\t" + sys.getVendor());
		System.out.println("Version SO\t\t" + sys.getVendorVersion());
		try {
			imprimirUptime();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
	public void imprimirUptime() throws SigarException {
		double uptime = sigar.getUptime().getUptime();
		String resultado = "";
		int dias = (int) uptime / (60 * 60 * 24);
		int minutos, horas;
		if (dias != 0)
			resultado += dias + " " + ((dias > 1) ? "dias" : "dia") + ", ";
		minutos = (int) uptime / 60;
		horas = minutos / 60;
		horas %= 24;
		minutos %= 60;
		if (horas != 0)
			resultado += horas + ":" + (minutos < 10 ? "0" + minutos : minutos);
		else
			resultado += minutos + " min";
		System.out.println("Encendido durante:\t" + resultado);
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para recuperar información del sistema operativo es OperatingSystem.
• Con los métodos getName y getDescription obtenemos el nombre del sistema operativo y descripción (por ejemplo: nombre = Linux; descripción = Gentoo 2.1.6).
• El método getUptime de la clase Sigar nos permite conocer cuanto tiempo ha estado prendido el equipo analizado.

Información de la CPU…

La siguiente clase nos permitirá conocer el modelo del procesador, sus capacidades, la cantidad de núcleos y el uso de los mismos, etc. Creamos una nueva clase llamada InfoCPU con el siguiente código:

import org.hyperic.sigar.CpuInfo;
import org.hyperic.sigar.CpuPerc;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoCPU {
	private Sigar sigar;

	public void imprimirInfoCPU() {
		sigar = new Sigar();
		CpuInfo[] infos = null;
		CpuPerc[] cpus = null;
		try {
			infos = sigar.getCpuInfoList();
			cpus = sigar.getCpuPercList();
		} catch (SigarException e) {
			e.printStackTrace();
		}

		CpuInfo info = infos[0];
		long tamanioCache = info.getCacheSize();
		System.out.println("Fabricante:\t\t" + info.getVendor());
		System.out.println("Modelo\t\t\t" + info.getModel());
		System.out.println("Mhz\t\t\t" + info.getMhz());
		System.out.println("Total CPUs\t\t" + info.getTotalCores());
		if ((info.getTotalCores() != info.getTotalSockets())
				|| (info.getCoresPerSocket() > info.getTotalCores())) {
			System.out.println("CPUs fisiscas\t\t" + info.getTotalSockets());
			System.out
					.println("Nucleos por CPU\t\t" + info.getCoresPerSocket());
		}

		if (tamanioCache != Sigar.FIELD_NOTIMPL)
			System.out.println("Tamanio cache\t\t" + tamanioCache);
		System.out.println("");

		for (int i = 0; i < cpus.length; i++)
			System.out.println("Consumo de CPU " + i + "\t"
					+ CpuPerc.format(cpus[i].getUser()));

		try {
			System.out.println("Consumo total de CPU\t"
					+ CpuPerc.format(sigar.getCpuPerc().getUser()));
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Aspectos importantes:

• Se deben usar objetos de CpuInfo y CpuPerc que proporcionan los métodos para recuperar información del procesador. Dichos objetos se crean a partir de un objeto principal de tipo Sigar.
• Para extraer información acerca del procesador usamos los métodos de la clase CpuInfo (por ejemplo getVendor o getModel).
• Los datos específicos de cada núcleo de nuestro procesador se extraen con los métodos de la clase CpuPerc (getUser para obtener el uso de un núcleo, por ejemplo).

Información del sistema de archivos…

La siguiente clase nos permite obtener información del sistema de archivos: unidades montadas, espacio en disco, tipo de sistema de archivos, etc. Creamos una nueva clase llamada InfoSistemaArchivos con el siguiente código:

import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;
import org.hyperic.sigar.FileSystem;
import org.hyperic.sigar.FileSystemUsage;
import org.hyperic.sigar.NfsFileSystem;
import org.hyperic.sigar.SigarProxy;
import org.hyperic.sigar.SigarProxyCache;

public class InfoSistemaArchivos {
	private SigarProxy proxy;
	private Sigar sigar;

	public InfoSistemaArchivos() {
		sigar = new Sigar();
		proxy = SigarProxyCache.newInstance(sigar);
	}

	public void imprimirInfo() throws SigarException {
		FileSystem[] listaSistemaArchivos = proxy.getFileSystemList();
		System.out.println("\ndispos.|total|usado|disponible|%uso|dir|tipo\n");
		for (int i = 0; i < listaSistemaArchivos.length; i++)
			imprimirSistemaArchivos(listaSistemaArchivos[i]);
	}

	public void imprimirSistemaArchivos(FileSystem sistemaArchivos)
			throws SigarException {
		long usado, disponible, total, porcentaje;

		try {
			FileSystemUsage uso;
			if (sistemaArchivos instanceof NfsFileSystem) {
				NfsFileSystem nfs = (NfsFileSystem) sistemaArchivos;
				if (!nfs.ping()) {
					System.out.println(nfs.getUnreachableMessage());
					return;
				}
			}
			uso = sigar.getFileSystemUsage(sistemaArchivos.getDirName());

			usado = uso.getTotal() - uso.getFree();
			disponible = uso.getAvail();
			total = uso.getTotal();

			porcentaje = (long) (uso.getUsePercent() * 100);
		} catch (SigarException e) {
			// por ejemplo, si en al procesar D:\ en windows falla
			// con "Device not ready"
			usado = disponible = total = porcentaje = 0;
		}

		String porcentajeUso;
		if (porcentaje == 0)
			porcentajeUso = "-";
		else
			porcentajeUso = porcentaje + "%";

		System.out.print(sistemaArchivos.getDevName());
		System.out.print("|" + total);
		System.out.print("|" + usado);
		System.out.print("|" + disponible);
		System.out.print("|" + porcentajeUso);
		System.out.print("|" + sistemaArchivos.getDirName());
		System.out.println("|" + sistemaArchivos.getSysTypeName());
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para obtener información de una unidad en específico es FileSystem.
• El método getDevName nos devuelve el nombre del dispositivo referenciado por el objeto de la clase FileSystem.
• Los métodos getTotal y getAvail devuelven un long que representa el espacio total del dispositivo y espacio disponible, respectivamente.
• Para conocer el tipo de sistema de archivos (ext4, ntfs, fat, btrfs, etc.) utilizamos el método getSysTypeName.

Información de la memoria…

La siguiente clase nos permite conocer la cantidad de memoria RAM que tiene el equipo, así como la que se está usando actualmente (tanto memoria física como virtual, aka, swap). Creamos una nueva clase llamada InfoMemoria con el siguiente código:

import org.hyperic.sigar.Mem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.Swap;
import org.hyperic.sigar.SigarException;

public class InfoMemoria {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() throws SigarException {
		Mem memoria = sigar.getMem();
		Swap intercambio = sigar.getSwap();

		System.out.println("Cantidad de memoria RAM: "+ memoria.getRam() + "MB");

		System.out.println("Total: "+enBytes(memoria.getTotal()));
		System.out.println("Usada: "+enBytes(memoria.getUsed()));
		System.out.println("Disponible: "+enBytes(memoria.getFree()));

		System.out.println("Memoria SWAP total: "+enBytes(intercambio.getTotal()));
		System.out.println("Memoria SWAP usada: "+enBytes(intercambio.getUsed()));
		System.out.println("Memoria SWAP libre: "+enBytes(intercambio.getFree()));

	}
	private Long enBytes(long valor) {
		return new Long(valor / 1024);
	}
}

Aspectos importantes:

• La clase Mem nos proporciona métodos para obtener información de la memoria del sistema.
• La clase Swap hace lo mismo que Mem, pero para la memoria virtual.
• Los métodos getTotal y getUsed nos devuelven un long que representa (en bits) la cantidad de memoria del equipo y lo que está usando, respectivamente.

La clase main…

El main de nuestro proyecto estará contenido en la clase InfoSistema:

import org.hyperic.sigar.SigarException;
public class InfoSistema {
	public static void main(String[] args) {
		try {
			System.out.println("====Informacion del sistema====");
			new InfoSO().imprimirInfo();
			System.out.println("\n==== Informacion de la CPU ====");
			new InfoCPU().imprimirInfoCPU();
			System.out.println("\n====Informacion del sistema de archivos====");
			new InfoSistemaArchivos().imprimirInfo();
			System.out.println("\n====Informacion de la memoria====");
			new InfoMemoria().imprimirInfo();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Eso es todo, solo nos queda ejecutar el proyecto y, opcionalmente, crear un archivo .jar para ejecutar en cualquier lado.

Descargas…

• Descarga del código fuente usado en esta entrada
• Descargar librerías de Sigar de SourceForge

Siempre olvido cómo generar salida coloreada en la consola, y por lo tanto pierdo tiempo buscando en Internet. Así que, aprovechando que tengo fresco dicho tema, mejor dejo un listado y las instrucciones con el ánimo de que sea útil para alguien (y para mi, por supuesto).

• Negro 0;30
• Gris oscuro 1;30
• Azul 0;34
• Azul resaltado 1;34
• Verde 0;32
• Verde resaltado 1;32
• Cian 0;36
• Cyan resaltado 1;36
• Rojo 0;31
• Rojo resaltado 1;31
• Púrpura 0;35
• Púrpura resaltado 1;35
• Café 0;33
• Amarillo 1;33
• Gris 0;37
• Blanco 1;37

Ejemplos…

Si lo vas a probar usando el comando echo, debes ejecutarlo con el parámetro -e:

echo -e 'Esto es \e[0;31mrojo\e[0m y esto es \e[1;34mazul resaltado\e[0m'

Resultado: 

echo -e 'Así se escribe \e[1;34mG\e[0m\e[1;31mo\e[0m\e[1;33mo\e[0m\e[1;34mg\e[0m\e[1;32ml\e[0m\e[1;31me\e[0m'

Resultado:

Como puedes observar, se trata de poner lo que quieras colorear entre los caracteres de escape \e[CODIGOm y \e[0m.

BigInteger y BigDecimal son clases envoltura de los tipos primitivos int y double, sin embargo tienen ventajas sobre los tipos primitivos. Cuando necesites usar números grandes en Java la mejor opción es usar estas clases, ya que su limite de almacenamiento es el límite de memoria que tenga la máquina virtual de Java.

Además, estas clases proporcionan algunos métodos bastante interesantes, como las operaciones básicas o saber si el número es primo o no. Como siempre vamos con algunos ejemplos de apoyo:

Operaciones básicas con la clase BigInteger

En el siguiente ejemplo se hace uso de los métodos add, substract, multiply y divide para realizar las operaciones básicas de suma, resta, multiplicación y división:

import java.math.BigInteger;
public class PruebaOperacionesBasicas {
    public static void main(String args[]){
        BigInteger entero1 = BigInteger.valueOf(45);
        BigInteger entero2 = BigInteger.valueOf(15);
        //sumar con metodo add()
        String texto = "La suma entre "+entero1+
                " y "+entero2+" es "+entero1.add(entero2);
        //restar con metodo substract()
        texto += "\nLa resta entre "+entero1+
                " y "+entero2+" es "+entero1.subtract(entero2);
        //multiplicar con metodo multiply()
        texto += "\nEl producto de "+entero1+
                " y "+entero2+" es "+entero1.multiply(entero2);
        //dividir con metodo divide()
        texto += "\nLa división de "+entero1+
                " y "+entero2+" entre "+entero1.divide(entero2);
        System.out.println(texto);
    }
}

Números primos en Java

Este es un típico ejercicio que nos plantean en la universidad; se trata de hacer un listado de los primeros X números primos. En este caso BigInteger nos proporciona dos métodos muy interesantes: isProbablePrime y nextProbablePrime. El primero de ellos devuelve true si el número es probablemente primo (recordemos que es complejo saber si un número es o no primo cuando es demasiado grande); el segundo devuelve el próximo posible número primo a partir del valor que contenga el objeto.

La siguiente aplicación usa el método nextProbablePrime para listar los primeros 2000 números primos:

import java.math.BigInteger;
public class PruebaNumerosPrimos {
    public static void main(String args[]){
        //iniciar el entero en cero
        BigInteger entero = BigInteger.ZERO;
        StringBuffer texto = new StringBuffer();
        for(int i = 0; i<2000; i++){
            entero = entero.nextProbablePrime();
            texto.append(entero+"\n");
            entero.add(BigInteger.ONE);
        }
        System.out.println(texto);
    }
}

Otros métodos interesantes

La clase BigInteger proporciona además otros métodos que nos ahorrarán bastante tiempo y líneas de código:

• pow, nos permite elevar un número a la potencia que deseemos.
• comparteTo, nos permite comparar si un BigInteger es mayor, igual o menor que otro.
• min y max, nos permiten saber cuál de los dos BigInteger es menor o mayor.

Como mencioné al principio, también es posible usar la clase BigDecimal que funciona de manera similar pero con números de coma flotante.

Descargar código fuente de ejemplos

En el siguiente ejemplo se muestra cómo realizar búsquedas dentro de un arreglo de manera lineal.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
namespace BusquedaLineal
{
   public class BusquedaLineal : Form
   {
      private Button botonBuscar;
      private TextBox cajaEntrada;
      private Label labelSalida;
      int[] a = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26,
                  28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50 };
      public BusquedaLineal()
      {
         InitializeComponent();
      }
      private void InitializeComponent()
      {
         this.botonBuscar = new Button();
         this.cajaEntrada = new TextBox();
         this.labelSalida = new Label();
         this.SuspendLayout();
         //
         // botonBuscar
         //
         this.botonBuscar.Location = new System.Drawing.Point(8, 8);
         this.botonBuscar.Name = "botonBuscar";
         this.botonBuscar.TabIndex = 0;
         this.botonBuscar.Text = "Buscar";
         this.botonBuscar.Click += new System.EventHandler(this.botonBuscar_Click);
         //
         // cajaEntrada
         //
         this.cajaEntrada.Location = new System.Drawing.Point(96, 9);
         this.cajaEntrada.Name = "cajaEntrada";
         this.cajaEntrada.Size = new System.Drawing.Size(88, 20);
         this.cajaEntrada.TabIndex = 1;
         this.cajaEntrada.Text = "";
         //
         // labelSalida
         //
         this.labelSalida.Location = new System.Drawing.Point(8, 40);
         this.labelSalida.Name = "labelSalida";
         this.labelSalida.Size = new System.Drawing.Size(184, 23);
         this.labelSalida.TabIndex = 2;
         //
         // BusquedaLineal
         //
         this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
         this.ClientSize = new System.Drawing.Size(200, 69);
         this.Controls.AddRange(new Control[] {
                  this.labelSalida,
                  this.cajaEntrada,
                  this.botonBuscar});
         this.Name = "BusquedaLineal";
         this.Text = "BusquedaLineal";
         this.ResumeLayout(false);
      }
      static void Main()
      {
         Application.Run(new BusquedaLineal());
      }
      private void botonBuscar_Click( object sender,
         System.EventArgs e )
      {
         int datoBuscar = Int32.Parse( cajaEntrada.Text );
         int indiceElemento = BuscarLineal( a, datoBuscar );
         if ( indiceElemento != -1 )
            labelSalida.Text =
               "Encontrado en el indice " + indiceElemento;
         else
            labelSalida.Text = "Valor no encontrado";
      } // fin del metodo botonBuscar_Click
      // buscar valor dentro del array
      public int BuscarLineal( int[] array, int dato )
      {
         for ( int n = 0; n < array.Length; n++ )
         {
            if ( array[ n ] == dato )
               return n;
         }
         return -1;
      } // fin del metodo BusquedaLineal
   }
}

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar el ordenamiento de arreglos de enteros, usando el método burbuja en C#.

Ejemplo…

using System;
public class OrdenamientoBurbuja
{
  static void Main()
  {
     int[] a =  { 54, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
     string salida = "Valores de los items originales\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     // ordenar elementos del arreglo
     OrdenarBurbuja( a );
     salida += "\n\nValores de los items en orden descendente\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     Console.WriteLine(salida);
  } // fin del metodo main
  // ordenar elementos de un arreglo con el metodo burbuja
  static public void OrdenarBurbuja( int[] b )
  {
     for ( int pasadas = 1; pasadas < b.Length; pasadas++ ) // pasadas
        for ( int i = 0; i < b.Length - 1; i++ )
           if ( b[ i ] > b[ i + 1 ] )      // comparar
              intercambio( b, i );         // intercambiar
  }
  // intercambio de dos elementos en un arreglo
  static public void intercambio( int[] c, int primero )
  {
     int temp;      // variable temporal para el intercambio
     temp = c[ primero ];
     c[ primero ] = c[ primero + 1 ];
     c[ primero + 1 ] = temp;
  }
}

Resultado…

Descargar código fuente

Ejemplos básicos de manipulación de arreglos en C#

Sumar elementos de un array

Sinopsis: hacer la sumatoria de los elementos de un arreglo.

using System;
class SumarArreglo
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     int total = 0;
     for ( int i = 0; i < a.Length; i++ )
        total += a[ i ];
     Console.WriteLine( "Suma de todos los elementos del array: " + total);
  } // fin de Main
} // fin de la clase SumarArreglo

Resultado…

Descargar código fuente

Creacion de histogramas

Sinopsis: crear un histograma (barras a base de asteriscos) a partir de unos datos.

using System;
class Histograma
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] n = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
     string salida = "Elemento\tValor\tHistograma\n";
     // construir salida
     for ( int i = 0; i < n.Length; i++ )
     {
        salida += "\n" + i + "\t\t\t" + n[ i ] + "\t\t";
        for ( int j = 1; j <= n[ i ]; j++ ) // imprimir una barra
           salida += "*";
     }
     Console.WriteLine( salida);
  } // fin Main
} // fin de la clase Histograma

Resultado…

Descargar código fuente

Estadisticas de notas de estudiantes

Sinopsis: apartir de un arreglo de notas (puntajes) identificar la frecuencia de cada una de ellas entre todos los estudiantes.

using System;
class EncuestaEstudiantes
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] respuestas = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1,
        6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7,
        5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };

     int[] frecuencia = new int[ 11 ];
     string salida = "";

     // incrementar la frecuecia de para cada respuesta
     for ( int j = 0; j < respuestas.Length; j++ )
        ++frecuencia[ respuestas[ j ] ];

     salida += "Puntaje\tFrecuencia\n";

     // resultados
     for ( int puntaje = 1; puntaje < frecuencia.Length; puntaje++ )
        salida += puntaje + "\t\t" + frecuencia[ puntaje ] + "\n";

     Console.WriteLine( salida);

  } // fin Main

} // fin de la clase EncuestaEstudiantes

Resultado…

Descargar código fuente

El siguiente es un pequeño programa que usando el método getenv de la clase System, devuelve información del sistema operativo y de las variables de entorno. La salida del mismo es algo como esto:

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

Descargar código

Se trata de una implementación chichi del famoso Juego de la Vida en Java, ya que Burnhack me ha picado con el gusanillo de la curiosidad En fin… el programa simula un espacio de células que cumplen con las reglas básicas del juego, permite dibujar nuevos patrones, generar granjas aleatorias, y poner en marcha automática o manualmente. De paso me sirvió para explicarle a mis hermanos el porqué del emblema hacker

Puedo decir que me divertí mucho programando, y que a la vez me da pena no haber podido dedicarle más de tres días: el resultado es un programa que funciona bien cuando se ejecuta de manera normalita, pero con la opción de zoom hay problemas. Y aquí les doy un par de consejos: puesto que al principio el programa lo iba a hacer junto con Burnhack, utilicé una clase que él utilizaba llamada BufferedImage (para dibujar las figuras). Luego, cuando me dí cuenta de que no entendía ni mierda nada del código de mi amigo, decidí hacer la lógica desde cero; y aquí van los consejos:

• Hacer comentarios es SUPREMAMENTE IMPORTANTE, sobre todo cuando se programa en grupo
• Cuando hagas este tipo de proyectos es mejor que uses Canvas; yo caí en cuenta muy tarde y ya me da flojera arreglarlo

Por supuesto, el programa está disponible para que lo estudien, lo copien, lo regalen, etc. Espero le sirva a alguien. Les quedo debiendo la explicación porqué es algo largo

Nota: los iconos los he tomado de Icojoy

Compilación y ejecución…

#compilación
javac Glider.java
#ejecución normal
java Glider
#ejecución con la característica zoom (umm, que mal programador soy )
java Glider –zoom

Descargar código fuente

En este artículo utilizaré un pequeño ejemplo para explicar cómo manipular documentos XML usando XERCES Java Parser. En este primer ejemplo usaré el API DOM, y la utilizaremos para generar un archivo XML y guardarlo en disco, y posteriormente procesaremos (parsearemos) dicho archivo para leer su información.

Nota: Sino tienes claro qué es un parser XML, qué es un API XML para Java y cuáles están disponibles, o aún tienes algunas dudas en relación con Java y XML, puedes/debes leer este pequeño artículo.

Generación de archivos XML usando Xerces

En esta ocasión utilizaremos el API DOM para generar un archivo XML, que guardará información acerca de un listado de descargas ficticio. Como resultado, nuestra aplicación generará el siguiente documento XML:

<?xml version="1.0" encoding="ISO-8859-1"?>
<Descargas>
    <descarga id="1">
        <titulo>Libros Java</titulo>
        <ruta>http://casidiablo.net/libros.zip</ruta>
        <hits>2546</hits>
    </descarga>
    <descarga id="2">
        <titulo>Libros C Sharp</titulo>
        <ruta>http://casidiablo.net/libroscs.zip</ruta>
        <hits>1654</hits>
    </descarga>
</Descargas>

En el cual tenemos un elemento llamado descarga que contiene un atributo llamado id; además posee tres nodos hijos: titulo, ruta y hits. Teniendo en cuenta esto crearemos un pequeño bean (clase Descargas.java), que contiene dichos datos:

public class Descargas {
    //Variables
    private int id;
    private String titulo;
    private String ruta;
    private int hits;
    //Constructor de la clase
    public Descargas(int id, String titulo, String ruta, int hits){
        this.id = id;
        this.titulo = titulo;
        this.ruta = ruta;
        this.hits = hits;
    }
    //Metodos Setters y Getters
    public void setID(int id) {
        this.id = id;
    }
    public int getID() {
        return this.id;
    }
    //etc... (AL FINAL DEL ARTÍCULO PUEDES DESCARGAR EL EJEMPLO COMPLETO)
}

Más adelante utilizaremos la clase GenerarXML.java, quien se encargará de crear el archivo XML. De momento detallaremos los pasos básicos para realizar tareas de ese tipo:

• Crear los objetos a cargar en el documento XML (en nuestro ejemplo, objetos tipo Descargas)
• Crear un objeto Document que contendrá el documento XML
• Generar los datos XML para los objetos creados en primer paso
• Crear un archivo (o salida) XML

En nuestro ejemplo, la invocación a los métodos que realizan estas tareas se encuentra en el método main:

public static void main(String args[])
{
   GenerarXML generador = new GenerarXML();
   // A. Crear el objeto(s) a Descargas
   Descargas descarga = new Descargas(1, "Libros Java", "http://casidiablo.net/libros.zip", 2546);
   Descargas descarga2 = new Descargas(2, "Libros C Sharp", "http://casidiablo.net/libroscs.zip", 1654);
   // B. Generar un documento XML usando Document
   generador.generaDocumentoXML();
   // C. Generar XML para el/los objeto(s)
   generador.generarDocumentoXMLDescarga(descarga);
   generador.generarDocumentoXMLDescarga(descarga2);
   // D. Obtener el código XML
   String textoXML = generador.obtenerTextoXML();
   generador.guardarDocumentoXML(textoXML);
   System.out.println(textoXML);
}

Veamos con más profundidad cómo funciona el segundo paso (Crear un objeto Document que contendrá el documento XML):

public void generaDocumentoXML() {
    try {
        // 1. Crear objeto DocumentBuilderFactory
        DocumentBuilderFactory dbFactory = DocumentBuilderFactoryImpl.newInstance();
        // 2. A partir del objeto DocumentBuilderFactory crear un objeto DocumentBuilder
        DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();
        // 3. Generar el documento XML
        documentoXML = docBuilder.newDocument();
    } catch (Exception e) {
        System.out.println("Error : " + e);
    }
    // 4. Crear el elemento "descargas"
    descarga = documentoXML.createElement(TAG_DESCARGAS);
    // 5. Agregar al documento principal
    documentoXML.appendChild(descarga);
}

1. Creamos un objeto DocumentBuilderFactory, utilizando la el método newInstance() de la clase DocumentBuilderFactoryImpl.
2. Creamos un objeto DocumentBuilder, con el que crearemos el objeto Document
3. Generamos el documento usando el método newDocument() de DocumentBuilder
4. Se crea el elemento raíz del documento XML y,
5. Se añade dicho elemento al objeto Document

Después de esto, ya tenemos listo nuestro objeto Document en donde crearemos el documento XML. El paso siguiente será alimentar el documento XML con la información de nuestros objetos, lo cual se hace en el método generarDocumentoXMLDescarga:

public void generarDocumentoXMLDescarga(Descargas descargas)
{
    Element elemento;
    Element item;
    // 1. Crear elemento
    elemento = documentoXML.createElement(TAG_DESCARGA);
    // 2. Asignar un atributo
    elemento.setAttribute(TAG_ID, ""+descargas.getID());
    // 3. Aniadir elemento al documento
    descarga.appendChild(elemento);
    // a. Crear item
    item = documentoXML.createElement(TAG_TITULO);
    // b. Asignar un dato al item
    item.appendChild(documentoXML.createTextNode(descargas.getTitulo()));
    // c. Aniadir el item
    elemento.appendChild(item);
    // todos los items se crean sigiuendo el patron a, b, c
    // el código fuente completo se encuentra
    //disponible para su descarga al final de este artículo
}

1. Se crea un elemento (<descarga>)
2. Se asigna un atributo al elemento (<descarga id=”xxx”>)
3. Se añade el elemento al documento XML; posteriormente tenemos la creación de items, para dicho elemento:
   a. Se crea el item (<titulo></titulo>)
   b. Se asigna un dato al item (<titulo>datos, muchos datos</titulo>)
   c. Se añade el item al elemento (<descarga id=”xxx”><titulo>datos, muchos datos</titulo></descarga>)

Para generar una salida del documento XML se utilizamos el método generaTextoXML() el cual devuelve un string que contiene el documento XML:

private String generaTextoXML() {
   StringWriter strWriter = null;
   XMLSerializer seliarizadorXML = null;
   OutputFormat formatoSalida = null;
   try {
      seliarizadorXML = new XMLSerializer();
      strWriter = new StringWriter();
      formatoSalida = new OutputFormat();
      // 1. Establecer el formato
      formatoSalida.setEncoding(XML_ENCODING);
      formatoSalida.setVersion(XML_VERSION);
      formatoSalida.setIndenting(true);
      formatoSalida.setIndent(4);
      // 2. Definir un objeto donde se generara el codigo
      seliarizadorXML.setOutputCharStream(strWriter);
      // 3. Aplicar el formato
      seliarizadorXML.setOutputFormat(formatoSalida);
      // 4. Serializar documento XML
      seliarizadorXML.serialize(documentoXML);
      strWriter.close();
   } catch (IOException ioEx) {
      System.out.println("Error : " + ioEx);
   }
   return strWriter.toString();
}

1. Utilizando un objeto de la clase OutputFormat, se asigna el tipo de codificación y versión del archivo XML, activamos la identación y la ponemos a 4 espacios
2. Un objeto XMLSerializer escribe los datos del documento XML sobre un objeto de flujo de salida, en este caso un objeto StringWriter.
3. Asignamos el tipo de formato que el objeto XMLSerializer generará
4. Generamos el documento XML

El string generado por generaTextoXML() podemos imprimirlo directamente en pantalla, o escribirlo en un archivo como lo hace el método guardarDocumentoXML():

public void guardarDocumentoXML(String texto) {
   try {
      OutputStream fout = new FileOutputStream(NOMBRE_ARCHIVO_XML);
      OutputStream bout = new BufferedOutputStream(fout);
      OutputStreamWriter out = new OutputStreamWriter(bout, JAVA_ENCODING);
      out.write(texto);
      out.flush();
      out.close();
   } catch (UnsupportedEncodingException e) {
   //etc, bla, bla, catchichurri
}

El método guardarDocumentoXML() un objeto FileOutputStream para escribir los datos del documento XML en un archivo (cuyo nombre define la variable NOMBRE_ARCHIVO_XML).

Continúa leyendo la segunda parte, en donde aprenderemos a Parsear archivos XML. Vamos parce!

CódiLa validación de formularios nos permite asegurarnos que los datos que, por ejemplo, un usuario ingrese en un campo de texto sean válidos. Dicha validación puede hacerse una vez que el usuario haya digitado todos los datos, o mientras el usuario los esté digitando.

Para el primer caso, lo mejor es utilizar expresiones regulares usando el método matches() de la clase String (si necesitas un ejemplo, clic aquí).

Para el segundo caso tendremos que manejar los eventos del teclado que se generen sobre determinado control, usando la interfaz KeyAdapter y el método keyReleased. Así, en nuestro código de ejemplo tenemos un JTextField al que le añadimos un Listener que escuchará los eventos del teclado, y verificará si la tecla presionada es un caractér válido (solo letras), de lo contrario lo elimina.

No hay nada especial en el código de ejemplo salvo por un par de líneas:

• Línea 17: se utiliza el método anidado getToolkit().beep(), que hará que el sistema alerte al usuario con un pitido cada vez que un dato erróneo.
• Línea 25: comparamos el char que digite el usuario con el entero 8, que es el código resultado al usar el Backspace (tecla para borrar hacia la izquierda); lo cual permite al usuario borrar caracteres.

Código…

import java.awt.Robot;
import javax.swing.*;
import java.awt.event.*;
public class SoloLetras extends JFrame {
	private JTextField caja = new JTextField();
	public SoloLetras() {
		super("Solo dejo escribir letras");
		caja.addKeyListener(new KeyAdapter() {
			public void keyReleased(KeyEvent e) {
				Character caracter = new Character(e.getKeyChar());
				if (!esValido(caracter)) {
					String texto = "";
					for (int i = 0; i < caja.getText().length(); i++)
						if (esValido(new Character(caja.getText().charAt(i))))
							texto += caja.getText().charAt(i);
					caja.setText(texto);
					getToolkit().beep();
				}
			}
			public boolean esValido(Character caracter)
			{
				char c = caracter.charValue();
				if ( !(Character.isLetter(c) //si es letra
						|| c == ' ' //o un espacio
						|| c == 8 //o backspace
					))
					return false;
				else
					return true;
			}
		});
		getContentPane().add(caja);
		setSize(300, 60);
		setVisible(true);
	}
	public static void main(String args[]) {
		JFrame.setDefaultLookAndFeelDecorated(true);
		SoloLetras ventana = new SoloLetras();
		ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}

Descargar código fuente