feed twitter facebook LinkedIn facebook

Java » Conocer el directorio de trabajo de Java

Septiembre 14, 2011 por Víctor Cuervo . 226 visitas 1 Comentario Imprimir Imprimir

El directorio de trabajo de Java es el directorio dónde se está ejecutando el programa Java. Si queremos conocer cual es el directorio de trabajo del programa Java podemos utilizar las propiedades del sistema.

Para manejar las propiedades del sistema tenemos la clase System y en concreto el método .getProperty().

La propiedad del sistema que nos permite conocer el directorio de trabajo de Java es "user.dir". Así el código será el siguiente:

String sDirectorioTrabajo = System.getProperty("user.dir");
System.out.println("El directorio de trabajo es " + sDirectorioTrabajo);

¿Qué otras propiedades del sistema conoces y crees que puedes ser útiles?

Java » Conectarse a un FTP con Java

Septiembre 7, 2011 por Víctor Cuervo . 350 visitas 1 Comentario Imprimir Imprimir

La posibilidad de contectarse a un FTP con Java no es una utilidad que nos den las librerías base de Java. Es por ello que para poder acometer esta tarea y conectarnos a un FTP con Java deberemos de utilizar las librerías de Apache Commons. En concreto el componente Net.

Así que lo primero que hay que hacer para pode crear nuestro programa que se conecte a un FTP con Java es decargarnos la librería Net de Apache Commons.

En nuestro código fuente deberemos de realizar un import de esta librería:

import org.apache.commons.net.ftp.FTPClient;

La clase de Apache Commons que nos permitirá crear un cliente FTP con Java es FTPClient. Por lo tanto la primera línea de nuestro programa creará una instancia de esta clase.

FTPClient client = new FTPClient();

Una vez creado el cliente deberemos de conocer tres cosas para poder conectarnos a un FTP con Java. Estas serán:

  • Servidor FTP
  • Usuario
  • Password

Estos datos los utilizaremos en el método .connect y .login del cliente FTP

String sFTP = "ftp.miservidor.com";
String sUser = "usuario";
String sPassword = "password";
 
try {
  client.connect(sFTP);
  boolean login = client.login(sUser,sPassword);
} catch (IOException ioe) {}

Cuando hagamos el login para conectarnos al FTP, este devolverá en un valor booleano si se ha podido conectar o no. Si todo va correctamente ya estaremos conectados.

Una vez que hagamos la operativa que necesitemos con el FTP (lo veremos en otros artículos sobre FTP y Java) deberemos de desconectarnos del FTP.

Para desconectarnos del FTP haremos dos cosas. En primer lugar haremos un logout del usuario y luego nos desconectaremos del servidor. Los método .logout() y .disconnect() nos ayudarán en esta tarea.

client.logout();
client.disconnect();

Ya tendremos todo nuestro código para conectarse (y desconectarse a un FTP con Java).

Hay que tener en cuenta que todo el proceso de conexión al FTP puede generar una excepción IOException. Es por ello que deberemos de tomar las medidas necesarias en una estuctura try-catch.

Recursos » @java en Twitter

Septiembre 1, 2011 por Víctor Cuervo . 146 visitas 1 Comentario Imprimir Imprimir

Si quieres estar al tanto de todas las novedades sobre Java, creo que @java es una cuenta de Twitter que no debes de perderte.

En la cuenta @java de Twitter podemos encontrar publicaciones de artículos, podcast, información de conferencias del mundo Java, preguntas y respuestas, URL de interés,...

Así que ya estás haciéndote follower de @java en Twitter.

¿Qué otra cuentas de Twitter recomendarias sobre Java, HTML, PHP, CSS,...? Comentanoslo e iremos añadiéndolas a nuestro listado.

Java » Pasar parámetros a una aplicación Java

Marzo 1, 2011 por Víctor Cuervo . 5513 visitas 1 Comentario Imprimir Imprimir

Si estamos haciendo una aplicación Java normal hay que saber que se le pueden pasar parámetros de inicialización.

