String pattern1 = "hgb"; String pattern2 = "|"; String text = "sdfjsdkhfkjsdf hgb sdjfkhsdkfsdf |sdfjksdhfjksd sdf sdkjfhsdkf | sdkjfh hgb sdkjfdshfks|"; Pattern p = Pattern.compile(Pattern.quote(pattern1) + "(.*?)" + Pattern.quote(pattern2)); Matcher m = p.matcher(text); while (m.find()) { System.out.println(m.group(1)); }
public void bindStringRegex(String var, String regex) { // Enforce requirements on variable names ($alphanumeric_) if (!STRING_REGEX_VAR_NAME_PATTERN.matcher(var).matches()) { throw new IllegalArgumentException("StringRegex binding error: Invalid variable name " + var); } Pattern varPattern = Pattern.compile(Pattern.quote(var)); String replace = Matcher.quoteReplacement(regex); stringRegexVariables.put(var, new Pair<>(varPattern, replace)); }
SystemUtils.run(process, outputWriter, null); String output = outputWriter.getBuffer().toString(); Pattern docClose = Pattern.compile("</DOC>.*", Pattern.DOTALL); output = docClose.matcher(output).replaceAll("</DOC>").replaceAll("<!DOCTYPE TimeML SYSTEM \"TimeML.dtd\">",""); //TODO TimeML.dtd? FileNotFoundException if we leave it in Pattern badNestedTimex = Pattern.compile(Pattern.quote("<T</TIMEX3>IMEX3")); output = badNestedTimex.matcher(output).replaceAll("</TIMEX3><TIMEX3"); Pattern badNestedTimex2 = Pattern.compile(Pattern.quote("<TI</TIMEX3>MEX3")); output = badNestedTimex2.matcher(output).replaceAll("</TIMEX3><TIMEX3"); document.set(TimeAnnotations.TimexAnnotations.class, timexAnns); if (outputResults) { System.out.println(timexAnns);
import java.util.Arrays; import java.util.regex.Pattern; public class SplitExample { public static final String PLAYER = "1||1||Abdul-Jabbar||Karim||1996||1974"; public static void main(String[] args) { String[] data = PLAYER.split("\\|\\|"); System.out.println(Arrays.toString(data)); Pattern pattern = Pattern.compile("\\|\\|"); data = pattern.split(PLAYER); System.out.println(Arrays.toString(data)); pattern = Pattern.compile(Pattern.quote("||")); data = pattern.split(PLAYER); System.out.println(Arrays.toString(data)); } }
private String toStringDep() { String str = ""; if(classORrestrictions!= null && !this.classORrestrictions.isEmpty()) { for (Map.Entry<Class, String> en : this.classORrestrictions.entrySet()) { String orgVal = en.getValue().toString(); String val; if(!alphaNumeric.matcher(orgVal).matches()) val = "/" + Pattern.quote(orgVal.replaceAll("/","\\\\/"))+ "/"; else val = orgVal; if (str.isEmpty()) str = "{" + class2KeyMapping.get(en.getKey()) + ":" + val + "}"; else str += " | " + "{" + class2KeyMapping.get(en.getKey()) + ":" + val + "}"; } } return str.trim(); }
private int extractMaxIndex(String key, String suffixPattern) { // extract index and property keys final String escapedKey = Pattern.quote(key); final Pattern pattern = Pattern.compile(escapedKey + "\\.(\\d+)" + suffixPattern); final IntStream indexes = properties.keySet().stream() .flatMapToInt(k -> { final Matcher matcher = pattern.matcher(k); if (matcher.find()) { return IntStream.of(Integer.valueOf(matcher.group(1))); } return IntStream.empty(); }); // determine max index return indexes.max().orElse(-1); }
private Collection<RuleRepositoryDto> listMatchingRepositories(@Nullable String query, @Nullable String languageKey) { Pattern pattern = Pattern.compile(query == null ? MATCH_ALL : MATCH_ALL + Pattern.quote(query) + MATCH_ALL, Pattern.CASE_INSENSITIVE); return selectFromDb(languageKey).stream() .filter(r -> pattern.matcher(r.getKey()).matches() || pattern.matcher(r.getName()).matches()) .collect(MoreCollectors.toList()); }
PatternFactory.ignoreWordRegex = Pattern.compile(wordIgnoreRegex); System.out.println("Reading english words from " + englishWordsFiles); for (String englishWordsFile : englishWordsFiles.split("[;,]")) englishWords.addAll(IOUtils.linesFromFile(englishWordsFile)); System.out.println("Size of othersemantic class variables is " + otherSemanticClassesWords.size()); } else { otherSemanticClassesWords = Collections.synchronizedSet(new HashSet<>()); System.out.println("Size of othersemantic class variables is " + 0); if (i > 0) stopStr += "|"; stopStr += Pattern.quote(s.getPhrase().replaceAll("\\\\", "\\\\\\\\")); i++;
public static String getValidFilename(String filename) { if (LangUtils.isValueBlank(filename)) { return null; } if (isSystemWindows()) { if (!filename.contains("\\\\")) { String[] parts = filename.substring(FilenameUtils.getPrefixLength(filename)).split(Pattern.quote(File.separator)); for (String part : parts) { if (INVALID_FILENAME_PATTERN.matcher(part).find()) { throw new FacesException("Invalid filename: " + filename); } } } else { throw new FacesException("Invalid filename: " + filename); } } String name = FilenameUtils.getName(filename); String extension = FilenameUtils.EXTENSION_SEPARATOR_STR + FilenameUtils.getExtension(filename); if (extension.equals(FilenameUtils.EXTENSION_SEPARATOR_STR)) { throw new FacesException("File must have an extension"); } else if (name.isEmpty() || extension.equals(name)) { throw new FacesException("Filename can not be the empty string"); } return name; }
public static String getExctWsRegex(String targetString) { StringBuilder sb = new StringBuilder(); String[] fields = whitespacePattern.split(targetString); for (String field:fields) { // require at least one whitespace if there is whitespace in target string if (sb.length() > 0) { sb.append("\\s+"); } // Allow any number of spaces between punctuation and text String tmp = punctWhitespacePattern.matcher(field).replaceAll(" $1 "); tmp = tmp.trim(); String[] punctFields = whitespacePattern.split(tmp); for (String f:punctFields) { if (sb.length() > 0) { sb.append("\\s*"); } sb.append(Pattern.quote(f)); } } return sb.toString(); }
/** * Takes an input String, and replaces any bash-style variables (e.g., $VAR_NAME) * with its actual environment variable from the passed environment specification. * * @param raw The raw String to replace variables in. * @param env The environment specification; e.g., {@link System#getenv()}. * @return The input String, but with all variables replaced. */ public static String expandEnvironmentVariables(String raw, Map<String, String> env) { String pattern = "\\$\\{?([a-zA-Z_]+[a-zA-Z0-9_]*)\\}?"; Pattern expr = Pattern.compile(pattern); String text = raw; Matcher matcher = expr.matcher(text); while (matcher.find()) { String envValue = env.get(matcher.group(1)); if (envValue == null) { envValue = ""; } else { envValue = envValue.replace("\\", "\\\\"); } Pattern subexpr = Pattern.compile(Pattern.quote(matcher.group(0))); text = subexpr.matcher(text).replaceAll(envValue); } return text; }
private Collection<Language> listMatchingLanguages(@Nullable String query, int pageSize) { Pattern pattern = Pattern.compile(query == null ? MATCH_ALL : MATCH_ALL + Pattern.quote(query) + MATCH_ALL, Pattern.CASE_INSENSITIVE); SortedMap<String, Language> languagesByName = Maps.newTreeMap(); for (Language lang : languages.all()) { if (pattern.matcher(lang.getKey()).matches() || pattern.matcher(lang.getName()).matches()) { languagesByName.put(lang.getName(), lang); } } List<Language> result = Lists.newArrayList(languagesByName.values()); if (pageSize > 0 && pageSize < result.size()) { result = result.subList(0, pageSize); } return result; }
/** * Create filter instance. * * @param caseSensitive Case sensitive flag. * @param regex Regex search flag. * @param ptrn String to search in string presentation of key or value. */ public VisorQueryScanRegexFilter(boolean caseSensitive, boolean regex, String ptrn) { int flags = caseSensitive ? 0 : Pattern.CASE_INSENSITIVE; this.ptrn = Pattern.compile(regex ? ptrn : ".*?" + Pattern.quote(ptrn) + ".*?", flags); } /**