Ayer hablábamos en el grupo de Facebook sobre Java en Español (¿¿Qué todavía no estás apuntado???) sobre el cálculo de el número feliz con Java. Pero, ¿qué es un número feliz? Si seguimos la descripción de la wikipedia sobre el número feliz, este es aquel que, de forma iterativa, en la suma de sus dígitos acaba resultando un 1.

Es decir, para el caso del número 7, que es un número feliz, la secuencia sería la siguiente:

7² = 49
4² + 9² = 97
9² + 7² = 130
1² + 3² + 0² = 10
1² + 0² = 1

Así que nos ponemos manos a la obra para resolver este planteamiento de el número feliz con Java.

Lo primero que vemos es que hay que extraer los dígitos del número. Esto ya lo explicábamos en el artículo Dígitos de un número con Java. Así que es bueno que lo leas en detalle. Si bien, lo que hacemos es utilizar divisiones y el módulo del 10 (división y resto) para ir extrayendo los números del dígito.

public static int[] digitosNumero(int iNumero){
 
  // Creamos un array del tamaño del número de dígitos del número
  String x = Integer.toString(iNumero);
  int[] iNumeros = new int[x.length()];
 
  // Método que devuelve los dígitos de un número
  int iDigito = 0;
  while (iNumero>0){
    iNumeros[iDigito] = iNumero%10;
    iNumero = iNumero/10;
    iDigito++;
  }
 
  return iNumeros;
 
}

Al final hemos construido un método que dado un entero nos devuelve un array con los dígitos de dicho número.

Lo siguiente será, por cada dígito del número hacer la suma de los cuadrados de los dígitos. Para calcular los cuadrados utilizamos el método .pow() de la clase Math.

Recuerda que la clase Math es estática y no hace falta instanciarla.

El código de esta suma de dígitos al cuadrado sería:

int[] iNumeros = digitosNumero(iNumero);
iSuma = 0;
for (int x=0;x<iNumeros.length;x++)
  iSuma += Math.pow(iNumeros[x],2);

Ahora hay que validar si la suma es un uno o si no saldremos del bucle. En el caso de que no sea un uno volvemos a llamar a la función digitosNumero para que nos vuelva a "trocear" el nuevo número.

while (iSuma!=1){
  iSuma = 0;		
 
  for (int x=0;x<iNumeros.length;x++)
    iSuma += Math.pow(iNumeros[x],2);				
 
  iNumeros = digitosNumero(iSuma);
}

Con esto ya tendríamos nuestro código que calcule si un número es un número feliz con Java terminado. Pero hay una cosa que se puede mejorar, y es que si el número no es feliz se mete en una secuencia infinita de calculos, ya que nunca encontrará el 1. Si bien, podemos cortar este bucle si se repite un número en la secuencia, ya que volverá a la misma secuencia.

Veamos el caso del número 2:

2² = 4
4² = 16
1² + 6² = 37
3² + 7² = 58
5² + 8² = 89
8² + 9² = 145
1² + 4² + 5² = 42
4² + 2² = 20
2² + 0² = 4

Al llegar al número 4 que ya estaba en la serie, todo se volverá a repetir de forma infinita. Es por ello que en este punto habría que cortar el cálculo.

Para implementar esto lo que hemos hecho es añadir un conjunto, es decir, un Set al programa, al cual vamos metiendo los números, siempre y cuando el número sumado no esté. Ya que si esta significará que la secuencia se vuelve a repetir y hay que salir del bucle.

Instanciamos el Set mediante una clase HashSet.

Set<Integer> iCalculados = new HashSet<Integer>();

Y en mitad del bucle hacemos la comprobación o inserción en el conjunto. Para ello utilizamos los métodos .contains y .add

if (iCalculados.contains(new Integer(iSuma)))
  bRepetido = true;
else
  iCalculados.add(new Integer(iSuma));

Vemos que aparece una variable bRepetido y es que esta será el flag que utilicemos para salirnos del bucle. Así que finalmente nuestro bucle de cálculo quedará de la siguiente forma:

