Check if target string starts with any of a list of specified strings beginning at the specified index.

@param target
@param toffset
@param startWith
@return
423599
public static boolean startAny(String target, Integer toffset, List<String> startWith) {
		if (isNull(target)) {
			return false;
		}
		
		return matcher(target).starts(toffset, startWith);
	}
744989
static public int skipToChars(byte[] data, int start, byte[] targets) {
        int index = start;
        int y = 0;
        byte current;
        for (; index < data.length; index++) {
            current = data[index];
            for (y = 0; y < targets.length; y++) {
                if (current == targets[y]) {
                    return index;
                }
            }
        }
        return index;
    }
1359550
public boolean find(int start, MatchResults result) {
        if (!matcher.find(start)) return false;
        applyMatch(result);
        return true;
    }
1178039
public Criteria startsWith(String... values) {
		assertValuesPresent((Object[]) values);
		return startsWith(Arrays.asList(values));
	}
385807
public Criteria startsWith(String s) {
		assertNoBlankInWildcardedQuery(s, false, true);
		predicates.add(new Predicate(OperationKey.STARTS_WITH, s));
		return this;

	}
924083
public final static <T> boolean startsWith(final Stream<T> stream, final Iterator<T> iterator) {
        final Iterator<T> it = stream.iterator();
        while (iterator.hasNext()) {
            if (!it.hasNext())
                return false;
            if (!Objects.equals(it.next(), iterator.next()))
                return false;
        }
        return true;

    }
537088
private boolean forwardMatch(String match, boolean ignoreCase, boolean resetOnTrue)
      throws
      IOException
  {
    Mark mark = reader.mark();
    List<Integer> cbuf = Lists.newArrayList();
    StringBuilder builder = new StringBuilder();

    boolean result = true;
    boolean seenChar = false;

    while (true)
    {
      cbuf.add(reader.next());

      char ch = (char) reader.curChar;

      if (reader.curChar == -1)
      {
        result = false;
        break;
      }
      else if (WHITESPACE.matches(ch))
      {
        if (seenChar)
        {
          builder.append(ch);
        }
      }
      else
      {
        if (builder.length() == 0)
        {
          seenChar = true;
        }
        builder.append(ch);
        int index = builder.length() - 1;

        if (!ignoreCase
            && (builder.charAt(index) == match.charAt(index)))
        {
          result = false;
          break;
        }

        if (ignoreCase
            && (Ascii.toLowerCase(builder.charAt(index)) != Ascii
            .toLowerCase(match.charAt(index))))
        {
          result = false;
          break;
        }
      }

      if (builder.length() == match.length())
      {
        if (!match.equalsIgnoreCase(builder.toString()))
        {
          result = false;
        }
        break;
      }
    }

    if (!result || resetOnTrue)
    {
      reader.unread(cbuf, mark);
    }

    return result;
  }
761047
public static int indexAny(String target, Integer fromIndex, String... indexWith) {
		return indexAny(target, fromIndex, Arrays.asList(indexWith));
	}
1253995
private int parseAnnotationStart(List<String> content, int lineIndex) {
        while (lineIndex > 0 && content.get(lineIndex - 1).trim().startsWith("@")) {
            lineIndex = lineIndex - 1;
        }
        return lineIndex;
    }
1018078
public static StringBuilder camelCase(final StringBuilder target, boolean firstToLower, final String... tokens) {
        for (String t: tokens) {
            if (firstToLower) {
                firstToLower = false;
                target.append(t.toLowerCase());
            } else {
                appendFirstToUpper(target, t);
            }
        }
        return target;
    }
1292120
private static boolean substringStartsWith(String string, int offset, String substring) {
    return string.regionMatches(offset, substring, 0, substring.length());
  }
1351360
public static function startsWith(
        $string,
        $target,
        $caseSensitive = true,
        $encoding = null
    ) {
        $encoding = $encoding === null ? mb_internal_encoding() : $encoding;

        if (!$caseSensitive) {
            $string = Mbstring::strtoupper($string, $encoding);
            $target = Mbstring::strtoupper($target, $encoding);
        }

        return Mbstring::strpos($string, $target, 0, $encoding) === 0;
    }
146789
public static <T> Level0ArrayOperator<String[],String> on(final String[] target) {
        return onArrayOf(Types.STRING, target);
    }
545038
public static String setOrAppend(final String target, final String value, final boolean withSpace) {
        if (target == null) {
            return value;
        }if(value == null) {
            return target;
        } else {
            if (withSpace && !target.endsWith(STRING_BLANK)) {
                return target + STRING_BLANK + value;
            } else {
                return target + value;
            }
        }
    }
485794
public T setStartOffset(long offset, TimeUnit units) {
    checkNotNull(units);

    this.startOffset = units.toMillis(offset);

    return getThis();
  }
93961
public static boolean startsWith(Object array1[], Object array2[]){
        return equals(array1, 0, array2, 0, array2.length);
    }
966437
public static int indexAny(String target, Integer fromIndex, List<String> indexWith) {
		if (isNull(target)) {
			return INDEX_NONE_EXISTS;
		}
		
		return matcher(target).indexs(fromIndex, checkNotNull(indexWith).toArray(new String[indexWith.size()]));
	}