Ejercicio con cuadrados

Supón que tenemos un fichero de texto que contiene la descripción de una serie de figuras y que se ajusta al siguiente formato.

• 1ª línea...      <nombre de la clase de figura>
• siguientes líneas...      <datos de la figura, uno por línea>

Ejemplo:

• Circulo
• 20
• 120
• 30
• Cuadrado
• 23
• 0
• 50
• ...

Implementa un programa que lea dicho fichero atendiendo solo a los cuadrados y a sus datos.

Por cada cuadrado deberá crear un objeto cuadrado según la descripción y guardarlo serializado en un fichero binario llamado soloCuadrados.dat

public class EjercicioCuadrados {
    public static void main (String [] args) throws IOException {
        FileReader fr = new FileReader("figuras.txt");
        BufferedReader br = new BufferedReader(fr);
        FileOutputStream fos = new FileOutputStream("soloCuadrados.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        int coorX, coorY, lado;
        String aux;
        aux = br.readLine();
        while (aux != null) {
            if (aux.equals("Cuadrado")) {
                coorX = Integer.parseInt(br.readLine());
                coorY = Integer.parseInt(br.readLine());
                lado = Integer.parseInt(br.readLine());
                oos.writeObject(new Cuadrado(coorX, coorY, lado));
            }
            aux = br.readLine();
        }
        oos.close();
        fos.close();
        br.close();
        fr.close();
    }
}

Ejercicio con figuras

En este ejercicio se utilizan las figuras creadas anteriormente. Se fabricarán varias figuras, que se almacenarán en un fichero utilizando la clase ObjectOutputStream, que nos permite serializar objetos (para ello la clase figura debe implementar Serializable).

Posteriormente se recuperarán las figuras y calcularemos el área media.

public class GuardarFiguras3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //FABRICAR VARIAS FIGURAS Y GUARDARLAS EN UN FICHERO
        FileOutputStream fos = new FileOutputStream("figuras3");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        LinkedList listado = new LinkedList();
        ListIterator it = listado.listIterator();
        Figura aux;
        float sup=0;
        it.add(new Rectangulo(1, 3, 5, 6));
        sup+=it.previous().area();
        it.next();
        it.add(new Coche(3, 2, 6, 9));
        sup+=it.previous().area();
        it.next();
        it.add(new Circulo(4, 4, 4));
        sup+=it.previous().area();
        it.next();
        it.add(new Rectangulo(1, 3, 5, 5));
        sup+=it.previous().area();
        it.next();
        it.add(new Triangulo(2, 4, 3, 4, 5));
        sup+=it.previous().area();
        sup = sup/5;
        System.out.println("Área media inicial: "+sup);
        ListIterator it2 = listado.listIterator();
        while (it2.hasNext()) {
            oos.writeObject(it2.next());
        }
        oos.close();
        fos.close();
        //RECUPERAR FIGURAS Y CALCULAR LA MEDIA (DEBE COINCIDIR CON LA INICIAL)
        FileInputStream fis = new FileInputStream("figuras3");
        ObjectInputStream ois = new ObjectInputStream(fis);
        float media = 0;
        int contador = 0;
        try {
            while (true) {
                aux = (Figura) ois.readObject();
                media += aux.area();
                contador++;
            }
        } catch (EOFException e) {
        }
        ois.close();
        fis.close();
        media = media / contador;
        System.out.println("Área media final: " + media);
    }
}

Ejercicio "Figuras geométricas"

Este ejercicio lo realizamos a lo largo de varias semanas, añadiendo funciones, creando clases nuevas y realizando algunos ejercicios con las figuras que se añadirán en entradas posteriores.

Dada la clase abstracta* "Figura", añadirle varias funciones de desplazamiento, una función que permita consultar su posición y dos funciones que permitan modificar directamente las coordenadas.

