Discussion :

[domiq44]

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 : fichier « month.txt » :

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

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 :

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

1
2
 
($id, $days, $month) = unpack ($line, "A2A2A*");

Mais en Java, comment faire ?

Merci.

[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 :

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

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"

[josiasseb]

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 :

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

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"

Je reprends cette discussion afin d'avoir de plus amples informations.

Quel serai l'équivalent de cette syntaxe perl:

Code :

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

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 :

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

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

[josiasseb]

J'ai trouvé grâce à un collègue:

Code :

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

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]

[domiq44]

J'ai une solution qui fonctionne

Créer la classe Unpack :

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

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

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à

[josiasseb]

Trop fort!

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