Seguro que muchos habéis reparado en el método main, qué es el método principal de una aplicación Java, y en cómo se describen sus parámetros.

public static void main(String[] args) { ... }

En ese array de String es dónde vamos a encontrar los parámetros de inicialización. Estos parámetros se pasan en la invocación de nuestro programa Java. Así, si tenemos un programa Java que se llama ParametrosJava, la forma de invocarlo desde la línea de comando será la siguiente:

java ParametrosJava parametro1 parametro2 ... parametroN

No existe un orden estandar para los parámetros, si no que según se pongan en la línea de comando, así le llegarán al programa.

Si queremos listar los parámetros que le llegan a la aplicación lo podemos hacer con un bucle for-each

for (String arg : args)
  System.out.println(arg);

Así tendremos el listado entero de parámetros que se le han pasado al programa.

Java » Validador de RUT en Java

Diciembre 9, 2010 por Pablo Ruiz . 6266 visitas 1 Comentario Imprimir Imprimir

El RUT es el Rol Único Tributario es un número único Chileno que sirve como identificador tributario.

El RUT consta de dos partes, el número y el dígito verificador separados por un guión. En el siguiente ejemplo se toma como RUT el número 30.686.957-X, donde 30.686.957 es el número del RUT y X es el dígito verificador que no conocemos o que queremos verificar:

Se procede a tomar el número de RUT de derecha a izquierda, multiplicando cada dígito por los números que componen la serie numérica 2,3,4,5,6,7; y sumando el resultado de estos productos, como se muestra a continuación (si se ha aplicado la serie hasta el 7 y quedan dígitos por multiplicar, se comienza la serie nuevamente):

7 × 2 = 14,
5 × 3 = 15,
9 × 4 = 36,
6 × 5 = 30,
8 × 6 = 48,
6 × 7 = 42,
0 × 2 = 0,
3 × 3 = 9

Entonces la suma de los productos es

14+15+36+30+48+42+0+9 = 194

Para poder hacer con Java esto tenemos que invertir el número:

public static Object[] invertir(Object[] array) {
  Object[] invertir_int = new Object[array.length];
  int maximo = array.length;
 
  for (int i = 0; i < array.length; i++) {
    Object j = array[maximo - 1];
    invertir_int[maximo - 1] = array[i];
    maximo--;
    }
  return invertir_int;
}

Ahora, vamos multiplicando por la serie de números y acumulando la suma en rutSumado.

int a = 2;
for (int i = 0; i < array.length; i++) {
  array[i] = Integer.parseInt((String) array[i]) * a;
  rutSumado += Integer.parseInt(String.valueOf(array[i]));
  if (a == 7) {
    a = 1;
  }
  a++;
}

Al número obtenido por la suma del producto de cada dígito por la serie ya mencionada, se le aplica módulo 11, o sea, se divide por 11 y se determina el resto de la división.

194: 11 = 17
Resto: 7

Ahora a 11 se le resta el resto:

11 - 7 = 4

El código Java sería

int resto = rutSumado % 11;
String Digito = String.valueOf(11 - resto);

Con el valor obtenido:

  • Si el resultado es 11, el dígito verificador será 0.
  • Si el resultado es 10, el dígito verificador será K.
  • En otro caso el resultado será el dígito verificador.

Para hacer esto con Java:

if (Digito.equals("11")) {
  Digito = "0";
}
if (Digito.equals("10")) {
  Digito = "K";
}

Como en el ejemplo el resultado de la resta es 4, el dígito verificador es 4. Por ende, el RUT del ejemplo es el 30.686.957-4.

Saludos, Espero que les sea de ayuda :D

Java » Ventanas con estilo gracias a Substances

Octubre 10, 2010 por Pablo Ruiz . 5589 visitas 2 Comentarios Imprimir Imprimir

Hoy explicaré en simples pasos cómo usar Substance en nuestras aplicaciones, que de hecho es una muy buena forma de darle estilo a nuestras ventanas

