Is stop word.

@param text the text
@return the boolean
17073
public boolean isStopWord(HString text) {
    if (text == null) {
      return true;
    } else if (text.isInstance(Types.TOKEN)) {
      return isTokenStopWord(Cast.as(text));
    }
    return text.tokens().stream().allMatch(this::isTokenStopWord);
  }
743939
@Override
    public void setAsText(final String text) {
        if (BeanUtils.isNull(text)) {
            setValue(null);
            return;
        }
        Object newValue = Boolean.valueOf(text);
        setValue(newValue);
    }
385616
public boolean removeDivider(String text) {
        for (int k = 0; k < list.getWidgetCount(); k++) {
            Widget w = list.getWidget(k);
            if (isDivider(w) && w.getElement().getInnerText().equals(text)) {
                list.remove(k);
                items.remove(k);
                return true;
            }
        }
        return false;
    }
117623
public static boolean startsWithIgnoreCase( String text , String prefix , int offset )
    {
        int textLen = text.length();
        int prefixLen = prefix.length();
        
        if (offset < 0 || (offset > textLen - prefixLen))
            return false;
        
        for(int n=0;n<prefixLen;n++)
        {
            char u1 = Character.toUpperCase(text.charAt(n+offset));
            char u2 = Character.toUpperCase(prefix.charAt(n));
            if (u1 != u2)
                return false;
        }
        
        return true;
    }
1061524
public synchronized void setText(String text) {
        setLines(splitIntoMultipleLines(text));
        this.labelSize = getBounds(lines, labelSize);
        invalidate();
    }
228643
public static boolean isOnlyEmojis(@Nullable final String text) {
    if (!TextUtils.isEmpty(text)) {
      final String inputWithoutSpaces = SPACE_REMOVAL.matcher(text).replaceAll(Matcher.quoteReplacement(""));

      return EmojiManager.getInstance()
            .getEmojiRepetitivePattern()
            .matcher(inputWithoutSpaces)
            .matches();
    }

    return false;
  }
1230235
public static List<Term> segment(char[] text)
    {
        List<Term> resultList = SEGMENT.seg(text);
        ListIterator<Term> listIterator = resultList.listIterator();
        while (listIterator.hasNext())
        {
            if (!CoreStopWordDictionary.shouldInclude(listIterator.next()))
            {
                listIterator.remove();
            }
        }

        return resultList;
    }
482732
public static String reduceLineBreaks(String text) {
        if (isEmpty(text)) {
            return text;
        }
        String textTrimed = trimWhitespace(text);
        return textTrimed.replaceAll("(\\r\\n|\\r|\\n)+", "\n");
    }
745150
private boolean isWord(String token) {
    if (token.length() == 1) {
      char c = token.charAt(0);
      if (!Character.isLetter(c)) {
        return false;
      }
    }
    return true;
  }
1069590
private static boolean isName(final String _text, final boolean isFirstWord, final boolean nextWordIsName) {
        if (hasManyCaps(_text)) return true;
        else if (startsWithCap(_text)) {
            if (isFirstWord) {
                // if the word is the first word in a sentence and
                // ends with -ly (adv) -> consider it not a name
                if (_text.endsWith("ly")) return false;

                // we need to deal with the first word in the sentence very carefully.
                // as we can not tell if the first word is a name by detecting upper case characters.
                final String type_original = Dictionary.checkup(_text);
                final String type_lowercase = Dictionary.checkup(toEngLowerCase(_text));
                if (type_original == null) {
                    // if the word cannot be found in the dictionary, we consider it as a name entity.
                    if (type_lowercase == null) return true;
                }
                else if ("NNP".equals(type_original)) return true;
                //noinspection IfMayBeConditional,SimplifiableIfStatement
                if (startsWith(type_lowercase, "IN", "CC", "RB", "WRB"/*, "JJ"*/, ".")) return false;
                else return nextWordIsName;
            }
            else return true;
        }
        else return false;
    }
549791
def isLineComment(self, text):
        

        m = self.lineComment(text, 0)
        return m and m.start(0) == 0 and m.end(0) == len(text)
847481
public static String findCurrentWordFromCursor(String text, int cursor) {
        if (text.length() <= cursor + 1) {
            // return last word
            if (text.contains(SPACE)) {
                if (doWordContainEscapedSpace(text)) {
                    if (doWordContainOnlyEscapedSpace(text))
                        return switchEscapedSpacesToSpacesInWord(text);
                    else {
                        return switchEscapedSpacesToSpacesInWord(findEscapedSpaceWordCloseToEnd(text));
                    }
                }
                else {
                    if (text.lastIndexOf(SPACE) >= cursor) // cant use lastIndexOf
                        return text.substring(text.substring(0, cursor).lastIndexOf(SPACE)).trim();
                    else
                        return text.substring(text.lastIndexOf(SPACE)).trim();
                }
            }
            else
                return text.trim();
        }
        else {
            String rest;
            if (text.length() > cursor + 1)
                rest = text.substring(0, cursor + 1);
            else
                rest = text;

            if (doWordContainOnlyEscapedSpace(rest)) {
                if (cursor > 1 &&
                        text.charAt(cursor) == SPACE_CHAR && text.charAt(cursor - 1) == SPACE_CHAR)
                    return "";
                else
                    return switchEscapedSpacesToSpacesInWord(rest);
            }
            else {
                if (cursor > 1 &&
                        text.charAt(cursor) == SPACE_CHAR && text.charAt(cursor - 1) == SPACE_CHAR)
                    return "";
                // only if it contains a ' ' and its not at the end of the string
                if (rest.trim().contains(SPACE))
                    return rest.substring(rest.trim().lastIndexOf(" ")).trim();
                else
                    return rest.trim();
            }
        }
    }
186116
def remove(self, text):
        """"""
        words = text.split(' ')
        stopped_words = [word for word in words if not self.dictionary.contains(word)]

        return ' '.join(stopped_words)
1169192
public String wordSegment(String text){
		String ret = text;
		
		if (vnSegmenter == null) return ret;
		ret = vnSegmenter.segmenting(ret);
		return ret;
	}
934149
public static boolean ifNotBlank(final String text, final Consumer<String> consumer) {
        if (StringUtils.isNotBlank(text)) {
            consumer.accept(text);
            return true;
        }
        return false;
    }
341947
private boolean isWord(String token) {
    boolean isWord = true;
    if (StringUtils.isNumericSpace(token)) {
      isWord = false;
    } else if (token.length() == 1) {
      char c = token.charAt(0);
      if (!Character.isLetter(c)) {
        isWord = false;
      }
    }
    return isWord;
  }
475713
public static List<Word> seg(String text, SegmentationAlgorithm segmentationAlgorithm){        
        List<Word> words = SegmentationFactory.getSegmentation(segmentationAlgorithm).seg(text);
        //停用词过滤
        StopWord.filterStopWords(words);
        return words;
    }