Tipo de almacenamiento según el tipo de variable (Byte, Int, Double)

Los formatos básicos de codificación de información aceptados por un ordenador son el ASCII y el BINARIO.

Para conocer como es el proceso de almacenamiento de los datos obtenidos por un programa, utilizaremos un algoritmo desarrollado por Ivan Alexander Laverde Gaviria docente de la Universidad Tecnológica de Pereira.

package randomaccessfiledemo;

/**
 *
 * @author IvanAlexander
 */
import java.io.*;

public class RandomAccessFileDemo {

   public static void main(String[] args) {
       int i;

      try {

         // create a new RandomAccessFile with filename test
         RandomAccessFile raf = new RandomAccessFile("c://tmp//test.txt", "rw");

         // Escribiendo cadenas

         raf.writeBytes("Escribiendo cadenas en diferente formato use un editor como el notepad++\n\n");

         raf.writeBytes("Escribiendo una cadena grabada de tipo bytes\n");
         raf.writeChars("Escribiendo una cadena grabada de tipo caracter\n");
         raf.writeUTF("Escribiendo una cadena grabada de tipo UTF\n");

         // Escribiendo en archivo los codigos ascii

         raf.writeBytes("\nEscribiendo los código ascii desde 0 a 255 con un solo byte\n\n");
         for (i=0;i<255;i++) {
             raf.writeByte(i);  // escribe un byte
             raf.writeByte(13); // baja de línea en el caso de los codigos 10 y 13 baja doble linea
         }

         //escribiendo en archivos números de tipo int

         raf.writeBytes("\nEscribiendo números (int) del 1'000.000 al 1'000.100 cada número ocupa 4 bytes \n\n");
         for (i=1000000;i<1000100;i++) {
             raf.writeInt(i);  // escribe un numero
             raf.writeByte(13); // baja línea para mostrar los datos separados
         }

        //escribiendo en archivos números de doble

         raf.writeBytes("\nEscribiendo números (dobles)) del 1'000.000 al 1'000.100 cada número ocupa 8 bytes \n\n");
         for (i=1000000;i<1000100;i++) {
             raf.writeDouble((double)i);  // escribe un numero
             raf.writeByte(13); // baja línea para mostrar los datos separados
         }

         raf.close();

      } catch (IOException ex) {
         ex.printStackTrace();
      }
   }
}

El algoritmo usa la clase RandomAccessFile, utilizada para acceder a un fichero de manera aleatoria, con el fin de conocer la manera de almacenar datos (byte, int, double) en un archivo con extensión txt.

writeByte()

Escribe la cadena en el flujo de salida subyacente como una secuencia de bytes.

raf.writeBytes("\nEscribiendo los código ascii desde 0 a 255 con un solo byte\n\n");
for (i=0;i<255;i++) {
   raf.writeByte(i);  // escribe un byte
   raf.writeByte(13); // baja de línea en el caso de los codigos 10 y 13 baja doble linea
}

Para $i = 33$
	Salida: !

Para $i = 49$
	Salida: 1

Para $i =156$
	Salida: £

writeInt()

Escribe un int en el flujo de salida subyacente como 4 bytes, primero el byte alto.

Para almacenar el numero entero en el archivo, el numero entero será llevado a código binario y luego guardado con su equivalente en código ASCII.

for (i=1000000;i<1000100;i++) {
   raf.writeInt(i);  // escribe un numero
   raf.writeByte(13); // baja línea para mostrar los datos separados
}

• Para i = 1000052
  De decimal a binario: 1000052 = 11110100001001110100

Representación de 11110100001001110100 en un conjunto de 4 Bytes

Representación de cada Byte en Ascii

00000000 = NULL

00001111 = SI (desplaza adentro)

01000010 = B

01110100 = t

Salida: NULL Bt

writeDouble()

Convierte el argumento doble en largo usando el método doubleToLongBits en la clase Double, y luego escribe ese valor largo en el flujo de salida subyacente como una cantidad de 8 bytes, primero el byte alto.

Para almacenar el numero con punto flotante de doble precisión en el archivo, este será llevado a código binario y luego guardado con su equivalente en código ASCII.

for (i=1000000;i<1000100;i++) {
   raf.writeDouble((double)i);  // escribe un numero
   raf.writeByte(13); // baja línea para mostrar los datos separados
}

• Para i=1000087
  Primero se aplica el método DoubleToLongBits:

El método java.lang.Double.doubleToLongBits () de la clase Java Double es una función incorporada en Java que devuelve una representación del valor de punto flotante especificado de acuerdo con el diseño de bits de “formato doble” de punto flotante IEEE 754

1000087 = 4696837894008995840

EL resultado obtenido lo convertimos a código binario.

4696837894008995840 = 100000100101110100001010010111000000000000000000000000000000000

Representación de 100000100101110100001010010111000000000000000000000000000000000 en un conjunto de 8 Bytes

Representación de Cada Byte en Ascii

• 10000010 = A
• 00101110 = .
• 10000101 = à
• 00101110 = .
• 00000000 = NULL
• 00000000 = NULL
• 00000000 = NULL
• 00000000 = NULL

Salida:
A.àNULLNULLNULLNULL
A.à

Referencias:

• https://docs.oracle.com/javase/7/docs/api/java/io/DataOutputStream.html
• https://puntocomnoesunlenguaje.blogspot.com/2013/06/java-ficheros-acceso-aleatorio.html
• https://www.ibm.com/support/knowledgecenter/es/ssw_aix_71/network/conversion_table.html?origURL=ssw_aix_71/com.ibm.aix.networkcomm/conversion_table.htm
• https://elcodigoascii.com.ar/
• https://es.wikipedia.org/wiki/Unidades_de_información

Anuncio publicitario