¿Que haremos?

Crearemos una ventana simple(JFrame, JTextField, JButton) a código. Sin ayuda de Netbeans u otro programa que solo tienes que arrastrar componentes, que de hecho es una muy buena forma, pero el motivo es enseñar.

Primero que todo haremos una nueva clase llamada "JVentana" que como el nombre lo indica tendrá lo suficiente para crear una ventana y también incluiremos un evento al botón:

public final class JVentana{
...}

Ahora agregamos 3 atributos de tipo JFrame, JTextField, JButton:

private JFrame Frame_principal;
private JTextField textField_texto;
private JButton button_saludo;

Siguiendo de lo antes realizado agregaremos un método llamado "inicializar", que inicializará los atributos que declaramos anteriormente:

public void inicializar(){
  Frame_principal = new JFrame("Sethcrofts para http://www.lineadecodigo.com");
  textField_texto = new JTextField();
  textField_texto.setColumns(40);
  button_saludo = new JButton("Saludar");
}

Explicación del método inicializar:

  1. Creamos el JFrame asigándole un nombre en su constructor
  2. Creamos el JTextField
  3. Seteamos el JTextField para que sea mas largo (por columnas)
  4. Creamos el JButton

Siguiendo lo anterior iremos a crear otro método llamado "agregarComponentes":

public void agregarComponentes(){
  Frame_principal.add(textField_texto);
  Frame_principal.add(button_saludo);
  Frame_principal.setLayout(new FlowLayout());
  Frame_principal.setVisible(true);
  Frame_principal.setResizable(false);
  Frame_principal.pack();
}

Explicación del método agregarComponentes:

  1. Agregamos el JTextField creado al FramePrincipal
  2. Agregamos el JButton creado al FramePrincipal
  3. Seteamos nuestra ventana principal al modo FlowLayout (Alterará la forma en que se ubicarán los componentes en el Frame)
  4. Hacemos visible la ventana principal
  5. Seteamos la opción de redimensionar la ventana (true=SI, false=NO)
  6. Seteamos la ventana principal, para que se adapte al tamaño de nuestros componentes para evitar espacios innesesarios

Ahora lo que nos queda hacer por último es programar nuestro evento para que al hacer click en el botón se genere un mensaje:

public void asignarEventos(){
  button_saludo.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        if(textField_texto.getText().equalsIgnoreCase("")){
            JOptionPane.showMessageDialog(null, "Ingrese un nombre.");
        }else{
            JOptionPane.showMessageDialog(null, "Hola: "+textField_texto.getText());
        }
    }
  });
}

Explicación del método asignarEventos:

  1. Asignamos un evento (ActionListener) al botón (button_saludo), como su nombre lo indica escuchará cada vez que se presione.
  2. Agregamos el método actonPerformed (Si usas Netbeans esa parte se hace por defecto, así que solo tendrás que asignar instrucciones)
  3. Preguntamos que si el textField_texto está vacio que realize la siguiente acción
  4. Desplegamos un mensaje en pantalla (como un alert() en Javascript, MessageBox en .NET )
  5. Si no es así, entonces saludará al nombre ingresado en el text

Y bueno ya casi terminando crearemos nuestro constructor:

public JVentana(){
  inicializar();
  agregarComponentes();
  asignarEventos();
}

Explicación del constructor:

  1. Llamamos al método inicializar
  2. Llamamos al método agregarComponentes
  3. Llamomos al método asignarEventos

Es importante la posición en que pones las llamada a los métodos, porque si pones por ejemplo agregarComponentes se generará un error ya que aún no se han creado los componente

Nuestra clase sería verse algo así :

 
package ejemplosubstance;
 
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
 
public final class JVentana{
 
  private JFrame Frame_principal;
  private JTextField textField_texto;
  private JButton button_saludo;
 
  public JVentana(){
    inicializar();
    agregarComponentes();
    asignarEventos();
  }
 