while ((iSuma!=1) && !(bRepetido)){
  iSuma = 0;
  for (int x=0;x<iNumeros.length;x++)
    iSuma += Math.pow(iNumeros[x],2);
  iNumeros = digitosNumero(iSuma);
 
  // Controlamos si ha salido un número repetido. Para no entrar en el bucle.
  if (iCalculados.contains(new Integer(iSuma)))
    bRepetido = true;
  else
    iCalculados.add(new Integer(iSuma));
 }

Ya solo nos quedará imprimir si el número es un número feliz o no. Esto nos lo cuenta la variable bRepetido.

if (bRepetido)
  System.out.println(iNumero + " NO es un número feliz");
else
  System.out.println(iNumero + " SI es un número feliz");

Similar Posts:

• Dígitos de un número
• Validador de RUT en Java
• Validar un CIF en Javascript
• Último dígito de un número con Java
• Mayor de dos números

Estaba haciendo unas pruebas con ficheros y no había caído en que el directorio con el que estaba trabajando tenía algunos ficheros ocultos que no estaba moviendo.cY me he dicho, porqué no escribir unas pequeñas líneas de código con Java para listar los ficheros ocultos de un directorio. Y es que el programa es muy sencillo.

Te recomiendo que empieces echando un ojo al artículo que explica como listar los ficheros de un directorio con Java. Ya que la base del listado de ficheros está en ese ejemplo.

Lo siguiente será saber que el método que nos dice si un fichero es oculto o no es .isHidden(). Algo que, por otro lado, cabía esperar. Así que listemos los ficheros del directorio.

String sDirectorio = "d:\\test";
File f = new File(sDirectorio);
 
if (f.exists()){
	File[] ficheros = f.listFiles();
	for (int x=0;x<ficheros.length;x++){
		System.out.println(ficheros[x].getName());
	}
} else{
	System.out.println("No existe ese directorio");
}

Con este código hemos listado todos los ficheros. Si queremos listar los ocultos añadimos el método .isHidden() sobre el objeto File sobre el que estamos iterando.

if (f.exists()){
	File[] ficheros = f.listFiles();
	for (int x=0;x<ficheros.length;x++){
		if (ficheros[x].isHidden())
			System.out.println(ficheros[x].getName());
	}
} else{
	System.out.println("No existe ese directorio");
}

Algo muy sencillo y útil para no dejarnos o encontrar esos ficheros ocultos.

En los siguientes artículos intentaremos hablar de todas las novedades que trae Java SE 7 sobre la gestión de ficheros.Similar Posts:

• Listar un directorio con Java
• Borrar un directorio con Java
• Obtener directorio padre de un fichero
• Listar un directorio de forma recursiva en Java
• Copiar directorio con Java

Antes de iniciar a explicar el codigo, tengo que señalar que tanto la clase HashSet como la clase HashMap tienen una ventaja la cual es, que los valores que se van insertando en la coleccion internamente no tendran un orden especifico, esto se debe a que estas clases realizan un ordenamiento interno mediante el hashcode de el elemento(Objeto), por lo cual no sabremos que elemento traerá.

Esto nos da una ventaja para nosotros que es poder sobrescribir el metodo .hashCode() y .equals() para asi, si tenemos un objeto que tienen sus mismas caracteristicas y mismo hashcode no se agregue a la colección , una de las principales ventajas de este metodo es la rapidez en la insercion de los elemento si tenemos cientos de elementosque agregar, esta coleccion es la indicada para este trabajo.

El algoritmo de busqueda de un elemento en la colecion es el siguiente

1. Encuentra el elemento (Objeto) mediante el hashcode. Imagínense varios personas en un salon con la misma edad.
2. Ya que encontro el elemento mediante el hashcode se realiza la comparacion si el objeto es igual mediante el método .equals(). Imaginen que en ese mismo salon se esta buscando a una persona con un nombre y apellido especifico.

Lo primero será definir un objeto de tipo Alumnos.

public class Alumnos {
    private int age;
    private String name;
 
    Alumnos(String name, int age){
    	this.name = name;
    	this.age = age;
    }
}

Las variables age y name serán las necesarias para que se comparen los objetos y su hashcode.

Lo siguiente que haremos será insertar los objetos Alumnos en un HashSet.

