Upcases a string.

@param aString A string to upcase
@return The upcased string
557331
public static String upcase(final String aString) {
        return aString.substring(0, 1).toUpperCase(Locale.getDefault()) + aString.substring(1);
    }
667973
public String convertString(String string)
    {        
        int start;
        int end = 0;
        while ((start = string.indexOf("k", end)) > 0)
        {
            end = start + 1;
            char ch = string.charAt(start - 1);
            if ((ch != '.') && (ch != ' '))
                continue;
            ch = string.charAt(start + 1);
            if (!Character.isUpperCase(ch))
                continue;
            boolean isUpper = false;
            for (; end < string.length(); end++)
            {
                 ch = string.charAt(end);
                if (!Character.isJavaIdentifierPart(ch))
                    break;
                if (!Character.isUpperCase(ch))
                    isUpper = true;
            }
            if (!isUpper) if ((end - start) >= 3)
                continue;
            if (end >= string.length())
                break;

            String newName = convertNameToConstant(string.substring(start+1, end));
            
            string = string.substring(0, start) + newName + string.substring(end);

        }
        return string;
    }
659968
public boolean contentEqualsIgnoreCase(CharSequence string) {
        if (string == null || string.length() != length()) {
            return false;
        }

        if (string.getClass() == AsciiString.class) {
            AsciiString rhs = (AsciiString) string;
            for (int i = arrayOffset(), j = rhs.arrayOffset(); i < length(); ++i, ++j) {
                if (!equalsIgnoreCase(value[i], rhs.value[j])) {
                    return false;
                }
            }
            return true;
        }

        for (int i = arrayOffset(), j = 0; i < length(); ++i, ++j) {
            if (!equalsIgnoreCase(b2c(value[i]), string.charAt(j))) {
                return false;
            }
        }
        return true;
    }
1045275
private boolean startsWithIgnoreCase(final String dateString,
            final String startString) {
        final String prefix = dateString.substring(0, startString.length());
        return prefix.equalsIgnoreCase(startString);
    }
4038
public String convertToUpperCase(String value) {
        String result = null;
        if (value != null) {
            result = value.toUpperCase();
        }
        return result;
    }
1028102
public static String toUpperCaseFirstOne(String s) {
		if (Character.isUpperCase(s.charAt(0)))
			return s;
		else
			return (new StringBuilder()).append(Character.toUpperCase(s.charAt(0))).append(s.substring(1)).toString();
	}
658997
String convertCase(String str) {
        if (str == null) {
            return null;
        }
        return sensitive ? str : str.toLowerCase();
    }
1080974
def _make_one_char_uppercase(string: str) -> str:
        """"""
        if not isinstance(string, str):
            raise TypeError('string must be a string')

        if Aux.lowercase_count(string) > 0:
            while True:
                cindex = randbelow(len(string))
                if string[cindex].islower():
                    aux = list(string)
                    aux[cindex] = aux[cindex].upper()
                    string = ''.join(aux)
                    break

        return string
616124
public static String capitalize(final String string)
   {
      if (string == null)
         throw new IllegalArgumentException("string");
      if (string.equals(""))
         throw new IllegalArgumentException("string");

      return Character.toUpperCase(string.charAt(0)) + string.substring(1);
   }
1316039
public static String getWithFirstUpperCase(String string) {
        if (string == null) {
            return "";
        }

        if (string.length() == 1) {
            return string.substring(0, 1).toUpperCase();
        }

        return string.substring(0, 1).toUpperCase() + string.substring(1);
    }
1002072
public static String readAsciiString(ByteBuffer buffer, int strLen) {
        byte[] bytes = new byte[strLen];
        buffer.get(bytes);
        return new String(bytes);
    }
167397
@SuppressWarnings("unchecked")
  public String getString(String name) {
    return ((Value<String>) getValue(name)).get();
  }
638905
public static String toUpperCaseWithUnderscore(final String str) {
        if (N.isNullOrEmpty(str)) {
            return str;
        }

        String result = upperCaseWithUnderscorePropNamePool.get(str);

        if (result == null) {
            result = StringUtil.toUpperCaseWithUnderscore(str);
            upperCaseWithUnderscorePropNamePool.put(str, result);
        }

        return result;
    }
530824
public static String asTitleCase(String text) {
        StringBuilder sb = new StringBuilder();
        boolean next = true;

        for (char c : text.toCharArray()) {
            if (Character.isSpaceChar(c)) {
                next = true;
            } else if (next) {
                c = Character.toTitleCase(c);
                next = false;
            }
            sb.append(c);
        }

        return sb.toString();
    }
290130
protected String changeCase(String originalString, String mode) {
		String targetString = originalString;
		// mode is case insensitive, allow upper for example
		CaseFormatMode changeCaseMode = CaseFormatMode.get(mode.toUpperCase());
		if (changeCaseMode != null) {
			switch (changeCaseMode) {
			case LOWER_CAMEL_CASE:
				targetString = camelFormat(originalString, false);
				break;
			case UPPER_CAMEL_CASE:
				targetString = camelFormat(originalString, true);
				break;
			case SNAKE_CASE:
			case LOWER_UNDERSCORE:
				targetString = caseFormatWithDelimiter(originalString, UNDERSCORE, false, true);
				break;
			case KEBAB_CASE:
			case LISP_CASE:
			case SPINAL_CASE:
			case LOWER_HYPHEN:
				targetString = caseFormatWithDelimiter(originalString, HYPHEN_MINUS, false, true);
				break;
			case TRAIN_CASE:
				targetString = caseFormatWithDelimiter(originalString, HYPHEN_MINUS, true, false);
				break;
			case UPPER_UNDERSCORE:
				targetString = caseFormatWithDelimiter(originalString, UNDERSCORE, true, false);
				break;
			default:
				// default not doing nothing to originalString
			}
		} else {
			LOGGER.error("Unknown mode {}, returning {} unchanged", mode, targetString);
		}
		return targetString;
	}
176030
public static String upperCaseInternal(String s) {
        if (isNullOrEmpty(s)) {
            return s;
        }
        return s.toUpperCase(LOCALE_INTERNAL);
    }
10669
public static String toLowerCaseWithUnderscore(final String str) {
        if (N.isNullOrEmpty(str)) {
            return str;
        }

        String result = lowerCaseWithUnderscorePropNamePool.get(str);

        if (result == null) {
            result = StringUtil.toLowerCaseWithUnderscore(str);
            lowerCaseWithUnderscorePropNamePool.put(str, result);
        }

        return result;
    }