convertir InputStream en UTF8

Version imprimable

19/10/2006, 15h58
menuge

convertir InputStream en UTF8

Salut à tous,

la question est dans le sujet:

Est il possible de convertir un InputStream en UTF8?

Merci d'avance!
19/10/2006, 16h05
adiGuba

Salut,

Oui ! En utilisant un Reader (:arrow: InputStreamReader)

a++
19/10/2006, 16h17
menuge

je ne vois pas comment?
19/10/2006, 16h19
adiGuba

Code:

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

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

a++
19/10/2006, 16h24
menuge

et pour convertir ce Reader en InputStream?
19/10/2006, 16h39
adiGuba

Heu... Je ne comprend toujours pas ce que tu veux faire...
19/10/2006, 16h46
menuge

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.
19/10/2006, 16h48
menuge

j'ai oublié de préciser: la méthode me permettan de parser ce fichier prnd en paramètre un InputStream
20/10/2006, 10h36
menuge

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...

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

Code:

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);
}

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:

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();
        }
    }

A tester...

a++

20/10/2006, 11h49
le y@m's

Je trouve cette solution beaucoup plus élégante que la mienne :ccool:.

(il est vraiment fort mon parrain :D)
20/10/2006, 14h57
menuge

MErci beaucoup pour ces idées....

Je vais tester ça la semaine prochiane...

Pour le moment, je le passe en :resolu: et je le réouvrirais...

Encore merci!