Alumnos person1 = new Alumnos("Juan",18);
Alumnos person2 = new Alumnos("Miguel",25);
Alumnos person3 = new Alumnos("Luis",18);
Alumnos person4 = new Alumnos("Luis",18);
 
HashSet<Alumnos> personas = new HashSet<Alumnos>();
personas.add(person1);
personas.add(person2);
personas.add(person3);
personas.add(person4);

Si verificamos el tamaño del HashSet alumnos veremos que nos devuelve "4", ya que por defecto el HashSet no realiza ninguna comparación.

System.out.println(personas.size());

Ahora agregamos 4 objetos alumno a un HashMap.

Map<Alumnos,String> m = new HashMap<Alumnos,String>();
 
m.put(person1, "valor1");
m.put(person2, "valor2");
m.put(person3, "valor1");
m.put(person4, "mi valor");

El método .size() nos devolvera un tamaño de "4" ya que el HashMap tampoco realiza ninguna comparación. De igual manerá el método .keySet() devuelve todos los elementos del HashMap.

System.out.println(m.keySet());
System.out.println(m.size());

Ahora vamos a cambiar el comportamiento de la clase Alumnos para que al insertarlo en un HashMap o en un HashSet se valide si el elemento insertado ya existe.

Sobrescribimos el método .equals() de tal manera que dos objetos Alumno serán iguales si coinciden sus nombres.

@Override
public boolean equals(Object o) {
  if (o instanceof Alumnos) {
    Alumnos p = (Alumnos)o;
    return this.name.equals(p.name);
  } else {
    return false;
  }
}

De igual manera sobrescribimos el método .hashCode(). Para generar el hascode utilizamos la variable edad y la longitud del String, consiguiendo así un entero.

@Override
public int hashCode() {
  return age * this.name.length();
}

Ahora, una vez sobrescritos los métodos .hashCode() y .equals(), si verificamos el tamaño del HashSet alumnos veremos que nos devuelve "3" ya que, si hay un elemento igual, el metodo .add() devolvera false.

Map<Alumnos,String> m = new HashMap<Alumnos,String>();

De igual manera el método .size() sobre el HashMap.keySet() los nombres de 3 alumnos ya que el método .put() habrá devuelto false al insertar objetos iguales.

System.out.println(m.keySet());
System.out.println(m.size());

Una cosa que hay que tener en cuenta es que si se sobreescribe solo uno de sus metodos ya sea .hashCode() o .equals() no tendremos el comportamiento deseado. Hay que sobrescribir los dos.Similar Posts:

• Número de ocurrencias en un array
• Calcular la moda de una distribución con Java
• Máximo y mínimo número de un conjunto
• Elemento maximo y minimo de un conjunto con Objetos
• Listar un conjunto

Hoy les traigo una forma de poder ejecutar un comando de consola en Java. La clave para ejecutar un comando en Java esta en los métodos exec(String command) y exec(String[] cmdarray).

La diferencia entre estos dos métodos Java es que el primero esta destinado a ejecutar comandos sin argumentos:

try {
	String cmd = "halt"; //Comando de apagado en linux
	Runtime.getRuntime().exec(cmd);
} catch (IOException ioe) {
	System.out.println (ioe);
}

Y el segundo si, solo que deben poner cada 'palabra' en un índice distinto en el arreglo Java:

try {
	String [] cmd = {"shutdown","-s","-t", "10"}; //Comando de apagado en windows
	Runtime.getRuntime().exec(cmd);
} catch (IOException ioe) {
	System.out.println (ioe);
}

Recordar que el comando se va a ejecutar en un proceso Java aparte.

Otra cosa a tener en cuenta es el retorno que brindan estos métodos. Para ello tenemos el objeto de tipo Process.

La clase Process posee algunos métodos interesantes, en especial el metodo public abstract InputStream getInputStream(), ya que con él podemos obtener un Stream para poder leer lo que el comando que ejecutamos escribío en la consola.

Process process = Runtime.getRuntime().exec("lsb_release -a");
InputStream inputstream = process.getInputStream();
BufferedInputStream bufferedinputstream = new BufferedInputStream(inputstream);

En mi caso, obtuve el siguiente texto al leer las lineas del buffer.

Distributor ID:	Ubuntu
Description:	Ubuntu 11.10
Release:	11.10
Codename:	oneiric

