There are several problems

1. EntityList returns a List of Entity so CanonicalName needs to be used to get a String name.
2. The CanonicalName is either a List where the first element is a String or just a String. To get the String in either case the two argument form of First has to be used.
3. The operator form of StringMatchQ only takes one argument and no options, so a pure function has to be used

With those changes

EntityList["FiniteGroup"] // CanonicalName // 
 Select[StringMatchQ[First[#, #], RegularExpression[".*space.*"], IgnoreCase -> True] &]

the result is an empty list. To check that it is working correctly

EntityList["FiniteGroup"] // CanonicalName // 
 Select[StringMatchQ[First[#, #], RegularExpression[".*abelian.*"], IgnoreCase -> True] &]

It is possible for the first case

ClearAll@selectN
selectN[predicate_][n_ : Infinity] := Select[#, predicate, n] &

Names["System`*Values"] // 
 selectN[StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"]][]

Names["System`*Values"] // 
 selectN[StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"]][2]

You can use this to write select functions for different predicates e.g.

valuesSelect = 
  selectN[StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"]];
Names["System`*Values"] // valuesSelect[3]

unitDeterminantSelect = selectN[Det[#] == 1 &];
Tuples[{0, 1}, {3, 3}] // unitDeterminantSelect[3]

But if you need to be able to return all matches then maybe this is better

ClearAll@selectN
selectN[predicate_, n_ : Infinity] := Select[#, predicate, n] &

Names["System`*Values"] // 
 selectN[StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"]]

Names["System`*Values"] // 
 selectN[StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"], 2]

From the documentation for Select

Select[crit] represents an operator form of Select that can be applied to an expression.

Notice that there is only one argument in the operator form. You can mimic the operator form using a pure function

Names["System`*Values"] // 
 Select[#, StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"], 2] &

Or you can generalize it

selectN[n_][predicate_] := Select[#, predicate, n] &

Names["System`*Values"] // 
 selectN[3][StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"]]

Or if you prefer

ClearAll@selectN
selectN[predicate_][n_] := Select[#, predicate, n] &

Names["System`*Values"] // 
 selectN[StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"]][3]

I want to some tips with the pattern like "(Down|Own|Sub|Up)Values".

That part was not clear in your original question.

Using StringExpression

Names["System`*Values"] // 
 Select[StringMatchQ[StartOfString ~~ "Down" | "Own" | "Sub" | "Up" ~~ "Values"]]

Using RegularExpression

Names["System`*Values"] // 
 Select[StringMatchQ[RegularExpression["^(Down|Own|Sub|Up)Values"]]]

This is the operator form of Map and is documented

Map[Information][List[DownValues]]

Map[f] represents an operator form of Map that can be applied to an expression.

Many built-in functions support an operator form. Take a look at this

The Select and StringMatchQ example above uses the operator form.

Another example - which primes in the range 1 - 1000 have a digit sum that is also prime.

Range[1000] // Select[PrimeQ] // AssociationMap[IntegerDigits/*Total] // Select[PrimeQ]

Not sure what you mean. If you already have the list of symbol names you are interested in why do you need to extract them from another list? Anyway, one way to do it using Names rather than pattern matching.

Names["System`*Values"] // 
  Select[MemberQ[{"DownValues", "OwnValues", "SubValues", "UpValues"}, #] &] //
  Map[Information]