  public void inicializar(){
    Frame_principal = new JFrame("Sethcrofts para http://www.lineadecodigo.com");
    textField_texto = new JTextField();
    textField_texto.setColumns(40);
    button_saludo = new JButton("Saludar");
  }
 
  public void agregarComponentes(){
    Frame_principal.add(textField_texto);
    Frame_principal.add(button_saludo);
    Frame_principal.setLayout(new FlowLayout());
    Frame_principal.setVisible(true);
    Frame_principal.setResizable(false);
    Frame_principal.pack();
  }
 
  public void asignarEventos(){
    button_saludo.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        if(textField_texto.getText().equalsIgnoreCase("")){
          JOptionPane.showMessageDialog(null, "Ingrese un nombre.");
        }else{
          JOptionPane.showMessageDialog(null, "Hola: "+textField_texto.getText());
        }
      }
    });
  }
}

Luego que tengamos todo listo viene la parte principal de éste tutorial por así decirlo "darle estilo a nuestras ventanas". Para ellos vamos a utilizar Substances.

Lo primero que tenemos que hacer es descargarnos el jar de Substances.

Descargar Substances Version: 5.3

Luego que lo tenemos descargado lo añadimos al proyecto, desconosco la manera en que algunas aplicaciones hacen éste proceso pero Netbeans lo hace de la siguiente manera

  1. Botón derecho sobre Libraries
  2. Add Jar/Folder (Agregar JAR / Carpeta)
  3. Buscamos y seleccionamos nuestro JAR descargado

Luego lo único que tenemos que hacer es nuestro honorable MAIN que quedaría de la siguiente manera:

public static void main(String[] args) {
  java.awt.EventQueue.invokeLater(new Runnable() {
    public void run() {
      try {
        Frame.setDefaultLookAndFeelDecorated(true);
        SubstanceLookAndFeel.setSkin("org.jvnet.substance.skin.OfficeSilver2007Skin");
        new JVentana();
      } catch (Exception e) {
        JOptionPane.showMessageDialog(null, "Error: "+e);
      }
    }
  });
}

Explicaré la dos lineas que son nuevas para ustedes. Sí, "JFrame.setDefaultLookAndFeelDecorated" y "SubstanceLookAndFeel.setSkin"

  1. La primera setea el Frame que vendrá luego a que adopte el decorado de Subtances y que decorado tendrá.
  2. Bueno la segunda linea de encarga del decorado en éste caso es "officeSilver2007Skin"

Si todo va bien deberíamos ver algo así

Java » Palabras que empiecen por…

Septiembre 22, 2010 por Víctor Cuervo . 5565 visitas 1 Comentario Imprimir Imprimir

Por un punto la respuesta, palabras que empiecen por "ca"... Quién no ha jugado a este juego de niños... Vamos a ver como podemos codificar este juego mediante el lenguaje Java.

Lo primero de todo será pedirle al usuario que inserte palabras por consola. Palabras que empiecen por... Para ello utilizamos la clase Scanner, la cual nos permite capturar el dato introducido por el usuario de forma sencilla.

Scanner reader = new Scanner(System.in);
System.out.println("Escribe palabras que empiecen por '" + sInicio + "'");
sTexto = reader.next();

Hemos utilizado una variable sInicio para poder configurar al gusto la palabra que empiece por...

El método .next() nos permite cargar en la variable sTexto lo que el usuario haya escrito.

Ahora hay que comprobar que lo que ha introducido el usuario es una palabra que empieza por... Para ello utilizamos el método .startsWith() de la clase String. Este método devolverá true cuando el inicio de la palabra corresponda al valor pasado como parámetro.

while(sTexto.startsWith(sInicio)) {
  System.out.println("Correcto... " + sTexto);
  System.out.println("Dime otra palabra...");
  sTexto = reader.next();
}

Vemos que si el método .startsWith() devuelve true, felicitamos al usuario y le volvemos a pedir otra palabra. Nuevamente con el método .next()

Solo nos quedará el tener un contador de aciertos para darle una puntuación al usuario

