Discussion :

[fredericL]

Bonjour,
j'aurais besoin de recoder le BufferedReader.readLine() pour qu'il s'arrete sur un caractère autre que '\n'. J'ai essayé de reprendre le code du readLine mais j'obtient des temps beaucoup plus longs. Est ce quelqu'un sait pourquoi?

Meci

[Erok]

Leur code doit être plus optimisé?

[fredericL]

J'ai repris entièrement leur code. Ils utilisent des char[], int, String et StringBuffer.
Mais je sais pas pourquoi ils sont si rapides comparé à mon code. Esc-ce qu'il y a un moyen d'être aussi rapide?

[Erok]

Est ce que c si important?
le readLine est quand meme rapide, si le tien est plu long d'un dixieme de seconde c pas bien mechant
bon bien sur si tu a 1 minute de difference la...

[bulbo]

Qu'utilises-tu pour la lecture de tes caracteres un Reader :

Tu lis les caracteres un par un :

Le mieux pour augmenter la vitesse de ce genre de chose, c'est de lire un buffer et de traiter ce buffer ensuite ...

Bulbo

[fredericL]

Sur des fichiers de 200 Mo le temps de traitement ça compte vachement.

bulbo >> j'en reviens toujours au même point (si tu te rappelle).
J'ai essayé d'utiliser un buffer avec char[] (comme dans le readLine de la classe BufferedREader).

Sinon, j'utilise un BufferedReader pour lire mes données. y a mieux?

[bulbo]

C'est clair qu'il y a un truc:

Voici le test que j'ai fait: lire ligne par ligne un fichier de 10000 lignes

Avec le BufferedReader: 140 ms de moyenne

Avec mon reader: 230 ms de moyenne (Aie la claque)

Avec la classe BufferedReader recopiee dans mon projet sans modif a part le package : 160 ms de moyenne (???)

Bulbo

[fredericL]

Qu'est ce que tu veux dire quand tu dis "BufferedReader recopiee dans mon projet sans modif a part le package"?
Tu as recopié entièrement la classe?

[bulbo]

Yep, j'ai recopie la classe dans mon projet, j'ai change le nom du package et c'est tout ..

Enfin c'est juste pour des tests, ce genre de blague n'est pas autorisee par la licence de Sun si tu veux distribuer ton appli ...

Ce qui m'enerve c'est que j'ai quasiment ecrit le meme algo qu'eux (sans pomper et en faisant gaffe a etre rapide) mais que je me prends qq chose comme 100 ms dans les dents sur un total de 140: pas glop

J'arrive pas a savoir ou je perds du temps, ca m'enerve ...

Bulbo

[fredericL]

Si tu trouves de quoi ça vient tu me dis... Je cherche de mon coté.

Merci de ton aide.

[bulbo]

En fait maintenant j'arrive meme a etre plus rapide que le BufferedReader mais ce qui me tracasse c'est que pour ca j'ai ete oblige de passer par un StringBuffer..

Initialement j'utilisais un tableau de char et c'etait plus lent : :

Bulbo

[fredericL]

Tant mieux que tu est plus rapide... est ce que tu pourrais me passer ton code... je suis en train de coder une classe de mon coté...
Moi aussi, je suis plus rapide que le readLine maintenant.

Ca viendrait pas du fait du synchronized?

Comment faire pour s'arreter sur une séquence non plus "\n" ou "\r\n" mais par exemple "$*%" (juste pour exemple).

[bulbo]

Pour la sequence tu te compliques la tache et je pense que le mieux pour ce genre de chose c'est de lire ligne par ligne et de tester la presence de la sequence en question.

Pour mon code, j'ai trouve pourquoi j'etais plus lent, en fait il semblerait que ce soit bcp plus lent de creer une String a partir d'un tableau de byte qu'a partir d'un tableau de byte ..

Pour en revenir a la sequence: si tu veux supporter ce genre de chose il faut ecrire une sorte d'analyseur lexicale..

