Java Matcher.find方法代码示例

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
/**
 * Counts valid emojis passed string
 * 
 * @param text String to count emoji characters in.
 * @return returns count of emojis
 */
public static int countEmojis(String text) {

	String htmlifiedText = htmlify(text);
	// regex to identify html entitities in htmlified text
	Matcher matcher = htmlEntityPattern.matcher(htmlifiedText);

	int counter = 0;
	while (matcher.find()) {
		String emojiCode = matcher.group();
		if (isEmoji(emojiCode)) {
			counter++;
		}
	}
	return counter;
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
public void setHexHtml(String hexHtml) {
	this.hexHtml = hexHtml;
	Matcher matcher = htmlSurrogateEntityPattern.matcher(hexHtml);
	if(matcher.find()) {
		String signifiantHtmlEntity = matcher.group("H");
		this.setHexHtmlShort(signifiantHtmlEntity);
	} else {
		this.setHexHtmlShort(hexHtml);
	}
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
public void setDecimalHtml(String decimalHtml) {
	
	this.decimalHtml = decimalHtml;
	Matcher matcher = htmlSurrogateEntityPattern.matcher(decimalHtml);
	if(matcher.find()) {
		String signifiantHtmlEntity = matcher.group("H");
		this.setDecimalHtmlShort(signifiantHtmlEntity);
	} else {
		this.setDecimalHtmlShort(decimalHtml);
	}
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
public static List<String> detectVariables(Route route) {
    Pattern pattern = Pattern.compile("\\{(\\w+)\\}");
    Matcher matcher = pattern.matcher(route.getPath());
    List<String> variables = new ArrayList<>();
    while (matcher.find()) {
        variables.add(matcher.group(1));
    }

    return variables;
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
/**
 * Aplicar regexps al mensaje, de todas las regexps enriquequecemos usando
 * la primera regexp que nos devuelva algun resultado.
 *
 * @param message
 * @return map
 */
public Map<String, String> applyRegexps(String message) {
    logger.debug("Message: " + message);


    for (Map.Entry<String, Pattern> entry : regexpMap.entrySet()) {
        logger.debug("Regexp: " + entry.getKey() + " |||| " + entry.getValue());
        Matcher m = entry.getValue().matcher(message);

        if (m.namedGroups().size() > 0) {
            logger.debug("WITH NAMED GROUPS");
            matchesMap.putAll(m.namedGroups());
            break;
        } else {
            logger.debug("WITHOUT NAMED GROUPS");
            // First match is already catched by previous namedGroups() call, so we reset it
            m.reset();
            // Useful for regexps with <key, value> pairs
            while (m.find() && m.groupCount() > 0){
                logger.debug("Group 0: " + m.group(0));
                logger.debug("Group 1: " + m.group(this.regexpKey));
                logger.debug("Group 2: " + m.group(this.regexpValue));
                matchesMap.put(m.group(this.regexpKey), m.group(this.regexpValue));
            }
        }
    }
    return matchesMap;
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
/**
 * Get emoji by unicode, short code, decimal html entity or hexadecimal html
 * entity
 * 
 * @param code unicode, short code, decimal html entity or hexadecimal html
 * @return Emoji
 */
public static Emoji getEmoji(String code) {

	Matcher m = shortCodePattern.matcher(code);
	

	// test for shortcode with colons
	if (m.find()) {
		code = m.group(1);
	}

	Emoji emoji = null;
	// If you're running java 8 you could do this:
       /*selectFirst(EmojiManager.data(),having(on(Emoji.class).getEmoji(), Matchers.equalTo(code))
                       .or(having(on(Emoji.class).getEmoji(), Matchers.equalTo(code)))
					.or(having(on(Emoji.class).getHexHtml(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getDecimalHtml(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getDecimalSurrogateHtml(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getHexHtmlShort(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getDecimalHtmlShort(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getAliases(), Matchers.hasItem(code)))
					.or(having(on(Emoji.class).getEmoticons(), Matchers.hasItem(code))));*/

       // since i'm using Java 7 if not you can just do as follows:
       /*
       * I'll be excluding Aliases e.g. "smiley" and Emoticons e.g. :/ because they interfere with links such as http[":/"]/
	* Matchers.hasItem(code).matches(emo.getEmoticons())
       **/
	for (Emoji emo: EmojiManager.data()) {
		if (Matchers.equalTo(code).matches(emo.getEmoji()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getEmoji()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getHexHtml()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getDecimalHtml()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getDecimalSurrogateHtml()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getHexHtmlShort()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getDecimalHtmlShort()) ||
                   Matchers.hasItem(code).matches(emo.getAliases())) {
			emoji = emo;
			break;
		}
	}

	return emoji;
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
/**
 * Common method used for processing the string to replace with emojis
 * 
 * @param text
 * @param pattern
 * @return
 */
private static String processStringWithRegex(String text, Pattern pattern, int startIndex, boolean recurseEmojify) {
	//System.out.println(text);
	Matcher matcher = pattern.matcher(text);
	StringBuffer sb = new StringBuffer();
	int resetIndex = 0;
	
	if(startIndex > 0) {
		matcher.region(startIndex, text.length());
	} 
	
	while (matcher.find()) {
		
		String emojiCode = matcher.group();
		
		Emoji emoji = getEmoji(emojiCode);
		// replace matched tokens with emojis
		
		if(emoji!=null) {
			matcher.appendReplacement(sb, emoji.getEmoji());
		} else {
			if(htmlSurrogateEntityPattern2.matcher(emojiCode).matches()) {
				String highSurrogate1 = matcher.group("H1");
				String highSurrogate2 = matcher.group("H2");
				String lowSurrogate1 = matcher.group("L1");
				String lowSurrogate2 = matcher.group("L2");
				matcher.appendReplacement(sb, processStringWithRegex(highSurrogate1+highSurrogate2, shortCodeOrHtmlEntityPattern, 0, false));
				
				//basically this handles &#junk1;❤️&#junk2; scenario
				//verifies if &#junk1;❤ or &#junk1; are valid emojis via recursion
				//if not move past &#junk1; and reset the cursor to ❤
				if(sb.toString().endsWith(highSurrogate2)) {
					resetIndex = sb.length() - highSurrogate2.length();
				} else {
					resetIndex = sb.length();
				}
				sb.append(lowSurrogate1);
				sb.append(lowSurrogate2);
				break;
			} else if(htmlSurrogateEntityPattern.matcher(emojiCode).matches()) {
				//could be individual html entities assumed as surrogate pair
				String highSurrogate = matcher.group("H");
				String lowSurrogate = matcher.group("L");
				matcher.appendReplacement(sb, processStringWithRegex(highSurrogate, htmlEntityPattern, 0, true));
				resetIndex = sb.length();
				sb.append(lowSurrogate);
				break;
			} else {
				matcher.appendReplacement(sb, emojiCode);
			}
		}

	}
	matcher.appendTail(sb);
	
	//do not recurse emojify when coming here through htmlSurrogateEntityPattern2..so we get a chance to check if the tail
	//is part of a surrogate entity
	if(recurseEmojify && resetIndex > 0) {
		return emojify(sb.toString(), resetIndex);
	}
	return sb.toString();
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
/**
 * Compile the {@code Grok} pattern to named regex pattern.
 *
 * @param pattern : Grok pattern (ex: %{IP})
 * @throws Exception
 */
public void compile(String pattern) throws Exception {

  if (StringUtils.isBlank(pattern)) {
    throw new Exception("{pattern} should not be empty or null");
  }

  namedRegex = pattern;
  originalGrokPattern = pattern;
  int index = 0;
  /** flag for infinite recurtion */
  int iterationLeft = 1000;
  Boolean continueIteration = true;

  // Replace %{foo} with the regex (mostly groupname regex)
  // and then compile the regex
  while (continueIteration) {
    continueIteration = false;
    if (iterationLeft <= 0) {
      throw new Exception("Deep recursion pattern compilation of " + originalGrokPattern);
    }
    iterationLeft--;

    Matcher m = GrokUtils.GROK_PATTERN.matcher(namedRegex);
    // Match %{Foo:bar} -> pattern name and subname
    // Match %{Foo=regex} -> add new regex definition
    if (m.find()) {
      continueIteration = true;
      Map<String, String> group = m.namedGroups();
      if (group.get("definition") != null) {
        try {
          addPattern(group.get("pattern"), group.get("definition"));
          group.put("name", group.get("name") + "=" + group.get("definition"));
        } catch (Exception e) {
          // Log the exeception
        }
      }
      namedRegexCollection.put("name" + index,
          (group.get("subname") != null ? group.get("subname") : group.get("name")));
      namedRegex =
          StringUtils.replace(namedRegex, "%{" + group.get("name") + "}", "(?<name" + index + ">"
              + grokPatternDefinition.get(group.get("pattern")) + ")");
      // System.out.println(_expanded_pattern);
      index++;
    }
  }

  if (namedRegex.isEmpty()) {
    throw new Exception("Pattern not fount");
  }
  // Compile the regex
  compiledNamedRegex = Pattern.compile(namedRegex);
}
 

import com.google.code.regexp.Matcher; //导入方法依赖的package包/类
/**
 * Extracts named groups from the raw data
 *
 * @param rawData
 * @return A map of group names mapped to their extracted values or null if there are no matches
 */
public Map<String, String> extractNamedGroups(final CharSequence rawData) {

  Matcher matcher = compiledPattern.matcher(rawData);

  if (matcher.find()) {

    MatchResult r = matcher.toMatchResult();

    if (r != null && r.namedGroups() != null) {
      return r.namedGroups();
    }
  }

  return null;
}