You simply need to escape the special characters. Try:

[a-zA-Z0-9\-#\.\(\)\/%&\s]{0,19}

You can test your regular expressions on http://rubular.com/

Try this regex

[\w-]+

Which matches all below

ABC12-xy
ABCD
ABC12_12
12-AB_xy

It looks like it will not match a whole string containing a mix of alphanumerics and symbols because of the OR in the middle.

e.g. it wont match abcABC()+, but will match abcABC and will match ()+

Try:

([a-zA-Z0-9\\'\\(\\+\\)\\,\\-\\.\\=]+)

Hope this helps!

I'm new to regular expressions in Java and I need to validate if a string has alphanumeric chars, commas, apostrophes and full stops (periods) only.

I suggest you use the \p{Alnum} class to match alpha-numeric characters:

Pattern p = Pattern.compile("[\\p{Alnum},.']*");

(I noticed that you included \s in your current pattern. If you want to allow white-space too, just add \s in the character class.)

From documentation of Pattern:

[...]

\p{Alnum} An alphanumeric character:[\p{Alpha}\p{Digit}]

[...]

You don't need to include ^ and {1, ...}. Just use methods like Matcher.matches or String.matches to match the full pattern.

Also, note that you don't need to escape . within a character class ([...]).

Considering you want to check for ASCII Alphanumeric characters, Try this: "^[a-zA-Z0-9]*$". Use this RegEx in String.matches(Regex), it will return true if the string is alphanumeric, else it will return false.

public boolean isAlphaNumeric(String s){
    String pattern= "^[a-zA-Z0-9]*$";
    return s.matches(pattern);
}

If it will help, read this for more details about regex: http://www.vogella.com/articles/JavaRegularExpressions/article.html

Use the ^ and $ anchors to instruct the regex engine to start matching from the beginning of the string and stop matching at the end of the string, so taking your regex:

^(\\W).{1,1}(\\w+)$

Please take a look at this Oracle (Java) tutorial on regular expressions.

I suggest you to use more readable refactored regex as this:

final String re = 
             "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*\\p{Punct})[\\p{ASCII}&&[\\S]]{8,}$";

Code Demo

RegEx Breakup:

• ^: Start
• (?=.*[0-9]): Lookahead to assert we have at least one digit
• (?=.*[a-z]): Lookahead to assert we have at least one lowercase letter
• (?=.*[A-Z]): Lookahead to assert we have at least one uppercase letter
• (?=.*\\p{Punct}): Lookahead to assert we have at least one punctuation character
• [\\p{ASCII}&&[\\S]]{8,}: Intersection composite character class to match 8 or more ASCII and non-white-space characters
• $: End

You can use the below regex to achieve your purpose:

^[\w][\S]{0,8}$

Explanation of the above regex:

^ - Represents the start of the line.

[\w] - Matches a character from [0-9a-zA-Z_]. If you do not want _(underscore) then provide the character class manually.[0-9A-Za-z]

[\S]{0,8} - Matches any non-space character 0 to 8 times.

$ - Represents end of the line.

You can find the demo of the above regex here.

Implementation in java:(You can modify the code accordingly to suit your requirements)

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main
{
    private static final Pattern pattern = Pattern.compile("^[\\w][\\S]{0,8}$", Pattern.MULTILINE);
    public static void main(String[] args) {
        final String string = "Hello!@+\n"
     + "t123123\n"
     + "H123!#\n"
     + "@adadsa\n"
     + "@3asdasd\n"
     + "%sdf\n"
     + "Helloworld1";
     
     Matcher matcher = pattern.matcher(string);
     while(matcher.find())
        System.out.println(matcher.group(0));
    }
}

You can find the sample run of the above implementation in here.

Since you want to split only on £ or $ I would suggest to put them in your own character class [£$] instead using predefined one which contains many characters that probably shouldn't be split. So try something like split("\\s|(?<=[£$])") which will split on

• \\s - every whitespace
• (?<=[£$]) - every place that has £ or $ before it like $|100 (| represents such place). Mechanism used here is called look-behind.

Demo

for (String s : "I have $100 and £200".split("\\s|(?<=[£$])"))
    System.out.println(">" + s);

output:

>I
>have
>$
>100
>and
>£
>200

You could match either == or a question mark in a capturing group, and use a backreference to group 1 using \1

You can use the character class [a-zA-Z0-9] or extend it to use \w (Note to use A-Z instead of A-z)

(==|\?)\h*\w+(?:\h+\w+)*\h*\1

• (==|\?) Capture group 1, match either == or ?
• \h* Match 1+ horizontal whitespace chars
• \w+ Match 1+ word chars
• (?:\h+\w+)* Optionally repeat matching the horizontal whitespace chars and word chars
• \h* Match 1+ horizontal whitespace chars
• \1 Backreference to group 1

Regex demo

In Java

String regex = "(==|\\?)\\h*\\w+(?:\\h+\\w+)*\\h*\\1";