public abstract class Figura implements Serializable {
    protected  Point posicion;
    public Figura(int a, int b) {
    posicion= new Point(a,b);}
    public abstract float area();
    public abstract float perimetro();
    public abstract int alto();
    public abstract int ancho();
    public abstract void dibujar(Graphics g);
    public abstract void guardar(OutputStream out) throws IOException;
    public abstract void cargar(InputStream in) throws IOException;
    public void arr(int incremento){
        this.posicion.y -= incremento;
    }
    public void abj(int incremento){
        this.posicion.y += incremento;
    }
    public void izq(int incremento){
        this.posicion.x -= incremento;
    }
    public void der(int incremento){
        this.posicion.x += incremento;
    }
    public Point posicion(){
        Point aux = new Point(posicion);
        return aux;
    }
    public void set_y(int pos_y){
        this.posicion.y = pos_y;
    }
    public void set_x(int pos_x){
        this.posicion.x = pos_x;
    }
}

Crear la clase (excepción) "FiguraFormatException", que hereda de "IllegalArgumentException" y se lanzará si en la función Cargar, se lee del flujo una figura que no es la indicada.

public class FiguraFormatException extends IllegalArgumentException{
    public FiguraFormatException() {
    }
    public FiguraFormatException(String string) {
        super(string);
    }
}

Dadas las clases "Triangulo", "Elipse", "Circulo", "Rectangulo" y "Cuadrado", que heredan de la clase abstracta "Figura", añadir un constructor que reciba un InputStream, que tendrá los datos adecuados para inicializar la figura. Además, se sobreescribirán las funciones abstractas de la clase "Figura".

CLASE Triangulo

public class Triangulo extends Figura {
    protected int lado1, lado2, lado3;
    private int lx, altura;
    public Triangulo(int a, int b, int c, int d, int e) {
        super(a, b);
        int elMayor = (c > d & c > e) ? c : ((d > e) ? d : e);
        if (elMayor >= (c + d + e - elMayor)) {
            throw new IllegalArgumentException("Los lados del triangulo son imposibles");
        }
        lado1 = c;
        lado2 = d;
        lado3 = e;
        lx = (lado2 * lado2 - lado3 * lado3 - lado1 * lado1) / (2 * lado1);
        altura = (int) Math.sqrt(lado3 * lado3 - lx * lx);
    }
    public Triangulo(InputStream in) throws IOException {
        super(0, 0);
        cargar(in);
    }
    public void guardar(OutputStream out) throws IOException {
        DataOutputStream escribir = new DataOutputStream(out);
        escribir.writeUTF("figuras.Triangulo");
        escribir.writeInt(posicion.x);
        escribir.writeInt(posicion.y);
        escribir.writeInt(lado1);
        escribir.writeInt(lado2);
        escribir.writeInt(lado3);
        escribir.flush();
    }
    public void cargar(InputStream in) throws IOException {
        DataInputStream leer = new DataInputStream(in);
        String figura;
        figura = leer.readUTF();
        if (!figura.equals("figuras.Triangulo")) {
            throw new FiguraFormatException();
        }
        posicion.x = leer.readInt();
        posicion.y = leer.readInt();
        lado1 = leer.readInt();
        lado2 = leer.readInt();
        lado3 = leer.readInt();
        lx = (lado2 * lado2 - lado3 * lado3 - lado1 * lado1) / (2 * lado1);
        altura = (int) Math.sqrt(lado3 * lado3 - lx * lx);
    }
    public float area() {
        return (lado1 * altura) / 2;
    }
    public float perimetro() {
        return lado1 + lado2 + lado3;
    }
    public int alto() {
        return altura;
    }
    public int ancho() {
        return lado1;
    }
    public void dibujar(Graphics g) {
        Color cActual = g.getColor();
        int[] xPuntos = {posicion.x,
            posicion.x + lado1,
            posicion.x + lado1 + lx};
        int[] yPuntos = {posicion.y,
            posicion.y,
            posicion.y + altura};
        g.fillPolygon(xPuntos, yPuntos, 3);
        g.setColor(Color.white);
        g.drawPolygon(xPuntos, yPuntos, 3);
        g.setColor(cActual);
    }
}

CLASE Elipse