tu memorises l'etat de ton analyseur et au cas ou tu reconnais ton pattern tu retournes la chaine

par exemple pour "$*%":

Code :

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

1
2
3
4
5
6
7
8
 
si tu lis '$' ton etat passe a 1
si ((etat == 1) && (c == '*'))
  etat = 2;
 
...
si (etat == 3)
  on a reconnu le delimiter ...

Il est evident que cet algo va prendre plus de temps qu'un bete readLine() mais sera plus rapide qu'un readLine + indexOf..

Voici mon code:

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
public class DummyTest
{
  private final static int BUF_SIZE = 8192;
  private Reader _reader;
 
  private char[] _buffer;
 
  private int _offset;
  private int _size;
 
  private char[] _result;
  private int _resSize;
 
  public DummyTest(String aFilename) throws Exception
  {
    _reader = new FileReader(aFilename);
    _offset = 0;
    _size = 0;
    _resSize = 0;
    _result = new char[BUF_SIZE];
    _buffer = new char[BUF_SIZE];
  }
 
  public String readLine(char delim) throws IOException
  {
    _resSize = 0;
    int start = 0;
    int len = 0;
    boolean eol = false;
 
    while (true)
    {
      if (_offset >= _size)
      {
        _offset = 0;
        _size = _reader.read(_buffer, 0, BUF_SIZE);
 
        if (_size == -1)
        {
          if (0 == _resSize)
          {
            return null;
          }
          else
          {
            return new String(_result);
          }
        }
      }
 
      start = _offset;
      for (; _offset < _size; _offset++)
      {
        if (_buffer[_offset] == delim)
        {
          eol = true;
          break;
        }
      }
 
      len = _offset - start;
      if ((_resSize + len) > _result.length)
      {
        char bs[] = new char[_result.length + BUF_SIZE];
        System.arraycopy(_result, 0, bs, 0, _resSize);
        _result = bs;
      }
 
      if (eol)
      {
        String result = null;
        if (0 == _resSize)
        {
          result = new String(_buffer, start, _offset - start);
        }
        else
        {
          System.arraycopy(_buffer, start, _result, _resSize, len);
          _resSize += len;
          result = new String(_result, 0, _resSize);
        }
 
        _offset++;
        return result;
      }
 
      System.arraycopy(_buffer, start, _result, _resSize, len);
      _resSize += len;
    }
  }
 
  public void close()
  {
    try
    {
      _reader.close();
    }
    catch (Exception e)
    {
    }
  }
}

Amuses-toi bien

Bulbo

[fredericL]

merci, je vais utiliser ça mais sur un seul caractère pour pas me compliquer trop.
J'ai l'autorisation d'utiliser ton code?
Merci de ton aide.

[bulbo]

Tu en fais ce que tu veux c'etait pour m'amuser...

Sur 100 lectures de fichier:

BufferedReader a une moyenne de 106 ms

Mon test a une moyenne de 100 ms (quelle fete )

Si tu veux supporter une String comme delimiteur tu peux remplacer ca:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
      start = _offset;
      for (; _offset < _size; _offset++)
      {
        if (_buffer[_offset] == delim)
        {
          eol = true;
          break;
        }
      }

Par:

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
 
// Au tout debut de readLine tu definis:
int state = 0;
 
  start = _offset;
  for (; _offset < _size; _offset++)
  {
    if (_buffer[_offset] == delim.charAt(state))
    {
      state++;
    }
    else
    {
      state = 0;
    }
 
    if (state == delim.length())
    {
      eol = true;
      break;
    }
  }

Voila et avec ca je vous mets quoi d'autre :

EDIT: avec cette nouvelle methode les 100 lectures prennent 130 ms, qui dit mieux ??

Ah oui j'avais oublie il faut aussi remplacer

Code :

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

1
2
3
 
_offset++;
return result;

par

Code :

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

1
2
3
 
_offset += delim.length();
return result;

Bulbo

[fredericL]

Merci beaucoup. C'est vraiment sympa de ta part.
Je vais faire ça.
Merci.