Espero que les haya gustado el artículo.Similar Posts:

• Multiplicar dos números con Java
• Como descargar un archivo en Java
• Pasar parámetros a una aplicación Java
• Lectura de caracteres por consola en Java
• Dividir dos números con Java

Vamos a ver como construir un método con Java al cual le pasemos un número de tres dígitos: unidades, decenas y centenas y nos lo transforme a texto. Es decir, el 534 nos lo transforme en "quinientos treinta y cuatro".

Lo primero será crear métodos de apoyo. El primer método de apoyo es el que dado una unidad nos la transforma en texto.

public static String unidadEnTexto(int iNumero){
// Método que dado un número me lo devuelve en texto
 switch(iNumero){
	case 1:
		return "uno";
	case 2:
		return "dos";
	case 3:
		return "tres";
	case 4:
		return "cuatro";
	case 5:
		return "cinco";
	case 6:
		return "seis";
	case 7:
		return "siete";
	case 8:
		return "ocho";
	case 9:
		return "nueve";
	case 0:
		return "cero";
	default:
		return "";
 }
}

El siguiente será el de las decenas. Es decir, le pasaremos un número que represente las decenas y nos devolverá el texto. Si le pasamos un 2 nos devolverá "veinte".

public static String decenaEnTexto(int iDecena){
  switch (iDecena){
	case 1:
		return "diez";
	case 2:
		return "veinte";
	case 3:
		return "treinta";
	case 4:
		return "cuarenta";
	case 5:
		return "cincuenta";
	case 6:
		return "sesenta";
	case 7:
		return "setenta";
	case 8:
		return "ochenta";
	case 9:
		return "noventa";
	default:
		return "";
  }
}

Todas las decenas las podemos montar con el texto de la decena y el texto de la unidad, añadiendo un "y" en medio. Así 22 sería "veinte y dos". Hay un caso especial a tener en cuenta y este es el de las decenas del diez. Así que para ese caso nos montamos otro método de apoyo.

public static String decenas(int iDecena){
  switch (iDecena){
	case 11:
		return "once";
	case 12:
		return "doce";
	case 13:
		return "trece";
	case 14:
		return "catorce";
	case 15:
		return "quince";
	case 16:
		return "dieciseis";
	case 17:
		return "diecisiete";
	case 18:
		return "dieciocho";
	case 19:
		return "diecinueve";
	default:
		return "";
  }
}

Y lo último igual para las centenas. Si bien es verdad que aquí solo se nos devolverá el relativo a los cientos, quinientos y novecientos. Ya que para el testo de centenas lo podemos montar mediante la unidad y añadiendo el sufijo cientos. Así tendremos dos-cientos, tres-cientos,...

public static String centenaEnTexto(int iCentena){
  switch (iCentena){
	case 1:
		return "ciento";
	case 5:
		return "quinientos";
	case 9:
		return "novecientos";
	default:
		return "";
  }
}

Ahora solo nos queda desmontar el número e ir llamando a las funciones de apoyo necesarias. Para ir obteniendo por dígitos nos apoyamos en el módulo y división de 10. Ya que el módulo nos deja el dígito y la división el resto del número.

Así, para las unidades sería:

int iUnidad = iNumero%10;
iNumero = iNumero/10;
sTexto = unidadEnTexto(iUnidad);

La conversión de la unidad ha sido sencilla ya que solo hemos tenido que llamar al método unidadEnTexto.

Vamos con las decenas, para obtener la decena el mismo mecanismo que antes.

int iDecena = iNumero%10;
iNumero = iNumero/10;
 
if ((iUnidad==0) && (iDecena>0))
	sTexto = decenaEnTexto(iDecena);
else if (iDecena==1)
	sTexto = decenas(10+iUnidad);
else if (iDecena > 1)
	sTexto = decenaEnTexto(iDecena) + " y " + sTexto;

Aqui tenemos tres casos.

• Si la unidad era un cero, pedimos la decena y será el texto único.
• Si la decena empieza por uno, caso especial y por lo tantto llamamos al método de las decenas.
• Otros casos componemos con la decena y la unidad juntas con un "y".

El último caso, las centenas.

int iCentena = iNumero%10;
 