while(sTexto.startsWith(sInicio)) {
  System.out.println("Correcto... " + sTexto);
  contador++;
  System.out.println("Dime otra palabra...");
  sTexto = reader.next();
}

Lecturas » La historia no oficial sobre los Applets de Java

Septiembre 2, 2010 por Víctor Cuervo . 3328 visitas 1 Comentario Imprimir Imprimir

Si estás al tanto de los últimos rifi rafes entre Google y Oracle por un "quítame allá esas patentes" te será interesante la lectura del artículo The unofficial history of Java applets (en inglés).

En el artículo, Yakov Fain, valora cuál será la estrategia de Java con respecto al futuro de las plataformas RIA, añadiendo una comparación de lo que le pasó a Sun Microsystems cuando se enfrentó legalmente a Microsoft y como le pasó factura en su evolución (principalmente en los Applets) y lo que le puede pasar ahora a Oracle que se quiere enfrentar con Google por unas patentes y la plataforma Android.

Además comenta sobre ¿Por qué Oracle quiere volver a la etiqueta APPLET?

¿Los temas legales pasarán nuevamente factura a la plataforma Java? ¿Saldrá perjudicada en la pelea por el pastel de las plataformas RIA?

Leer The unofficial history of Java applets (en inglés)

Noticias Web » Netbeans 6.9

Junio 16, 2010 por Víctor Cuervo . 7798 visitas 4 Comentarios Imprimir Imprimir

Netbeans ya tiene una nueva versión de su IDE, Netbeans 6.9

Dentro de las mejoras que nos proporciona Netbeans 6.9 encontramos:

  • JavaFX Composer, como interface gráfico para construir aplicaciones RIA mediante la tecnología JavaFX. JavaFX Composer soportará drag&drop de componentes y la posibilidad de hacer binding entre los componentes y el modelo de datos.
  • Soporte de la plataforma OSGI
  • Mejoras en los editores y debuggers Java
  • Regeneración de entidades JPA ante cambios de la base de datos.
  • Soporte de REST para Webservices
  • Corrector ortográfico en eleditor.
  • ...

Se mejora el soporte de los frameworks:

  • JavaFX SKD 1.3
  • PHP Zend
  • Ruby on Rails 3.0
  • Spring Framework 3.0

Netbeans está disponible para plataformas Windows, Mac, Linux y Solaris.

Descárgate la nueva versión Netbeans 6.9

Vía: Java Hispano

Noticias Web » Driver JDBC Type 5

Abril 30, 2010 por Víctor Cuervo . 5403 visitas Sin Comentarios Imprimir Imprimir

Progress Software ha lanzado unos nuevos driver JDBC type 5. Los cuales se añaden a los 4 tipos de drivers ya existentes.

Y es que desde 1998, año desde el que están disponibles los driver type 4, no se había trabajado en nuevas especificaciones. Y ya iba siendo hora de tener una pequeña evolución.

Progress Software ha enfocado los driver JDBC type 5 a intentar subsanar las carencias de los driver type 4:

  • Rendimiento lento o inconsistente, el rendimiento en ciertos casos es pobre y  no es consistente entre diferentes tipos de plataformas.
  • Funcionalidades inaccesibles o no disponibles, el ajuste del driver es muy crítico y en ciertas ocasiones se necesita acceso al código JDBC.
  • Excesivo consumo de CPU y de memoria, en el tiempo de acceso a datos.
  • Restricciones en el despliegue de aplicaciones, se requieren de diferentes archivos JAR. Incluso, en algunos casos, el despliegue de DLL. Limitando los entornos en los que se puede desplegar.
  • Implementaciones propietarias, en ciertas implementaciones el soporte de transaccionalidad XA o el soporte de campos CLOB/BLOB requieren código propietario.

Progress Software tiene disponible los driver type 5 para para Oracle, SQL Server, DB2, Sybase, MySQL e Informix. Habrá que probarlos.

Vía: Application Development Trends