Necesito codificar mis archivos en "ISO-8859-1". Sé cómo hacer esto con un lector como este:

BufferedReader br = new BufferedReader(new InputStreamReader(
            new FileInputStream(src), "ISO-8859-1"))

Pero estoy preguntando cómo codificar un DataInputStream como este.

Mi declaración en este momento:

DataInputStream dit = new DataInputStream(new BufferedInputStream(
            new FileInputStream(src)))

Preferiría una solución, donde el parámetro de codificación está en la declaración. Los datos que quiero leer se han escrito con un DataOutputStream.

Método de importación y método de exportación para DataStreams:

public void importDST(String src) throws FileNotFoundException, IOException{
    try (DataInputStream dit = new DataInputStream(new BufferedInputStream(new FileInputStream(src)))) {
        while(dit.available() > 0) {
            pupils.add(new Pupil(dit.readInt(), dit.readInt(), dit.readUTF(), dit.readUTF(), dit.readChar(),
                    dit.readUTF(), dit.readInt(), dit.readInt(), dit.readInt(), dit.readUTF(), dit.readUTF(), dit.readUTF(), dit.readUTF(),
                    dit.readUTF(), dit.readUTF()));
        }
    } catch (FileNotFoundException e) {
        throw e;
    } catch (IOException e) {
        throw e;
    }
}

public void exportDST(String dest, ArrayList<Pupil> pupils) throws FileNotFoundException, IOException{
    this.pupils = pupils;
    try (DataOutputStream dot = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)))) {
        for (Pupil p : this.pupils) {
            dot.writeInt(p.getId());
            dot.writeInt(p.getNumber());
            dot.writeUTF(p.getFirstname());
            dot.writeUTF(p.getLastname());
            dot.writeChar(p.getGender());
            dot.writeUTF(p.getReligion());
            dot.writeInt(p.getDay());
            dot.writeInt(p.getMonth());
            dot.writeInt(p.getYear());
            dot.writeUTF(p.getStreet());
            dot.writeUTF(p.getPlz());
            dot.writeUTF(p.getLocation());
            dot.writeUTF(p.getShortName());
            dot.writeUTF(p.getClassName());
            dot.writeUTF(p.getKvLastname());
        }
    } catch (FileNotFoundException e) {
        throw e;
    } catch (IOException e) {
        throw e;
    }
}

Alumno de clase:

public class Pupil implements Serializable{
private int id;
private int number;
private String firstname;
private String lastname;
private char gender;
private String religion;
private int day;
private int month;
private int year;
private String street;
private String plz;
private String location;
private String shortName;
private String className;
private String kvLastname;

public Pupil() {}

public Pupil(int id, int number, String firstname, String lastname, char gender,
             String religion, int day, int month, int year, String street, String plz, String location,
             String shortName, String className, String kvLastname) {
    this.id = id;
    this.number = number;
    this.firstname = firstname;
    this.lastname = lastname;
    this.gender = gender;
    this.religion = religion;
    this.day = day;
    this.month = month;
    this.year = year;
    this.street = street;
    this.plz = plz;
    this.location = location;
    this.shortName = shortName;
    this.className = className;
    this.kvLastname = kvLastname;
}
}
2
Stefan 16 sep. 2018 a las 18:02

3 respuestas

La mejor respuesta

Pasé por alto este problema escribiendo y leyendo solo Ints y Bytes, en lugar de Strings. Leí bytearrays e hice una nueva cadena con la codificación. Aquí está el código cambiado:

Leyendo:

public void importDST(String src) throws IOException{
    try (DataInputStream dit = new DataInputStream(new BufferedInputStream(new FileInputStream(src)))) {
        while (dit.available() > 0) {
            Pupil p = new Pupil();
            byte[] arr;
            int len;

            p.setId(dit.readInt());
            p.setNumber(dit.readInt());
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setFirstname(new String(arr, "ISO-8859-1"));
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setLastname(new String(arr, "ISO-8859-1"));
            p.setGender(dit.readChar());
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setReligion(new String(arr, "ISO-8859-1"));
            p.setDay(dit.readInt());
            p.setMonth(dit.readInt());
            p.setYear(dit.readInt());
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setStreet(new String(arr, "ISO-8859-1"));
            p.setPlz(dit.readInt());
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setLocation(new String(arr, "ISO-8859-1"));
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setShortName(new String(arr, "ISO-8859-1"));
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setClassName(new String(arr, "ISO-8859-1"));
            len = dit.readInt();
            arr = new byte[len];
            dit.readFully(arr);
            p.setKvLastname(new String(arr, "ISO-8859-1"));

            pupils.add(p);
        }
    }
}

Escritura:

public void exportDST(String dest, ArrayList<Pupil> pupils) throws IOException{
    this.pupils = pupils;
    try (DataOutputStream dot = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)))) {
        for (Pupil p : pupils) {
            dot.writeInt(p.getId());
            dot.writeInt(p.getNumber());
            dot.writeInt(p.getFirstname().length());
            dot.writeBytes(p.getFirstname());
            dot.writeInt(p.getLastname().length());
            dot.writeBytes(p.getLastname());
            dot.writeChar(p.getGender());
            dot.writeInt(p.getReligion().length());
            dot.writeBytes(p.getReligion());
            dot.writeInt(p.getDay());
            dot.writeInt(p.getMonth());
            dot.writeInt(p.getYear());
            dot.writeInt(p.getStreet().length());
            dot.writeBytes(p.getStreet());
            dot.writeInt(p.getPlz());
            dot.writeInt(p.getLocation().length());
            dot.writeBytes(p.getLocation());
            dot.writeInt(p.getShortName().length());
            dot.writeBytes(p.getShortName());
            dot.writeInt(p.getClassName().length());
            dot.writeBytes(p.getClassName());
            dot.writeInt(p.getKvLastname().length());
            dot.writeBytes(p.getKvLastname());
        }
    }
}

¡Gracias por todas tus respuestas!

0
Stefan 17 sep. 2018 a las 19:33

Tu pregunta realmente no tiene sentido.

Secuencias modelo de secuencias de bytes . No tienen una codificación de caracteres, son solo bytes.

Los lectores leen secuencias de caracteres . En última instancia, también son secuencias de bytes, pero hay una codificación de caracteres que dice cómo convertir esos bytes en caracteres. Como tal, tiene sentido poder especificar esta codificación en el constructor.

DataInputStream s son Stream s: leen un binario para que no tengan una codificación de caracteres.

0
Andy Turner 16 sep. 2018 a las 16:52

En cuanto a ObjectInputStream, la documentación indica que

Un ObjectInputStream deserializa datos primitivos y objetos previamente escritos usando un ObjectOutputStream.

Además, tenga en cuenta:

Solo los objetos que admiten la interfaz java.io.Serializable o java.io.Externalizable se pueden leer desde secuencias.

Es decir, los datos leídos se han serializado previamente (o externalizado) usando ObjectOutputStream y se le han dado objetos que implementan Serializable (o Externalizable). De este modo, se ocuparía de la codificación de conjunto de caracteres para cualquier atributo String en los métodos readObject y `writeObject 'de sus objetos serializables.

En cuanto a DataInputStream, vea esta respuesta: DataInputStream y UTF-8

Tendría que especificar la codificación al crear una Cadena a partir de los bytes leídos.

0
MikkelRJ 16 sep. 2018 a las 15:19