if ((iCentena!=1) && (iCentena!=5) && (iCentena!=9) && (iCentena!=0))
	sTexto = unidadEnTexto(iCentena) + "cientos" + " " + sTexto;
else if ((iCentena==1) || (iCentena==5) || (iCentena==9))
	sTexto = centenaEnTexto(iCentena) + " " + sTexto;

En este caso solo hay el dilema del 1, 5 y 9. Así que un if y solucionado. El resto de las centenas las montamos con la unidad en texto más el texto "cientos".

Así, finalmente, hemos dejado en sTexto el número convertido a texto con Java.Similar Posts:

• Calcular el número feliz con Java
• Sumatorio de un numero de forma recursiva
• Tablas de multiplicar recursivas en Java
• Notas Americanas
• Calcular signo del zodiaco con Java

Ya vimos en un ejemplo los pasos que hay que seguir para conectarse a un FTP mediante un programa en Java. Con ese código veíamos como acceder al directorio raíz del FTP. Para ello utilizábamos las librerías Apache Commons.

Ahora vamos a ver cómo podemos acceder con Java a un directorio concreto del FTP para acceder a su información.

Lo primero de todo será conectarnos al FTP. Así que creamos una clase FTPClient.

FTPClient client = new FTPClient();
client.connect(sFTP);
boolean login = client.login(sUser,sPassword);

Los métodos connect() y login() nos permiten establecer la conexión y el login sobre el servidor del FTP.

Una vez conectados al servidor FTP podemos ver el directorio al que estamos conectados mediante el método printWorkingDirectory().

System.out.println(client.printWorkingDirectory());

Ahora pasaremos a cambiar de directorio dentro del servidor. En este caso vamos a apoyarnos en el método changeWorkingDirectory() indicándole el directorio al que queremos cambiar como parámetro.

client.changeWorkingDirectory("\\httpdocs");
System.out.println(client.printWorkingDirectory());

De esta forma y después de acceder al directorio, ya podemos operar sobre él.

Para finalizar nuestro código Java no podemos olvidarnos de desconectarnos del servidor.

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

Similar Posts:

• Conectarse a un FTP con Java
• Saber si una ruta es un directorio con Java
• Directorio Temporal del Sistema en Java
• Listar un directorio con Java IO
• Conocer el directorio de trabajo de Java

Como mi primera colaboración en Linea de Codigo les voy a presentar una forma muy simple para poder descargar cualquier archivo desde Java.

Sin duda, es una solución simple a un problema relativamente recurrente, pero que con un poco de maña pueden hacer algo muy poderoso, y quizás hasta profesional, como lo es un programa Auto-Actualizable.
(Abajo del todo les cuento un poco sobre mi experiencia sobre este tema.)

Pero primero es lo primero, y para empezar vamos a necesitar los siguientes elementos Java para realizar una descarga.
Estos son:

String url = "http://i.imgur.com/HZ1hq.jpg"; //dirección url del recurso a descargar
String name = "lineadecodigo.jpg"; //nombre del archivo destino

Por cuestiones de prolijidad y organización está bueno que los archivos sean destinados a una carpeta especial encargada de almacenarlos, en vez de que anden dando vueltas por ahí.

Lo siguiente que debemos hacer en nuestro programa Java es crear la carpeta destino, si es que esta no existe. En caso de no poder crearla el programa se abortará, ya que si no puede crear una carpeta, es muy probable que tampoco pueda crear el archivo destino de la descarga.

//Directorio destino para las descargas
String folder = "descargas/";
 
//Crea el directorio de destino en caso de que no exista
File dir = new File(folder);
 
if (!dir.exists())
  if (!dir.mkdir())
    return; // no se pudo crear la carpeta de destino

Por como esta planteado, si ya existía un archivo con el mismo nombre que el archivo destino, este va a ser reemplazado, con el uso del metodo public boolean exists() se puede solucionar.

Además, tengan en cuenta que el método public boolean renameTo(File dest) no funciona bien en Windows, siempre retornara false y nunca hará su cometido. Esto lo digo por si quieren usar archivos con un nombre temporal, puede que tengan problemas a la hora de renombrarlo.

Una vez hecho esto estamos en condiciones de empezar la descarga del archivo elegido en Java.

