For Java:

[Quantifiers documentation][1]

X, exactly n times: X{n}  
X, at least n times: X{n,}  
X, at least n but not more than m times: X{n,m}


  [1]: http://docs.oracle.com/javase/tutorial/essential/regex/quant.html

The finite repetition syntax uses `{m,n}` in place of star/plus/question mark.

From [`java.util.regex.Pattern`](http://download.oracle.com/docs/cd/E17409_01/javase/6/docs/api/java/util/regex/Pattern.html):

    X{n}      X, exactly n times
    X{n,}     X, at least n times
    X{n,m}    X, at least n but not more than m times

All repetition metacharacter have the same precedence, so just like you may need grouping for `*`, `+`, and `?`, you may also for `{n,m}`.

* `ha*` matches e.g. `&quot;haaaaaaaa&quot;`
* `ha{3}` matches only `&quot;haaa&quot;`
* `(ha)*` matches e.g. `&quot;hahahahaha&quot;`
* `(ha){3}` matches only `&quot;hahaha&quot;`

Also, just like `*`, `+`, and `?`, you can add the `?` and `+` reluctant and possessive repetition modifiers respectively.

		System.out.println(
			&quot;xxxxx&quot;.replaceAll(&quot;x{2,3}&quot;, &quot;[x]&quot;)
		); &quot;[x][x]&quot;

		System.out.println(
			&quot;xxxxx&quot;.replaceAll(&quot;x{2,3}?&quot;, &quot;[x]&quot;)
		); &quot;[x][x]x&quot;

Essentially anywhere a `*` is a repetition metacharacter for &quot;zero-or-more&quot;, you can use `{...}` repetition construct. Note that it&#39;s not true the other way around: you can use finite repetition in a lookbehind, but you can&#39;t use `*` because Java doesn&#39;t officially support infinite-length lookbehind.

### References

* [regular-expressions.info/Repetition](http://www.regular-expressions.info/repeat.html)

### Related questions

* [Difference between `.*` and `.*?` for regex](https://stackoverflow.com/questions/3075130/difference-between-and-for-regex/3075532#3075532)
* [`regex{n,}?` == `regex{n}`?](https://stackoverflow.com/questions/3184484/regexn-regexn/)
* [Using explicitly numbered repetition instead of question mark, star and plus](https://stackoverflow.com/questions/3032593/using-explicitly-numbered-repetition-instead-of-question-mark-star-and-plus)
   * Addresses the habit of some people of writing `a{1}b{0,1}` instead of `ab?`

`^\w{14}$` in Perl and any Perl-style regex.

If you want to learn more about regular expressions - or just need a handy reference -  the [Wikipedia Entry on Regular Expressions][1] is actually pretty good.


  [1]: http://en.wikipedia.org/wiki/Regular_expression

In Java create the pattern with `Pattern p = Pattern.compile(&quot;^\\w{14}$&quot;);` for further information [see the javadoc][1]


  [1]: http://download.oracle.com/docs/cd/E17476_01/javase/1.4.2/docs/api/java/util/regex/Pattern.html

How can I get the RGB value of a particular pixel in a UIImage?

Get Pixel color of UIImage

How do I throw a 404 error from within a java servlet? My web.xml already specifies what page to show when there is a 404, how do I throw a 404 from within a servlet?

How do I throw a 404 error from within a java servlet?

I am wondering if there is a better to represent a fix amount of repeats in a regular expression. For example, if I just want to match exactly 14 letters/digits, I am using `^\w\w\w\w\w\w\w\w\w\w\w\w\w\w$` which will match a word like `UNL075BE499135` and not match `UNL075BE499135AAA`
is there a handy way to do it? In am currently doing it in java but I guess this may apply to other language as well. Thanks in advance.


How to represent a fix number of repeats in regular expression?

<p>I am wondering if there is a better to represent a fix amount of repeats in a regular expression. For example, if I just want to match exactly 14 letters/digits, I am using <code>^\w\w\w\w\w\w\w\w\w\w\w\w\w\w$</code> which will match a word like <code>UNL075BE499135</code> and not match <code>UNL075BE499135AAA</code>
is there a handy way to do it? In am currently doing it in java but I guess this may apply to other language as well. Thanks in advance.</p>


This method:

    boolean containsSmiley(String s) {
        if (s == null) {
            return false;
        }
        else {
            return s.contains(&quot;:)&quot;);
        }
    }

can equivalently be written:

    boolean containsSmiley(String s) {
        if (s == null) {
            return false;
        }
    
        return s.contains(&quot;:)&quot;);
    }

In my experience, the second form is seen more often, especially in more complex methods (where there may be several such exit points), and the same is true for &quot;throw&quot; as well as &quot;return&quot;. Yet the first form arguably makes the conditional structure of the code more explicit. Are there any reasons to prefer one over the other?

(Related: [Should a function have only one return statement?][1])


  [1]: https://stackoverflow.com/questions/36707/should-a-function-have-only-one-return-statement

Why is &quot;else&quot; rarely used after &quot;if x then return&quot;?

I need to display a file size as a *string* using sensible units.

For example,

    1L ==&gt; &quot;1 B&quot;;
    1024L ==&gt; &quot;1 KB&quot;;
    2537253L ==&gt; &quot;2.3 MB&quot;

etc.

I found [this previous answer][1], which I didn&#39;t find satisfactory.

I have come up with my own solution which has similar shortcomings:

    private static final long K = 1024;
    private static final long M = K * K;
    private static final long G = M * K;
    private static final long T = G * K;

    public static String convertToStringRepresentation(final long value){
        final long[] dividers = new long[] { T, G, M, K, 1 };
        final String[] units = new String[] { &quot;TB&quot;, &quot;GB&quot;, &quot;MB&quot;, &quot;KB&quot;, &quot;B&quot; };
        if(value &lt; 1)
            throw new IllegalArgumentException(&quot;Invalid file size: &quot; + value);
        String result = null;
        for(int i = 0; i &lt; dividers.length; i++){
            final long divider = dividers[i];
            if(value &gt;= divider){
                result = format(value, divider, units[i]);
                break;
            }
        }
        return result;
    }

    private static String format(final long value,
        final long divider,
        final String unit){
        final double result =
            divider &gt; 1 ? (double) value / (double) divider : (double) value;
        return String.format(&quot;%.1f %s&quot;, Double.valueOf(result), unit);
    }

The main problem is my limited knowledge of Decimalformat and / or String.format. I would like 1024L, 1025L, etc. to map to `1 KB` rather than `1.0 KB`.

So, two possibilities:

 1. I would prefer a good out-of-the-box solution in a public library like [Apache Commons][2] or [Google Guava][3].
 2. If there isn&#39;t, how can I get rid of the &#39;.0&#39; part (without resorting to string replacement and regex, I can do that myself)?

  [1]: https://stackoverflow.com/questions/801935/formatting-file-sizes-in-java-jstl
  [2]: https://en.wikipedia.org/wiki/Apache_Commons
  [3]: https://en.wikipedia.org/wiki/Google_Guava


Format file size as MB, GB, etc

I&#39;m trying to get a better understanding of the difference. I&#39;ve found a lot of explanations online, but they tend towards the abstract differences rather than the practical implications.

Most of my programming experiences has been with CPython (dynamic, interpreted), and Java (static, compiled). However, I understand that there are other kinds of interpreted and compiled languages. Aside from the fact that executable files can be distributed from programs written in compiled languages, are there any advantages/disadvantages to each type? Oftentimes, I hear people arguing that interpreted languages can be used interactively, but I believe that compiled languages can have interactive implementations as well, correct?

Compiled vs. Interpreted Languages

What&#39;s the data structure in Java that has the fastest operation for contains() ?

e.g. i have a set of numbers { 1, 7, 12, 14, 20... }

Given another arbitrary number x, what&#39;s the fastest way (on average) to generate the boolean value of whether x is contained in the set or not? The probability for !contains() is about 5x higher.

Do all the map structures provide o(1) operation? Is HashSet the fastest way to go?

Fastest data structure for contains() in Java?

What is the simplest way to to wait for all tasks of `ExecutorService` to finish? My task is primarily computational, so I just want to run a large number of jobs - one on each core.  Right now my setup looks like this: 

    ExecutorService es = Executors.newFixedThreadPool(2);
    for (DataTable singleTable : uniquePhrases) {	
        es.execute(new ComputeDTask(singleTable));
    }
    try{
        es.wait();
    } 
    catch (InterruptedException e){
        e.printStackTrace();
    }

`ComputeDTask` implements runnable.  This appears to execute the tasks correctly, but the code crashes on `wait()` with `IllegalMonitorStateException`.  This is odd, because I played around with some toy examples and it appeared to work.  

`uniquePhrases` contains several tens of thousands of elements.  Should I be using another method?  I am looking for something as simple as possible

ExecutorService, how to wait for all tasks to finish

Is it possible in `JavaScript` to do something like `preg_match` does in `PHP` ?

I would like to be able to get two numbers from string:

    var text = &#39;price[5][68]&#39;;

into two separated variables:

    var productId = 5;
    var shopId    = 68;

Edit:
I also use `MooTools` if it would help.


preg_match in JavaScript?

&gt; **Possible Duplicate:**  
&gt; [How to determine if a number is a prime with regex?](https://stackoverflow.com/questions/2795065/how-to-determine-if-a-number-is-a-prime-with-regex)  

&lt;!-- End of automatically inserted text --&gt;

&lt;a href=&quot;http://www.noulakaz.net/weblog/2007/03/18/a-regular-expression-to-check-for-prime-numbers/&quot;&gt;This page&lt;/a&gt; claims that this regular expression discovers non-prime numbers (and by counter-example: primes):

    /^1?$|^(11+?)\1+$/

How does this find primes?

How does this regex find primes?

I&#39;m completely incapable of regular expressions, and so I need some help with a problem that I think would best be solved by using regular expressions.

I have list of strings in C#:

    List&lt;string&gt; lstNames = new List&lt;string&gt;();
    lstNames.add(&quot;TRA-94:23&quot;);
    lstNames.add(&quot;TRA-42:101&quot;);
    lstNames.add(&quot;TRA-109:AD&quot;);
    
    foreach (string n in lstNames) {
      // logic goes here that somehow uses regex to remove all special characters
      string regExp = &quot;NO_IDEA&quot;;
      string tmp = Regex.Replace(n, regExp, &quot;&quot;);
    }

I need to be able to loop over the list and return each item without any special characters. For example, item one would be &quot;TRA9423&quot;, item two would be &quot;TRA42101&quot; and item three would be TRA109AD. 

Is there a regular expression that can accomplish this for me?

Also, the list contains more than 4000 items, so I need the search and replace to be efficient and quick if possible.

EDIT:
I should have specified that any character beside a-z, A-Z and 0-9 is special in my circumstance.

Regex to remove all special characters from string?

I am in shell and I have this string: `12 BBQ ,45 rofl, 89 lol`

Using the regexp: `\d+ (?=rofl)`, I want `45` as a result.

Is it correct to use regex to extract data from a string? The best I have done is to highlight the value in some of the online regex editor. Most of the time it remove the value from my string.

I am investigating `expr`, but all I get is syntax errors.
 
How can I manage to extract 45 in a shell script?

How to extract a value from a string using regex and a shell?

I&#39;m a little fuzzy on what the difference between a &quot;group&quot; and a &quot;capture&quot; are when it comes to .NET&#39;s regular expression language.  Consider the following C# code:

    MatchCollection matches = Regex.Matches(&quot;{Q}&quot;, @&quot;^\{([A-Z])\}$&quot;);

I expect this to result in a single capture for the letter &#39;Q&#39;, but if I print the properties of the returned `MatchCollection`, I see:

    matches.Count: 1
    matches[0].Value: {Q}
    matches[0].Captures.Count: 1
    matches[0].Captures[0].Value: {Q}
    matches[0].Groups.Count: 2
    matches[0].Groups[0].Value: {Q}
    matches[0].Groups[0].Captures.Count: 1
    matches[0].Groups[0].Captures[0].Value: {Q}
    matches[0].Groups[1].Value: Q
    matches[0].Groups[1].Captures.Count: 1
    matches[0].Groups[1].Captures[0].Value: Q

What exactly is going on here?  I understand that there&#39;s also a capture for the entire match, but how do the groups come in?  And why doesn&#39;t `matches[0].Captures` include the capture for the letter &#39;Q&#39;?

Content Type	Original Author	Original Content on Stackoverflow
Question	Ken	View Question on Stackoverflow
Solution 1 - Java	shookster	View Answer on Stackoverflow
Solution 2 - Java	polygenelubricants	View Answer on Stackoverflow
Solution 3 - Java	eldarerathis	View Answer on Stackoverflow
Solution 4 - Java	Jano González	View Answer on Stackoverflow

How to represent a fix number of repeats in regular expression?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

References

Solution 3 - Java

Solution 4 - Java

How do I throw a 404 error from within a java servlet?

Get Pixel color of UIImage

Attributions