« unpack » à la Perl en Java ?

Version imprimable

19/01/2007, 14h47
domiq44

« unpack » à la Perl en Java ?
Bonjour,

Je dois lire un fichier de données au format texte.
Les données sont au format fixe.

Prenons l'exemple simpliste suivant.
Mon fichier "month.txt" contient :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 0131Janvier 0228Février 0331Mars 0430Avril 0531Mai 0630Juin 0731Juillet 0831Août 0930Septembre 1031Octobre 1130Novembre 1231Décembre
où
1. numéro du mois : entier, long=2
2. nombre de jours dans le mois : entier, long = 2
3. nom du mois : chaine, long = 20
En perl, si $line contient une ligne du fichier, je ferais cela :
Code:

1 2 ($id, $days, $month) = unpack ($line, "A2A2A*");
Mais en Java, comment faire ?

Merci.

A ma connaissance il n'y a pas l'equivalent en Java (du moins dans les librairies standards).

Ce qui s'en rapproche le plus c'est java.util.Scanner de Java 5.
Code:

1 2 3 4 5 Scanner scan = new Scanner("1231Décembre"); String id = scan.findInLine(".{2}"); // 2 premiers caracteres String day = scan.findInLine(".{2}"); // les 2 caracteres suivants String month = scan.findInLine(".*"); // tous les caracteres suivants
Scanner.findInLine() prend une RegEx en parametre, donc on peut faire un peu plus puissant qu'un "nombre de caracteres" 8-)

Citation:
Envoyé par pseudocode
A ma connaissance il n'y a pas l'equivalent en Java (du moins dans les librairies standards).

Ce qui s'en rapproche le plus c'est java.util.Scanner de Java 5.
Code:

1 2 3 4 5 Scanner scan = new Scanner("1231Décembre"); String id = scan.findInLine(".{2}"); // 2 premiers caracteres String day = scan.findInLine(".{2}"); // les 2 caracteres suivants String month = scan.findInLine(".*"); // tous les caracteres suivants
Scanner.findInLine() prend une RegEx en parametre, donc on peut faire un peu plus puissant qu'un "nombre de caracteres" 8-)
Je reprends cette discussion afin d'avoir de plus amples informations.

Quel serai l'équivalent de cette syntaxe perl:
Code:

1 2 3 4 5 6 7 8 my ($strg) = @_; my $ret = ''; my @arr = unpack('C*', $strg); for my $char (@arr){ $ret .= sprintf("%%%X", $char); }
J'ai quelque chose de ce genre là mais ca ne fonctionne pas :
Code:

1 2 3 4 5 6 7 String ret = ""; Scanner scan = new Scanner(code); while(scan.hasNextByte()) { ret = ret + String.format("%%%1$X", scan.nextByte()); }
C'est le C* qui me pose le plus de problèmes de retranscription.

J'ai besoin d'aide !
Merci

24/01/2008, 15h14
josiasseb
J'ai trouvé grâce à un collègue:
Code:

1 2 3 4 5 6 String ret = ""; for (int j=0; j<code.getBytes().length; j++) { ret = ret + String.format("%%%1$X", code.getBytes()[j]); }
Je cherchais trop compliqué.
En fait, pas besoin de java.util.Scanner.
Merci getBytes()

[resolu]

J'ai une solution qui fonctionne :D

Créer la classe Unpack :

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
82
83
 
package my.tools;
 
import java.text.ParseException;
import java.util.ArrayList;
import java.util.StringTokenizer;
 
/**
 * Permet le decompactage de données au format fixe
 */
public class UnPack {
    /**
     * Unpacks a string into a string array following a given format.
     */
    public static String[] unpack(String format, String data) throws ParseException {
        ArrayList result = new ArrayList();
        int formatOffset = 0;
        int dataOffset = 0;
        int minDataOffset = 0;
        int maxDataOffset = data.length();
 
        StringTokenizer tokenizer = new StringTokenizer(format);
        while (tokenizer.hasMoreTokens()) {
            String token = tokenizer.nextToken();
            int tokenLen = token.length();
 
            // count determination
            int count = 0;
            if (tokenLen == 1)
                count = 1;
            else if (token.charAt(1) == '*')
                count = -1;
            else {
                try {
                    count = new Integer(token.substring(1)).intValue();
                } catch (NumberFormatException ex) {
                    throw new ParseException("Unknown count token", formatOffset);
                }
            }
 
            // action determination
            char action = token.charAt(0);
            switch (action) {
            case 'A':
                if (count == -1) {
                    int start = (dataOffset < maxDataOffset) ? dataOffset : maxDataOffset;
                    result.add(data.substring(start));
                    dataOffset = maxDataOffset;
                } else {
                    int start = (dataOffset < maxDataOffset) ? dataOffset : maxDataOffset;
                    int end = (dataOffset + count < maxDataOffset) ? dataOffset + count : maxDataOffset;
                    result.add(data.substring(start, end));
                    dataOffset += count;
                }
                break;
            case 'x':
                // to do...
                break;
            case 'X':
                // to do...
                break;
            default:
                throw new ParseException("Unknown action token", formatOffset);
            }
            formatOffset += tokenLen + 1;
        }
        return (String[]) result.toArray(new String[result.size()]);
    }
 
    /**
     * Aggregates repetitly a basic pattern.
     * 
     * @param pattern
     * @param count
     * @return
     */
    static String aggregate(String pattern, int count) {
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < count; i++)
            buffer.append(pattern);
        return buffer.toString();
    }
}

et son utilisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
import my.UnPack;
...
        String[] field = null;
...
        try {
            field = UnPack.unpack("A11 A1 A8 A8 A8 A6 A*", line);
        } catch (ArrayIndexOutOfBoundsException ex) {
            System.out.println(ex);
        } catch (ParseException ex) {
            System.out.println(ex);
        }

Voilà :roll:

31/01/2008, 13h57
josiasseb

[Resolu]

Trop fort!

C'était trop fort pour moi de re-coder la fonction elle-même en entier.
Un grand merci.