Obviamente este no es el foro para preguntar, pero estoy seguro de que aqui hay más informáticos dispuestos a ayudarme que en javahispano.com xD

¿Alguien conoce el lenguje? Quisiera preguntar una cosilla. Si no, tampoco pasa nada.

Un salu2

Pues pregunta !!!!

(yo no tengo ni puta idea) Pero me he quedado con las ganas de saber cual es la duda. :blink:

:yes:

Yo hace mucho que no toco nada de java, pero si quieres poner la duda igual conozco quien la pueda solucionar o tienes suerte y me suena de algo.

O tal vez Dhauf lo sepa... así a Valad se le irá la duda :D

Dispara chaval! :lol: (aunque mejor no te olvides de tu contraseña del foro de javahispano...)

Ole! xD

Pues es una duda de plataforma, quiero añadir en un Writer llamado paco un salto de linea para implementar un algoritmo LZW (el algoritmo es lo de menos, lo digo a titulo ilustrativo), de forma que la salida en vez de
ggogofgofigofio
sea
g
go
gof
gofi
gofio
claro, yo le pongo dentro de un bucle paco.write (Vector(i)+"\n"), lo cual funciona estupendamente en Unix pero en Windows donde deberia salir un salto de linea lo que muestra es un cuadrado.

¿Alguien sabe como hacerlo? Me he sacado las neuronas con el puto UNICODE y nada xD ¡Gracias!

P.D.: Si no lo sabeis, tendré una excusa para ir a tutorias a tratar de ligarme a la profesora xD

La pregunta no es de java exactamente, ahora te escribo de memoria:

- te sale un cuadrado por que probablemente estás usando el notepad o similar para ver el fichero, deberías usar un editor hexadecinmal para ver los codigos ascii del texto.

- para hacer el salto de línea, al menos en windows, necesitas un cr (carriage return) + lf (line feed). Lo que es lo mismo un chr$(13) & chr$(10), ni idea en java, pero es un retorno de carro y un salto de línea (esto viene de cuando se usaban impresoras)

- Supongo que el \n es el salto de línea, deberías averiguar cual es el retorno de carro o incluir los caracteres 13 y 10 directamente.

Igual esto te da la pista.

Lo que ha comentado Karamor me parece una buena prueba y en todo caso lo que yo puedo aportar (y probablemente ya sepas) es que el LineFeed es \f y el retorno de carro \r.

Prueba a sustituir el \n por \r+\f y ver qué pasa. En teoría en Unix seguirá funcionando y tal vez en el puñetero Windows le dé por solucionarse.

PD: ¿ta buena la profe? o ¿pretendes ligártela para sacar mejores notas? Tal vez en este foro puedan darte truquillos también para "como ligarse a la profe sin despeinarse" (sección que por supuesto NO intervendré yo porque se me da fatal :ditasea: )

Gracias muchachos, lo he solucionado gracias a ustedes ^^
Ahora tengo un cutre compresor de textos, que envia la palabra "gofio" como 101 ^^
(También envía Don Quijote de la Mancha eh!!! xD)

Socorro, llevo ya ni se cuanto tiempo intentando sacar esto, el paquete java.lang me lo sé de memoria ya, y no consigo encontrar el modo de hacer algo que sería muy simple en otros lenguajes. Voy a relatar los pasos que doy, a ver si ustedes que son unos cracks ven algo que yo no vea o se les ocurre otro método.

Tengo que conseguir almacenar un numero entero de n bits en una ristra de bytes. Por ejemplo, el número 364.987 sería 1011001000110111011, 19 bits. En principio eso lo hago ya, utilizo el metodo toBinaryString de la clase Integer.

Ese String se lo meto a un StringBuffer para utilizar los métodos substring(comienzo, final) y substring(comienzo), y cortarlo en fragmentos de 1 byte (por ahora 8 caracteres), y un fragmento final si la cantidad original de bits no es múltiplo de 8.

int num = 364987;
System.out.println("Testeo de bits, numero: "+num);
StringBuffer bin = new StringBuffer(Integer.toBinaryString(num));
System.out.println("Cadena binaria: "+bin); //Esto mostraria 1011001000110111011
int trozo1 = bin.length()/8; //Obtenemos 2, las palabras enteras de 1 byte
int trozo2 = bin.length()%8; //Obtenemos 3, el nº de bits sobrantes
int trozos = trozo1 + ((trozo2==0)?0:1); //Si sobran bits, sumamos una palabra más
System.out.println("Longitud: "+bin.length()+", Trozos: "+trozos);

byte byt[] = new byte[trozos]; //Aqui almacenaremos las n palabras

//Este if no es elegante, cuando funcione lo arreglaré xD
if ((bin.length()%8) != 0) {
.....//Guardamos los bits sobrantes en byt[2]
.....byt[2] = (byte)Integer.parseInt (bin.substring((bin.length()/8)*8) ,2);
.....//Esto muestra
.....Trozo 3: 011
.....System.out.println("Trozo 3: "+bin.substring((bin.length()/8)*8));
}