Esto se realiza de la siguiente forma:

1. Crear el archivo destino.
2. Establecer la conexión con la url.
3. Abrir los streams necesarios.
4. Leer y escribir hasta encontrar el fin del archivo.
5. Cerrar los streams (¡Importante!).

Creamos el archivo destino, en caso de existir lo elimina:

File file = new File(folder + name);

Establece la conexion con la url mediante una clase URLConnection:

URLConnection conn = new URL(url).openConnection();
conn.connect();
System.out.println("\nempezando descarga: \n");
System.out.println(">> URL: " + url);
System.out.println(">> Nombre: " + name);
System.out.println(">> tamaño: " + conn.getContentLength() + " bytes");

Abrimos los Stream:

InputStream in = conn.getInputStream();
OutputStream out = new FileOutputStream(file);

Mediante un bucle vamos leyendo del InputStream y vamos escribiendo en el OutputStream. Vamos leyendo de a un byte por vez y los escribe en un archivo. El -1 significa que se llego al final.

int b = 0;
while (b != -1) {
  b = in.read();
  if (b != -1)
    out.write(b);
}

Cerramos los streams:

out.close();
in.close();

En todo el código de manejo del URLConnection y de los Stream debemos de controlar las excepciones MalformedURLException e IOException.

try {
 ...
} catch (MalformedURLException e) {
  System.out.println("la url: " + url + " no es valida!");
} catch (IOException e) {
  e.printStackTrace();
}

Un poco mas sobre programas auto-actualizables. ¿Cuál es la clave de esto?

1. Conseguir un servidor (como googlecode) que permita almacenar archivos en una url que no se vea modificada entre cambios.
2. Una forma de versionado, por mas simple que sea, para poder reconocer si hay versiones nuevas o no.

De esta forma, podrían almacenar en un txt una lista de direcciones url correspondientes a los archivos que deben ser actualizados. Entonces, descargan ese txt, luego lo recorren como a cualquier archivo y por cada url que encuentre en él, inicien una descarga. Finalmente, reemplazan esos archivos con sus predecesores y mediante un dialogo le piden al usuario que reinicie el programa y luego lo cierran con:

System.exit (0);

O algo por el estilo.

Esto, sinceramente, les va a solucionar muchos problemas en cuanto a tiempo, ya que pueden actualizar sus programas directamente desde la comodidad de su casa.

¿Se les ocurre alguna otra utilidad? ¿Le harían alguna modificación al código Java?Similar Posts:

• Crear la ruta de un fichero con Java
• Evitar que un programa Java se cargue dos veces
• Renombrar un fichero con Java IO
• Copiar directorio con Java
• Saber si una ruta es un directorio con Java

En el dia de hoy les explicare como formatear una fecha en Java. Lo primero que haremos será usar una de las clases de el paquete java.text. Esta clase es DateFormat. De igual manera utilizaremos la clase Date y Locale del paquete java.util.

Un detalle de la clase DateFormat de Java es que es abstracta por lo cual usaremos metodos estaticos para que nos devuelvan una instancia de la clase. en caso de usar el codigo les recuerdo realizar los import de las clases necesarias

Lo primero crearemos una instancia de la clase Date:

Date date = new Date();

Crearemos una instancia de la clase Locale. Como ven ingrese parametros al constructor los cuales especifican el lenguaje y pais respectivamente. Ingrese al constructor parametros para que muestre la fecha en Brasil (pt,BR).

Locale locBR = new Locale("pt","BR");

Ahora creamos un array de DateFormat.

DateFormat[]df = new DateFormat[4];

A cada una de las posiciones le damos una instancia de DateFormat. El metodo getDateInstance regresa una instancia:

df[0]= DateFormat.getDateInstance(DateFormat.MEDIUM);
df[1]= DateFormat.getDateInstance(DateFormat.LONG);
df[2]= DateFormat.getDateInstance(DateFormat.SHORT);
df[3]= DateFormat.getDateInstance(DateFormat.LONG, locBR );

A cada una de las instancias le pasamos constantes, de cualquier forma, hay mas constantes las cuales podrias revisar en el API y hacer prueba. A la última de las instancias le pasamos el locale para que me de formato en el país.