public class Elipse extends Figura {
    public final static float PI = 3.1415F;
    protected int dMenor, dMayor;
    public Elipse(int a, int b, int c, int d) {
        super(a, b);
        dMenor = c;
        dMayor = d;
    }
    public Elipse(InputStream in) throws IOException {
        super(0, 0);
        this.cargar(in);
    }
    public void guardar(OutputStream out) throws IOException {
        DataOutputStream escribir = new DataOutputStream(out);
        escribir.writeUTF("figuras.Elipse");
        escribir.writeInt(posicion.x);
        escribir.writeInt(posicion.y);
        escribir.writeInt(dMenor);
        escribir.writeInt(dMayor);
        escribir.flush();
    }
    public void cargar(InputStream in) throws IOException {
        DataInputStream leer = new DataInputStream(in);
        if (!leer.readUTF().equals("figuras.Elipse")) {
            throw new FiguraFormatException();
        }
        posicion.x = leer.readInt();
        posicion.y = leer.readInt();
        dMenor = leer.readInt();
        dMayor = leer.readInt();
    }
    public float area() {
        return PI * dMenor * dMayor;
    }
    public float perimetro() {
        return PI * (dMenor + dMayor);
    }
    public int alto() {
        return dMayor;
    }
    public int ancho() {
        return dMenor;
    }
    public void dibujar(Graphics g) {
        Color cActual = g.getColor();
        g.fillOval(posicion.x, posicion.y, dMenor, dMayor);
        g.setColor(Color.white);
        g.drawOval(posicion.x, posicion.y, dMenor, dMayor);
        g.setColor(cActual);
    }
}

CLASE Circulo

public class Circulo extends Elipse {
    public Circulo(int a, int b, int d) {
        super(a, b, d, d);
    }
    public Circulo(InputStream is) throws IOException {
        super(0, 0, 0, 0);
        //Si se produce una IOException, se borrarán los datos del objeto Circulo
        cargar(is);
    }
    @Override
    public void guardar(OutputStream os) throws IOException {
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeUTF("figuras.Circulo");
        dos.writeInt(posicion.x);
        dos.writeInt(posicion.y);
        dos.writeInt(dMayor);
        dos.flush();
    }
    @Override
    public void cargar(InputStream is) throws IOException {
        DataInputStream dis = new DataInputStream(is);

        if (!dis.readUTF().equals("figuras.Circulo")) {
            throw new FiguraFormatException();
        }
        posicion = new Point(dis.readInt(), dis.readInt());
        dMayor = dis.readInt();
        dMenor = dMayor;
    }
}

CLASE Rectangulo

public class Rectangulo extends Figura {
    protected int lado1, lado2;
    public Rectangulo(int a,int b,int c,int d) {
        super(a,b);
        lado1=c;
        lado2=d; }
    public Rectangulo(InputStream in) throws IOException {
        super(0,0);
        this.cargar(in);
    }
    public float area() {
        return lado1*lado2;
    }
    public float perimetro() {
        return lado1*2+lado2*2;
    }
    public int alto() {
        return lado2;
    }
    public int ancho() {
        return lado1;
    }
    public void dibujar(Graphics g) {
        Color cActual=g.getColor();
        g.fillRect(posicion.x,posicion.y,lado1,lado2);
        g.setColor(Color.white);
        g.drawRect(posicion.x,posicion.y,lado1,lado2);
        g.setColor(cActual);
    }
    public void guardar (OutputStream out) throws IOException{
        DataOutputStream dos = new DataOutputStream(out);
        dos.writeUTF("figuras.Rectangulo");
        dos.writeInt((int) super.posicion().getX());
        dos.writeInt((int) super.posicion().getY());
        dos.writeInt(lado1);
        dos.writeInt(lado2);
        dos.flush();
    }
    public void cargar (InputStream in) throws IOException{
        DataInputStream dis = new DataInputStream(in);
        if(!dis.readUTF().equals("figuras.Rectangulo")) {
            throw new FiguraFormatException("La figura no es un rectángulo.");
        }
        super.set_x(dis.readInt());
        super.set_y(dis.readInt());
        lado1=dis.readInt();
        lado2=dis.readInt();
    }
}

CLASE Cuadrado

public class Cuadrado extends Rectangulo {
    public Cuadrado(int a, int b, int c) {
        super(a, b, c, c);
    }
    public Cuadrado(InputStream in) throws IOException {
        super(0, 0, 0, 0);
        cargar(in);
    }
    @Override
    public void guardar(OutputStream out) throws IOException {
        DataOutputStream escribe = new DataOutputStream(out);
        escribe.writeUTF("figuras.Cuadrado");
        escribe.writeInt(posicion.x);
        escribe.writeInt(posicion.y);
        escribe.writeInt(this.alto());
        escribe.flush();
    }
    @Override
    public void cargar(InputStream in) throws IOException {
        DataInputStream lee = new DataInputStream(in);
        if (!lee.readUTF().equals("figuras.Cuadrado")) {
            throw new FiguraFormatException();
        }
        posicion.x = lee.readInt();
        posicion.y = lee.readInt();
        lado1 = lee.readInt();
        lado2 = lado1;
    }
}