//Aqui recorremos las n palabras de 1 byte y las vamos guardando
for (i=(bin.length()/8); i>0; i--) {
.....byt[i-1] = (byte)Integer.parseInt(bin.substring((i-1)*8,i*8),2);
.....//Esto muestra
.....Trozo 2: 00110111
.....Trozo 1: 10110010
.....System.out.println("Trozo "+i+": "+bin.substring((i-1)*8,i*8));
}

Hasta aqui bien, en byt[] guardo 3 bytes, el menos significativo en byt[2] y el más significtativo en byt[0]. Si saco esos bytes individualmente por pantalla, los resultados serán
byt[0] = -78
byt[1] = 55
byt[2] = 3
Lo que EN PRINCIPIO es un resultado válido para esos datos.

El problema es para reconstruir el entero original, no hay forma humana ni divina de hacerlo. He estado probando con los operadores binarios op1>>op2 y op1<<op2, que ruedan el numero op1 una cantidad op2 de bits a la derecha o a la izquierda respectivamente, algo como

System.out.println("Lectura de bytes");
for (i=byt.length; i>0; i-- ) {
.....m = byt[i-1];
.....m |= m<<((i-1)*8);
}

Pero el OR sobreescribe los datos al poner en complemento a 2 uno de los números y la salida es 11111111111111111111111110110010. Esto se debe a que el supuesto -78 lo complementa a dos, y rellena los 32 bits que tienen los enteros que lo preceden de unos. Y el OR se carga lo que haya con esos unos, claro.

También he probado con

for (i=(byt.length-1); i>-1; i-- ) {
m = byt[i];
System.out.println ("Palabra "+i+": "+Integer.toBinaryString(m));
}

Y el resultado vendria a ser
Palabra 2: 11 //Bien
Palabra 1: 110111 //Se carga los dos 1º ceros, pero es cosa de la representacion. "Realmente" siguen ahi
Palabra 0: 11111111111111111111111110110010
El hijoputa vuelve a complementarlo (logicamente, porque lo he guardado como -78)

¿Alguna sugerencia? ¿Veis lo que yo no veo?
Tengo que guardarlo como ristra de bytes, es indispensable. Esos bytes los leeré de un fichero, por ahora lo estoy haciendo en memoria.

Si podeis, ayudadme o acbaré colgado de un pino. Gracias por adelantado ^^

Vale, ya lo he resuelto. Lo pongo a titulo informativo. Si llego a saber que me iba a salir despues de una pajilla, no gasto tanto tiempo en ponerle colorines al post anterior xD

import java.io.*;
public class a {
public static void main (String args[]) throws IOException{
FileOutputStream fos = new FileOutputStream ("paco");
BufferedOutputStream bos = new BufferedOutputStream (fos);
DataOutputStream out = new DataOutputStream (bos);
int num = 650000;
String bin = Integer.toBinaryString(num);
System.out.println(num + " -> " + bin);
int trozo1 = bin.length()/8;
int trozo2 = bin.length()%8;
int trozos = trozo1 + ((trozo2==0)?0:1);
byte byt[] = new byte[trozos+2];
byt[0] = 127;
byt[1] = (byte)trozos;
int num2 = num;
int i;
for (i = 0; i<trozos; i++) {
byt[i+2] = (byte)num2;
System.out.println((byt[i+2]& 0xff)+ " <- "+ Integer.toBinaryString((byt[i+2]& 0xff)));
out.writeByte (num2);
num2 = num2>>8;
}
num2 = 0;
for (i=trozos-1; i>-1; i--) {
num2 = num2<<8;
num2 = (num2 | (byt[i+2]& 0xff));
}
System.out.println(num2);
out.close();
}
}

Esto... vale! Que todas tus dudas sean como esta (que me ha costado tan poco resolver) :lol: :lol: :lol:

Menos mal que he visto el post cuando estaba resuelto, vaya rollo... :P

Habrás dejado alucinado a unos cuantos :lol:

Pues si...

Me has recordado aquellos tiempos que me dió por aprender de forma autodidacta a programar en Ensamblador, que lios de 0'os y 1'nos.

Cuantas operaciones resueltas con AND.. OR...

Cuantas vueltas a la cabeza cuando estaba programando algo... (yo me llevaba la cabeza llena de codigo, a todas partes, y mas de una vez he resuelto aquello que no me salia sobre las servilletas papel de un bar, ante la mirada asombrada de los colegas de turno)

Ya no programo nada, ni me da por aprender nada nuevo, cosas de no trabajar en el ramo, ni tener tiempo, pero siempre me gustó y viendo este post veo que lo echo de menos... jajaja

Quizas empiece a darle caña al Visual Basic... a ver si hago algo !!!