Optimize the speed of execution

[Vodka]

Hello,
I am trying to make a small Java program that uses the regex library provided by Java. However, I have some problems with it.
Firstly I found the API very slow regex . In fact, I mainly use the replaceAll method of the string class (which uses the regex API) and some processing takes some time (several thousands of iterations / call to replaceAll). Is there a solution to optimize the speed of execution of this method? Thanks in advance.

[Windowed]

Hello,
If the pattern is always the same, it is optimized to do that is to create it once and for all, eg if you have something like this:
for (...) {
String rs = line.replaceAll("regex", "Replacement");
}
You could do this:

Pattern pattern = Pattern.compiles("regex");
for (...) {
    String rs = pattern.matcher(line).replaceAll("Replacement");
}

[Vodka]

Hello,

If the pattern is always the same, it is optimized to do that is to create it once and for all, eg if you have something like this:

Naturally, I'll try this track and see the difference .

You'll have your posts regexp and purpose ...

for regex looks like stuff like enabling matcher comments:
- / \ * [\ U0000-\ uffff] *? \ * / -> Java /*...*/ comment
- / / .* -> Java comment //...
Thank you for your help . There.

[HardWeaR]

Hello,
For error. I remember having this problem with java 1.4, it was resolved with a superior version of Java whose implementation was clearly different. Without ever knowing why it shows! Everything I've done at the time was that the regexp was not involved, it was mainly the length of the string on which they made the match that involved a large recursion. by the cons [\ u0000-\ uffff] here is a very large range and includes the sequence here * /, you may not nab the end of comment since the regexp is greedy algorithm by default.

[GlassFish]

Hello,
To do it right it uses a quantified "reluctant" (the *?).
For what interest cons of using [\ u0000-\ uffff] where the point would be the case:

String pattern = "/\\*.*?\\*/";

Hope this will help you. If not then you can try something other, but before that you need to try this.

[cyber-noob]

Hello,
The first point regarding the compilation of pattern. Indeed, the failure to recompile the pattern every time improves the speed of program execution . I can not tell you the percentage / ratio of increase is visible but without calculation so it should still be significant. The only snag some treatment is still long (and yet I use separate threads ...). I use 1.5 in my case and I still make mistakes, but as it has been said above I think it comes from the regex in itself because it only happens on some type of regex type (x | y) *.