Crear las clases "TEquilatero" que hereda de "Triangulo" y "Coche" que hereda de "Figura".

La clase "TEquilatero":

• Es un triángulo con los tres lados iguales.

La clase "Coche":

• Estará formada por dos círculos (ruedas) y un rectángulo.
• Su posición la indicará la esquina superior izquierda.
• Los círculos tendrán el mismo tamaño que la altura del rectángulo.
• Si la suma de los dos diámetros es mayor a la longitud del rectángulo, entonces el diámetro será la mitad de la longitud.

CLASE TEquilatero

public class TEquilatero extends Triangulo {
    public TEquilatero(int a, int b, int c) {
        super(a, b, c, c, c);
    }
    public TEquilatero(InputStream in) throws IOException {
        super(0, 0, 0, 0, 0);
        cargar(in);
    }
    @Override
    public void cargar(InputStream into) throws IOException {
        DataInputStream di = new DataInputStream(into);
        if (!di.readUTF().equals("figuras.TEquilatero")) {
            throw new FiguraFormatException();
        }
        posicion.x = di.readInt();
        posicion.y = di.readInt();
        lado1 = di.readInt();
    }
    @Override
    public void guardar(OutputStream o) throws IOException {
        DataOutputStream out = new DataOutputStream(o);
        out.writeUTF("figuras.TEquilatero");
        out.writeInt(posicion.x);
        out.writeInt(posicion.y);
        out.writeInt(lado1);
        out.flush();
    }
}

CLASE Coche

public class Coche extends Figura {
    private Rectangulo chasis;
    private Circulo rueda1, rueda2;
    public Coche(int a, int b, int alto, int ancho) {
        super(a, b);
        if (alto <= ancho) {
            chasis = new Rectangulo(a, b, ancho, alto / 2);
            rueda1 = new Circulo(a, b + chasis.alto(), alto / 2);
            rueda2 = new Circulo(a + ancho - alto / 2, b + chasis.alto(), alto / 2);
        } else {
            chasis = new Rectangulo(a, b, ancho, alto - (ancho / 2));
            rueda1 = new Circulo(a, b + chasis.alto(), ancho / 2);
            rueda2 = new Circulo(a + ancho / 2, b + chasis.alto(), ancho / 2);
        }
    }
    public Coche(InputStream in)throws IOException{
        super(0,0);
        this.cargar(in);
    }
    @Override
    public float area() {
        return chasis.area() + rueda1.area() + rueda2.area();
    }
    @Override
    public float perimetro() {
        return chasis.perimetro() + rueda1.perimetro() + rueda2.perimetro();
    }
    @Override
    public int alto() {
        return chasis.alto() + rueda1.alto();
    }
    @Override
    public int ancho() {
        return chasis.ancho();
    }
    @Override
    public void dibujar(Graphics g) {
        chasis.dibujar(g);
        rueda1.dibujar(g);
        rueda2.dibujar(g);
    }
    @Override
    public void arr(int incremento) {
        super.arr(incremento);
        chasis.arr(incremento);
        rueda1.arr(incremento);
        rueda2.arr(incremento);
    }
    @Override
    public void abj(int incremento) {
        super.abj(incremento);
        chasis.abj(incremento);
        rueda1.abj(incremento);
        rueda2.abj(incremento);
    }
    @Override
    public void izq(int incremento) {
        super.izq(incremento);
        chasis.izq(incremento);
        rueda1.izq(incremento);
        rueda2.izq(incremento);
    }
    @Override
    public void der(int incremento) {
        super.der(incremento);
        chasis.der(incremento);
        rueda1.der(incremento);
        rueda2.der(incremento);
    }
    @Override
    public void set_y(int pos_y) {
        super.set_y(pos_y);
        chasis.set_y(pos_y);
        rueda1.set_y(pos_y + chasis.alto());
        rueda2.set_y(pos_y + chasis.alto());
    }
    @Override
    public void set_x(int pos_x) {
        super.set_x(pos_x);
        chasis.set_x(pos_x);
        rueda1.set_x(pos_x);
        rueda2.set_x(pos_x + chasis.ancho() - rueda2.ancho());
    }
    public void guardar(OutputStream out) throws IOException {
        DataOutputStream escribe = new DataOutputStream(out);
        escribe.writeUTF("figuras.Coche");
        escribe.writeInt(posicion.x);
        escribe.writeInt(posicion.y);
        escribe.flush();
        rueda1.guardar(out);
        rueda2.guardar(out);
        chasis.guardar(out);

    }
    public void cargar(InputStream in) throws IOException {
        DataInputStream leer = new DataInputStream(in);
        String clase;
        if (!(clase=leer.readUTF()).equals("figuras.Coche")) {
            throw new FiguraFormatException("La figura no es un coche. Se ha leído: "+clase);
        }
        posicion.x = (leer.readInt());
        posicion.y = (leer.readInt());
        rueda1 = new Circulo(in);
        rueda2 = new Circulo(in);
        chasis = new Rectangulo(in);
    }
}

