convertir InputStream en UTF8

**menuge** · 19/10/2006, 15h58

Salut à tous,

la question est dans le sujet:

Est il possible de convertir un InputStream en UTF8?

Merci d'avance!

**adiGuba** · 19/10/2006, 16h05

Salut,

Oui ! En utilisant un Reader ( InputStreamReader)

a++

**menuge** · 19/10/2006, 16h17

je ne vois pas comment?

**adiGuba** · 19/10/2006, 16h19

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Reader reader = new InputStreamReader(input, "UTF8");

Maintenant j'ai peut-être mal compris ce que tu voulais faire...

a++

**menuge** · 19/10/2006, 16h24

et pour convertir ce Reader en InputStream?

**adiGuba** · 19/10/2006, 16h39

Heu... Je ne comprend toujours pas ce que tu veux faire...

**menuge** · 19/10/2006, 16h46

En fait, voilà ce que j'ai comme pb:

J'ai une méthode qui prend en paramètre un InputStream.
Cette méthode fait différentes opérations dont celle de parser cet InpuitStream qui est en fait un fichier XML.

J'ai eu quelques soucis lors du parsing dû à l'encodage du fichier. Il faut donc, que je le convertisse en UTF-8.

**menuge** · 19/10/2006, 16h48

j'ai oublié de préciser: la méthode me permettan de parser ce fichier prnd en paramètre un InputStream

**menuge** · 20/10/2006, 10h36

en fait, ce que je souhaite faire, c'est:

InputStream inputUTF8 = new InputStream(oldInputStream, "UTF-8");

J'aimerai avoir ce constructeur ou quelque chose faisant ça...

**le y@m's** · 20/10/2006, 11h29

Une solution pourrait être de passer par un ByteArrayInputStream.
Un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static InputStream toUTF8(InputStream input)
throws UnsupportedEncodingException, IOException {
    return toUTF8(input, null);
}
 
 
public static InputStream toUTF8(InputStream input, String inputCharsetName)
throws UnsupportedEncodingException, IOException {
    int size = 0;
    byte[] data = new byte[0];
    byte[] buff = new byte[2048];
    int nbRead = 0;
    try {
        while((nbRead = input.read(buff)) > 0) {
            String sBuff = inputCharsetName == null ? new String(buff) : new String(buff, inputCharsetName);
            size += nbRead;
            byte[] temp = new byte[size];
            System.arraycopy(data, 0, temp, 0, data.length);
            System.arraycopy(sBuff.getBytes("UTF8"), 0, temp, data.length, nbRead);
            data = temp;
        }
    } finally {
        input.close();
    }
    return new ByteArrayInputStream(data);
}

**adiGuba** · 20/10/2006, 11h38

Une autre solution serait de lire les données en entrée avec un Reader (afin de bien gérer l'encodage original du fichier) et de transformer cela en String, afin de pouvoir les transformer en bytes selon l'encodage voulu.

Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
    class InputStreamConverter extends InputStream{
 
        /* Le Reader utilisé pour lire le flux original */
        private final Reader input;
        /* Le charset utilisé pour la sortie des données */
        private final String outputCharset;
 
        /* Buffer de lecture du Reader */
        private char[] cbuf = new char[4092];
        /* Buffer des données avec le bon charset */
        private byte[] data = null;
        /* Position dans le buffer de données */
        int pos = 0;
 
 
        /**
         * Création d'un InputStream à partir des données d'un InputStream avec le charset par défaut,
         * et en les encodant avec un autre charset.
         * @param input L(InputStream qui sera utilisée pour lire les données
         * @param outputCharset Le charset utilisée pour encoder les données lu via read().
         */
        public InputStreamConverter(InputStream input, String outputCharset) {
            this(new InputStreamReader(input), outputCharset);
        }
 
        /**
         * Création d'un InputStream à partir des données d'un InputStream selon un charset spécifique,
         * et en les encodant avec un autre charset.
         * @param input L(InputStream qui sera utilisée pour lire les données
         * @param inputCharset Le charset utilisée pour lire les données.
         * @param outputCharset Le charset utilisée pour encoder les données lu via read().
         * @throws UnsupportedEncodingException
         */
        public InputStreamConverter(InputStream input, String inputCharset, String outputCharset) throws UnsupportedEncodingException {
            this(new InputStreamReader(input, inputCharset), outputCharset);
        }
 
        /**
         * Création d'un InputStream à partir des données du Reader spécifié,
         * en les encodant avec un autre charset.
         * @param reader Le Reader qui sera utilisée pour lire les données
         * @param charset Le charset utilisée pour encoder les données lu via read().
         */
        public InputStreamConverter(Reader reader, String charset) {
            this.input = reader;
            this.outputCharset = charset;
        }
 
        @Override
        public int read() throws IOException {
            if (data==null || pos>=data.length) {
 
                // lecture bufférisée depuis le Reader
                int len = input.read(cbuf);
                if (len>0) {
                    // on transforme le char[] en String
                    // afin de pouvoir le convertir en byte[] au format voulu :
                    data = new String(cbuf,0,len) . getBytes(this.outputCharset);
                    // On réinitialise la position de lecture :
                    pos = 0;
                } else {
                    // on a atteint la fin du flux
                    data = null;
                }
            }
            if (data==null)
                return -1;
            // On renvoit les données du buffer en tampon (si présente).
            return data[pos++];
        }
 
        @Override
        public void close() throws IOException {
            this.input.close();
        }
 
        @Override
        protected void finalize() throws Throwable {
            this.input.close();
        }
    }