Recordar que como DateFormat es abstracta no podemos hacer esto new DateFormat().

Por último hacemos un loop para iterar sobre el array y damos el formato a la fecha que habiamos creado arriba

for(DateFormat d : df)
  System.out.println(d.format(date));

Similar Posts:

• Obtener la fecha en un JSP
• Obtener fecha de modificación de un fichero con Java
• Obtener fecha actual con Java
• Convertir una cadena a fecha en Javascript
• Fecha en castellano con VBScript

Hoy les explicaré un método en Java que hice para invertir arrays simples.

En él haremos lo siguiente

1. Clase llamada InvertirArray
2. Declararemos un array de tipo Object llamado invertir_int
3. Un método llamado invertir(Object[] arg0)
4. Un método que nos devolverá el arreglo invertido llamado getArreglo_invertido()
5. Y el Main para probar

La definición de la clase Java queda así:

 public class InvertirArray {}

Ya sabes que dentro de las llaves haremos todo lo demas.

Seguimos con la declaración del array de tipo Object. Este array nos servirá para invertir el array inicial.

private static Object[] invertir_int;

Luego construimos el método que invertirá el array:

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

Lo que hacemos es instanciar un array con el tamaño del array que hay que invertir y luego recorreremos dicho array de atrás adelante para ir creando el array invertido.

Luego el método que nos devuelve el arreglo

public static Object[] getArreglo_invertido() {
        return InvertirArray.invertir_int;
    }

y finalmente una simple forma de usar este método:

public static void main(String args[]) {
 
        Object[] arreglo = new Object[5];
 
        arreglo[0] = 0;
        arreglo[1] = 1;
        arreglo[2] = 2;
        arreglo[3] = 3;
        arreglo[4] = 4;
 
        for (int i = 0; i < arreglo.length; i++) {
            Object j = arreglo[i];
            System.out.println("Arreglo Normal: " + j);
        }
 
        try {
            invertir(arreglo);
        } catch (Exception e) {
            System.out.println("Error: "+e.getMessage());
        }
 
        for (int i = 0; i < invertir_int.length; i++) {
            Object j = invertir_int[i];
            System.out.println("Arreglo invertido: " + j);
        }
    }

Similar Posts:

• Validador de RUT en Java
• Simple navegador web en C# Framework 2.0
• Constantes en Java
• La conjetura capicua con Java
• Hola Mundo en Java

Hoy un artículo sencillo pero de mucha utilidad. Como bien sabéis, dependiendo del sistema operativo que estemos utilizando en Java, las rutas de los ficheros (llamados path) se crean de diferente forma.

Así cuando creemos una ruta para un sistema operativo Windows pondremos:

c:\midirectorio\mifichero.txt

Mientras que si estamos en un sistema Linux utilizaremos:

/midirectorio/mifichero.txt

Es por ello que tenemos que tener especial cuidado en construir la ruta del fichero en nuestro programa Java. Para poder resolver esto tenemos varias alternativas. La primera sería chequeando las propiedades del sistema "os.name" y "file.separator" con .getProperty().

String so = System.getProperty("os.name");
String separador = System.getProperty("file.separator");

En el caso de "os.name" obtenemos el nombre del sistema operativo y en el caso de "file.separator" obtenemos el separador de directorios. Así, montar nuestra ruta de un fichero sería:

sPath = separador + sDirectorio + separador + sFichero;
System.out.println(sPath);

Pero, si no queremos consultar las propiedades del sistema, tenemos la constante File.separator. La cual tiene almacenado el separador de directorios del sistema operativo sobre el que nos ejecutemos. De esta forma construir la ruta de un fichero se haría de la siguiente manera:

String sPath = File.separator + sDirectorio + File.separator + sFichero;
System.out.println(sPath);

Hay que tener un poco de cuidado con la versión de Java que utilices, ya que File.separator solo está disponible desde Java 5.

¿Cual de las dos formas utilizarías? ¿Conoces alguna más?Similar Posts:

• Separador de directorios en Java
• Obtener ruta absoluta de un fichero
• Vaciar el contenido de un fichero mediante borrado y creación
• Conocer el tamaño de un fichero con Java
• Borrar un directorio con Java