* Una clase será abstracta cuando no queremos que se puedan crear objetos de esa clase. Sus funciones pueden ser abstractas, en este caso, las clases que hereden de una abstracta pueden sobreescribir esas funciones o dejarla abstracta (la clase hija será también abstracta). Una clase abstracta también puede tener funciones no abstractas, es decir, que tengan código.

Creación de fichero con datos aleatorios

Supongamos que disponemos de un fichero binario que contiene una secuencia de registros con la siguiente estructura:

1. Altura. (float)
2. Edad. (int)
3. Repetidor. (boolean)

EJERCICIOS:

• Haz una aplicación para generar un fichero con estas características de contenido aleatorio.
• Haz otra que lo lea y calcule la edad media de los alumnos repetidores.
• Y otra más que muestre el contenido del fichero correctamente tabulado para facilitar su legibilidad.

GENERACIÓN DEL FICHERO CON CONTENIDO ALEATORIO

public class Ejercicio2_escribir {
    public static void main (String [] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("registro2");
        DataOutputStream dos = new DataOutputStream(fos);
        int numRegistros = (int) (Math.random()*100+1);
        int i = 0, edad;
        double aux;
        float altura;
        boolean repetidor;
        while (i < numRegistros) {
            altura=(float) (Math.random()*2);
            altura=(int) (altura*100);
            altura=(float) (altura/100);
            dos.writeFloat(altura);
            edad=(int) (Math.random()*100+1);
            dos.writeInt(edad);
            aux=Math.random();
            if (aux < 0.5)
                repetidor=true;
            else
                repetidor=false;
            dos.writeBoolean(repetidor);
            i++;
        }
        dos.close();
        fos.close();
    }
}

LEER FICHERO Y CALCULAR EDAD MEDIA DE REPETIDORES

public class Ejercicio2_media {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("registro2");
        DataInputStream dis = new DataInputStream(fis);
        int suma=0, aux, contador = 0;
        float media;
        try {
            while (true) {
                dis.readFloat();
                aux=dis.readInt();
                if (dis.readBoolean()) {
                    suma+=aux;
                    contador++;
                }
            }
        }
        catch (EOFException e) {
        }
        fis.close();
        dis.close();
        if (contador==0) {
            System.out.println("No hay repetidores.");
        }
        else {
            media = (float) suma/contador;
            System.out.println("La edad media de los repetidores es: " +media+ " años.");
        }
    }
}

MOSTRAR EL CONTENIDO DEL FICHERO

public class Ejercicio2_mostrar {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("registro2");
        DataInputStream dis = new DataInputStream(fis);
        System.out.printf("ALTURA\tEDAD\tREPETIDOR");
        System.out.println();
        try {
            while (true) {
                System.out.printf("%.2f\t%2d\t%b", dis.readFloat(), dis.readInt(), dis.readBoolean());
                System.out.println();
            }
        }
        catch (EOFException e) {
        }
        fis.close();
        dis.close();
    }
}

Ejercicio creación de ficheros

Realizar un programa que cree un fichero con los siguientes datos:

• 85.23, de tipo float.
• 18, de tipo entero.
• true, de tipo boolean.

