Visto en http://www.learncomputer.com/mistakes-java-programmers-make/
Algunos comentarios sobre el articulo en http://www.javahispano.org/portada/2012/11/19/top-5-errores-que-comenten-los-programadores-java.html
Los 5 errores mas comunes de los programadores Java
noviembre 22nd, 2012 | Posted by in Java - (0 Comments)Las muchas formas de usar el patron Singleton en Java
octubre 30th, 2012 | Posted by in Java - (0 Comments)En el muy recomendable sitio howtodoinjava.com han publicado un articulo sobre las muchas maneras que podemos usar el patron Singleton en Java. El autor da un ejemplo de cada una de las formas y explica sus diferencias entre ellas.
Url: http://howtodoinjava.com/2012/10/22/singleton-design-pattern-in-java/
Buenas practicas en Java, malas para Android
octubre 1st, 2012 | Posted by in Android | Java - (1 Comments)Leyendo javahispano.org me encontre con esta presentación de Romain Guy y Chet Haase sobre las diferencias entre crear codigo para interfaces de usuario en java y sus diferencias a la hora de crear interfaces para Android.
JavaRa 2.0 es un programa que nos permite “administrar” nuestra instalacion de java muy facilmente. Es especialmente util para actualizar o desisntalar versiones del JRE. Muchas veces me ha pasado de que alguna aplicacion que estaba desarrollando me empezara a dar errores al momento de actualizar mis versiones de java, con lo cual JavaRa me ha parecido interesante, al menos para probarlo.
Url: http://singularlabs.com/software/javara/javara-download/
Tipos primitivos como byte arrays en java
marzo 8th, 2012 | Posted by in Android | Java - (0 Comments)Estos metodos java le pueden ser utiles a alguien que haya tenido el mismo problema que yo. En una app android necesitaba enviar algunos datos int, double, float y convertirlos a byte arrays, para enviarlos como paquetes usando el protocolo UDP.
Aca van los metodos para tratar tipos y byte arrays.
Enlace Original: http://www.daniweb.com/software-development/java/code/216874
/* ========================= */
/* "primitive type --> byte[] data" Methods */
/* ========================= */
public static byte[] toByta(byte data) {
return new byte[]{data};
}
public static byte[] toByta(byte[] data) {
return data;
}
/* ========================= */
public static byte[] toByta(short data) {
return new byte[] {
(byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(short[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 2];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 2, 2); return byts; } /* ========================= */ public static byte[] toByta(char data) { return new byte[] { (byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(char[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 2];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 2, 2); return byts; } /* ========================= */ public static byte[] toByta(int data) { return new byte[] { (byte)((data >> 24) & 0xff),
(byte)((data >> 16) & 0xff),
(byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(int[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 4];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 4, 4); return byts; } /* ========================= */ public static byte[] toByta(long data) { return new byte[] { (byte)((data >> 56) & 0xff),
(byte)((data >> 48) & 0xff),
(byte)((data >> 40) & 0xff),
(byte)((data >> 32) & 0xff),
(byte)((data >> 24) & 0xff),
(byte)((data >> 16) & 0xff),
(byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(long[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 8];
for (int i = 0; i < data.length; i++)
System.arraycopy(toByta(data[i]), 0, byts, i * 8, 8);
return byts;
}
/* ========================= */
public static byte[] toByta(float data) {
return toByta(Float.floatToRawIntBits(data));
}
public static byte[] toByta(float[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 4];
for (int i = 0; i < data.length; i++)
System.arraycopy(toByta(data[i]), 0, byts, i * 4, 4);
return byts;
}
/* ========================= */
public static byte[] toByta(double data) {
return toByta(Double.doubleToRawLongBits(data));
}
public static byte[] toByta(double[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 8];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 8, 8); return byts; } /* ========================= */ public static byte[] toByta(boolean data) { return new byte[]{(byte)(data ? 0x01 : 0x00)}; // bool -> {1 byte}
}
public static byte[] toByta(boolean[] data) {
// Advanced Technique: The byte array containts information
// about how many boolean values are involved, so the exact
// array is returned when later decoded.
// ----------
if (data == null) return null;
// ----------
int len = data.length;
byte[] lena = toByta(len); // int conversion; length array = lena
byte[] byts = new byte[lena.length + (len / 8) + (len % 8 != 0 ? 1 : 0)];
// (Above) length-array-length + sets-of-8-booleans +? byte-for-remainder
System.arraycopy(lena, 0, byts, 0, lena.length);
// ----------
// (Below) algorithm by Matthew Cudmore: boolean[] -> bits -> byte[]
for (int i = 0, j = lena.length, k = 7; i < data.length; i++) {
byts[j] |= (data[i] ? 1 : 0) << k--;
if (k < 0) { j++; k = 7; }
}
// ----------
return byts;
}
/* ========================= */
public static byte[] toByta(String data) {
return (data == null) ? null : data.getBytes();
}
public static byte[] toByta(String[] data) {
// Advanced Technique: Generates an indexed byte array
// which contains the array of Strings. The byte array
// contains information about the number of Strings and
// the length of each String.
// ----------
if (data == null) return null;
// ---------- flags:
int totalLength = 0; // Measure length of final byte array
int bytesPos = 0; // Used later
// ----- arrays:
byte[] dLen = toByta(data.length); // byte array of data length
totalLength += dLen.length;
int[] sLens = new int[data.length]; // String lengths = sLens
totalLength += (sLens.length * 4);
byte[][] strs = new byte[data.length][]; // array of String bytes
// ----- pack strs:
for (int i = 0; i < data.length; i++) { if (data[i] != null) { strs[i] = toByta(data[i]); sLens[i] = strs[i].length; totalLength += strs[i].length; } else { sLens[i] = 0; strs[i] = new byte[0]; // prevent null entries } } // ---------- byte[] bytes = new byte[totalLength]; // final array System.arraycopy(dLen, 0, bytes, 0, 4); byte[] bsLens = toByta(sLens); // byte version of String sLens System.arraycopy(bsLens, 0, bytes, 4, bsLens.length); // ----- bytesPos += 4 + bsLens.length; // mark position // ----- for (byte[] sba : strs) { System.arraycopy(sba, 0, bytes, bytesPos, sba.length); bytesPos += sba.length; } // ---------- return bytes; } /* ========================= */ /* "byte[] data --> primitive type" Methods */
/* ========================= */
public static byte toByte(byte[] data) {
return (data == null || data.length == 0) ? 0x0 : data[0];
}
public static byte[] toByteA(byte[] data) {
return data;
}
/* ========================= */
public static short toShort(byte[] data) {
if (data == null || data.length != 2) return 0x0;
// ----------
return (short)(
(0xff & data[0]) < < 8 |
(0xff & data[1]) << 0
);
}
public static short[] toShortA(byte[] data) {
if (data == null || data.length % 2 != 0) return null;
// ----------
short[] shts = new short[data.length / 2];
for (int i = 0; i < shts.length; i++) {
shts[i] = toShort( new byte[] {
data[(i*2)],
data[(i*2)+1]
} );
}
return shts;
}
/* ========================= */
public static char toChar(byte[] data) {
if (data == null || data.length != 2) return 0x0;
// ----------
return (char)(
(0xff & data[0]) << 8 |
(0xff & data[1]) << 0
);
}
public static char[] toCharA(byte[] data) {
if (data == null || data.length % 2 != 0) return null;
// ----------
char[] chrs = new char[data.length / 2];
for (int i = 0; i < chrs.length; i++) {
chrs[i] = toChar( new byte[] {
data[(i*2)],
data[(i*2)+1],
} );
}
return chrs;
}
/* ========================= */
public static int toInt(byte[] data) {
if (data == null || data.length != 4) return 0x0;
// ----------
return (int)( // NOTE: type cast not necessary for int
(0xff & data[0]) << 24 |
(0xff & data[1]) << 16 |
(0xff & data[2]) << 8 |
(0xff & data[3]) << 0
);
}
public static int[] toIntA(byte[] data) {
if (data == null || data.length % 4 != 0) return null;
// ----------
int[] ints = new int[data.length / 4];
for (int i = 0; i < ints.length; i++)
ints[i] = toInt( new byte[] {
data[(i*4)],
data[(i*4)+1],
data[(i*4)+2],
data[(i*4)+3],
} );
return ints;
}
/* ========================= */
public static long toLong(byte[] data) {
if (data == null || data.length != 8) return 0x0;
// ----------
return (long)(
// (Below) convert to longs before shift because digits
// are lost with ints beyond the 32-bit limit
(long)(0xff & data[0]) << 56 |
(long)(0xff & data[1]) << 48 |
(long)(0xff & data[2]) << 40 |
(long)(0xff & data[3]) << 32 |
(long)(0xff & data[4]) << 24 |
(long)(0xff & data[5]) << 16 |
(long)(0xff & data[6]) << 8 |
(long)(0xff & data[7]) << 0
);
}
public static long[] toLongA(byte[] data) {
if (data == null || data.length % 8 != 0) return null;
// ----------
long[] lngs = new long[data.length / 8];
for (int i = 0; i < lngs.length; i++) {
lngs[i] = toLong( new byte[] {
data[(i*8)],
data[(i*8)+1],
data[(i*8)+2],
data[(i*8)+3],
data[(i*8)+4],
data[(i*8)+5],
data[(i*8)+6],
data[(i*8)+7],
} );
}
return lngs;
}
/* ========================= */
public static float toFloat(byte[] data) {
if (data == null || data.length != 4) return 0x0;
// ---------- simple:
return Float.intBitsToFloat(toInt(data));
}
public static float[] toFloatA(byte[] data) {
if (data == null || data.length % 4 != 0) return null;
// ----------
float[] flts = new float[data.length / 4];
for (int i = 0; i < flts.length; i++) {
flts[i] = toFloat( new byte[] {
data[(i*4)],
data[(i*4)+1],
data[(i*4)+2],
data[(i*4)+3],
} );
}
return flts;
}
/* ========================= */
public static double toDouble(byte[] data) {
if (data == null || data.length != 8) return 0x0;
// ---------- simple:
return Double.longBitsToDouble(toLong(data));
}
public static double[] toDoubleA(byte[] data) {
if (data == null) return null;
// ----------
if (data.length % 8 != 0) return null;
double[] dbls = new double[data.length / 8];
for (int i = 0; i < dbls.length; i++) {
dbls[i] = toDouble( new byte[] {
data[(i*8)],
data[(i*8)+1],
data[(i*8)+2],
data[(i*8)+3],
data[(i*8)+4],
data[(i*8)+5],
data[(i*8)+6],
data[(i*8)+7],
} );
}
return dbls;
}
/* ========================= */
public static boolean toBoolean(byte[] data) {
return (data == null || data.length == 0) ? false : data[0] != 0x00;
}
public static boolean[] toBooleanA(byte[] data) {
// Advanced Technique: Extract the boolean array's length
// from the first four bytes in the char array, and then
// read the boolean array.
// ----------
if (data == null || data.length < 4) return null;
// ----------
int len = toInt(new byte[]{data[0], data[1], data[2], data[3]});
boolean[] bools = new boolean[len];
// ----- pack bools:
for (int i = 0, j = 4, k = 7; i < bools.length; i++) { bools[i] = ((data[j] >> k--) & 0x01) == 1;
if (k < 0) { j++; k = 7; }
}
// ----------
return bools;
}
/* ========================= */
public static String toString(byte[] data) {
return (data == null) ? null : new String(data);
}
public static String[] toStringA(byte[] data) {
// Advanced Technique: Extract the String array's length
// from the first four bytes in the char array, and then
// read the int array denoting the String lengths, and
// then read the Strings.
// ----------
if (data == null || data.length < 4) return null;
// ----------
byte[] bBuff = new byte[4]; // Buffer
// -----
System.arraycopy(data, 0, bBuff, 0, 4);
int saLen = toInt(bBuff);
if (data.length < (4 + (saLen * 4))) return null;
// -----
bBuff = new byte[saLen * 4];
System.arraycopy(data, 4, bBuff, 0, bBuff.length);
int[] sLens = toIntA(bBuff);
if (sLens == null) return null;
// ----------
String[] strs = new String[saLen];
for (int i = 0, dataPos = 4 + (saLen * 4); i < saLen; i++) { if (sLens[i] > 0) {
if (data.length >= (dataPos + sLens[i])) {
bBuff = new byte[sLens[i]];
System.arraycopy(data, dataPos, bBuff, 0, sLens[i]);
dataPos += sLens[i];
strs[i] = toString(bBuff);
} else return null;
}
}
// ----------
return strs;
}
Leyendo picandocodigo.net hablan sobre esta nueva versón del SDK. Personalmente sólo estoy usando java para android, pero nunca se sabe que nos puede deparar el cliente…
He dejado de trabajar en Java hace un par de años, sin embargo siempre trato de leer el blog javahispano.org, que me ha ayudado mucho en mi anterior vida. En este caso, para lo que aún siguen en tema, les dejo este documento pdf del seminario sobre Hibernate 3.
El proyecto mono supera a Java en aplicaciones cliente Linux
julio 22nd, 2009 | Posted by in Java | Mono - (1 Comments)Vía javahispano.org me entero que la plataforma Mono ha superado a Java en aplicaciones cliente bajo Linux. Otro pequeño golpecillo para el ego de Java.
Url: http://www.sdtimes.com/link/33618 (ingles)
En Javahispano leo sobre este post publicado en theserverside.com llamado “10 good reasons to look for something better than Java“. Aunque ya hace casi 2 años que no utilizo Java para del desarrollo web, la lista esta referida sólamente al lenguaje, que para mi entender es lo menos problematico a la hora de desarrollar proyectos webs.
En mi experiencia, lo que me ha quitado mucho las ganas de volver a trabajar en java para mis proyectos (pequeños y medianos, aclaro) es todo el entorno de apis, frameworks, contenedores y demas carga que viene incluido en un proyecto java, si no queremos usar jsp a “a pelo”.
Sun Microsystems planea lanzar una enorme App Store que dejaría a servicios como el de Apple muy por detrás en tamaño. Según el CEO de Sun, se esperan mejorar las ventas y reavivar el negocio con la nueva Java App Store para PCs. Sun está actualmente sumida en un proceso de absorción por parte de Oracle, quien ha afirmado estar muy interesada en la tecnología Java de Sun y no tanto en el hardware de la marca
Una tienda de aplicaciones que usen el lenguaje de programación de Sun Java tiene un gran potencial debido a los millones de desarrolladores que crean aplicaciones en Java, que lleva en el mercado desde mediados de los noventa. Sun estima que se usan aplicaciones Java en más de 4.500 millones de ordenadores, móviles y otros gadgets. El CEO de Sun, Jonathan Schwartz, ha indicado que en un principio iría enfocada al mercado de PCs, que estima en una comunidad de 1.000 millones de usuarios.
Copyright © 2010 All rights reserved.
Designed by 