Se realizarán dos versiones, en la primera el fichero será un fichero de texto, en el que se almacenarán caracteres. En la segunda versión el fichero será de tipo binario, es decir, se guardarán bytes.

public class EjercicioFlujo4 {
    public static void main (String [] arg) throws IOException{
        //VERSIÓN 1: fichero de texto
        FileWriter fich = new FileWriter("nuevo");
        PrintWriter impr = new PrintWriter(fich);
        impr.println(85.23F);
        impr.println(18);
        impr.println(true);
        impr.close();
        fich.close();

        //VERSIÓN 2: fichero binario
        FileOutputStream fich1 = new FileOutputStream("nuevo2");
        DataOutputStream impr1 = new DataOutputStream(fich1);
        impr1.writeFloat(85.23F);
        impr1.writeInt(18);
        impr1.writeBoolean(true);
        impr1.close();
        fich1.close();

        //LEER LOS FICHEROS
        //VERSIÓN 1: fichero de texto
        FileReader fich3 = new FileReader("nuevo");
        BufferedReader aux = new BufferedReader(fich3);
        System.out.println(Float.parseFloat(aux.readLine()));
        System.out.println(Integer.parseInt(aux.readLine()));
        System.out.println(Boolean.parseBoolean(aux.readLine()));
        aux.close();
        fich3.close();
        /*Otra forma
        FileInputStream fis = new FileInputStream("nuevo");
        Scanner entrada = new Scanner(fis);
        System.out.println(entrada.nextLine());
        System.out.println(entrada.nextInt());
        System.out.println(entrada.nextBoolean());
        entrada.close();
        fis.close();*/

        //VERSIÓN 2: fichero binario
        FileInputStream fich2 = new FileInputStream("nuevo2");
        DataInputStream leer = new DataInputStream(fich2);
        System.out.println(leer.readFloat());
        System.out.println(leer.readInt());
        System.out.println(leer.readBoolean());
        leer.close();
        fich2.close();        
    }
}

Ejercicio función totaliza

Realizar la siguiente función:

• static int totaliza (Reader in). Recibe un flujo de datos de tipo "Reader" y lee los números enteros que contiene. La función irá sumando estos números hasta tener el total, que es el dato que se retorna.

Si se produce error al leer alguna línea y pasarlo a entero, se atrapará la excepción y se sacará un mensaje con el número de la línea que no se ha leído.

Se añade el programa principal con el que se probó la función.

public class EjercicioFlujo3 {
    public static void main (String [] args) throws FileNotFoundException, IOException {
        String ruta="/home/veronica/Documentos/fichero";
        int total;
        FileReader leerFich = new FileReader(ruta);
        total=totaliza(leerFich);
        leerFich.close();
        System.out.println(total);
    }
    public static int totaliza (Reader in) throws IOException {
        int resultado=0;
        int linea=1;
        String num;
        BufferedReader aux = new BufferedReader(in);
        while ((num=aux.readLine()) != null) {
            try {
                resultado += Integer.parseInt(num);
            }
            catch(NumberFormatException e) {
                System.err.println("Fallo en la línea: "+linea);
            }
            linea++;
        }
        aux.close();
        return resultado;
    }
}

Ejercicio analizar String

Queremos analizar el juego de caracteres de un String, es decir, queremos saber cómo se almacena en memoria, conocer la secuencia de bytes. Para ello emplearemos las clases de Java que nos permiten trabajar con la entrada/salida de datos.

public class EjercicioFlujo {
    public static void main (String [] args) throws IOException {
        Scanner entrada = new Scanner(System.in);
        String p;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        OutputStreamWriter osw = new OutputStreamWriter(baos);
        //Si quisiéramos guardarlo en Unicode16:
        //OutputStreamWriter osw = new OutputStreamWriter(baos, "UTF-16");
        byte[] resultado;
        p=entrada.nextLine();
        osw.write(p);
        osw.close();
        baos.close();
        resultado = baos.toByteArray();
        System.out.println(p);
        for (int i=0; i<resultado.length;i++){
            //Para conseguir que nos escriba el código de todos los caracteres
            System.out.println(0x00FF & (int)resultado[i]);
        }
    }
}

En este caso hemos utilizado las clases ByteArrayOutputStream y OutputStreamWriter.