com.jelastic.api.core.utils.StringUtils Maven / Gradle / Ivy
/*Server class MD5: 135550f279c166498f14afcbfb609c96*/
package com.jelastic.api.core.utils;
import org.json.JSONObject;
import java.util.regex.Pattern;
import java.util.zip.CRC32;
import java.util.zip.Checksum;
import java.util.*;
/**
* @name Jelastic API Client
* @version 8.11.2
* @copyright Jelastic, Inc.
*/
public class StringUtils {
private static final Pattern DOUBLE_PATTERN = Pattern.compile("[\\x00-\\x20]*[+-]?(NaN|Infinity|((((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)" + "([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)|" + "(((0[xX](\\p{XDigit}+)(\\.)?)|(0[xX](\\p{XDigit}+)?(\\.)(\\p{XDigit}+)))" + "[pP][+-]?(\\p{Digit}+)))[fFdD]?))[\\x00-\\x20]*");
public static final String EMPTY = "";
public static final int INDEX_NOT_FOUND = -1;
public static final String serialize(Object obj) {
if (obj == null) {
return null;
} else if (obj instanceof String) {
return (String) obj;
} else if (obj instanceof Map) {
return new JSONObject((Map) obj).toString();
} else {
return obj.toString();
}
}
public static String join(Object[] array, String separator) {
if (array == null) {
return null;
}
return join(array, separator, 0, array.length);
}
public static String join(Object[] array) {
return join(array, null);
}
public static String join(Object[] array, String separator, int startIndex, int endIndex) {
if (array == null) {
return null;
}
if (separator == null) {
separator = EMPTY;
}
int bufSize = (endIndex - startIndex);
if (bufSize <= 0) {
return EMPTY;
}
bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length()) + separator.length());
StringBuilder buf = new StringBuilder(bufSize);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
if (array[i] != null) {
buf.append(array[i]);
}
}
return buf.toString();
}
public static final String join(Set set, String sprt) {
return join(set.toArray(), sprt);
}
public static final String join(Collection coll, String sprt) {
return join(coll.toArray(), sprt);
}
public static String joinWithoutLn(String[] array, String sprt) {
String result = "";
if (array.length == 0) {
return result;
}
for (String string : array) {
result += sprt + string;
}
return result.substring(1);
}
public static String joinWithoutLn(Collection collection, String sprt) {
String result = "";
for (Object element : collection) {
result += sprt + element;
}
return collection.isEmpty() ? result : result.substring(1);
}
public static String capitalize(String string) {
if (string == null || string.isEmpty()) {
return "";
}
return string.substring(0, 1).toUpperCase() + string.substring(1);
}
public static String capitalizeFirstLetter(String original) {
if (original.length() == 0)
return original;
return original.substring(0, 1).toUpperCase() + original.substring(1);
}
public static String coalesce(String... params) {
for (String val : params) {
if (val != null) {
return val;
}
}
return null;
}
public static boolean isBoolean(String str) {
if (isEmpty(str)) {
return false;
}
return Boolean.TRUE.toString().equalsIgnoreCase(str) || Boolean.FALSE.toString().equalsIgnoreCase(str);
}
public static boolean isFloat(String s) {
return DOUBLE_PATTERN.matcher(s).matches();
}
public static String replaceLast(String target, String replacement, String string) {
int lastIndex = string.lastIndexOf(target);
if (lastIndex == -1) {
return string;
}
String beginString = string.substring(0, lastIndex);
String endString = string.substring(lastIndex + target.length());
return beginString + replacement + endString;
}
public static boolean isNotBlank(final CharSequence cs) {
return !isBlank(cs);
}
public static boolean isBlank(final CharSequence cs) {
final int strLen = length(cs);
if (strLen == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(cs.charAt(i))) {
return false;
}
}
return true;
}
public static int length(final CharSequence cs) {
return cs == null ? 0 : cs.length();
}
public static boolean equalsIgnoreCase(final CharSequence cs1, final CharSequence cs2) {
if (cs1 == cs2) {
return true;
}
if (cs1 == null || cs2 == null) {
return false;
}
if (cs1.length() != cs2.length()) {
return false;
}
return regionMatches(cs1, true, 0, cs2, 0, cs1.length());
}
private static boolean regionMatches(CharSequence cs, boolean ignoreCase, int thisStart, CharSequence substring, int start, int length) {
if (cs instanceof String && substring instanceof String) {
return ((String) cs).regionMatches(ignoreCase, thisStart, (String) substring, start, length);
} else {
return cs.toString().regionMatches(ignoreCase, thisStart, substring.toString(), start, length);
}
}
public static String trimToEmpty(final String str) {
return str == null ? EMPTY : str.trim();
}
public static String stripToEmpty(String str) {
return str == null ? EMPTY : strip(str, null);
}
public static String strip(String str, String stripChars) {
if (isEmpty(str)) {
return str;
}
str = stripStart(str, stripChars);
return stripEnd(str, stripChars);
}
public static String stripStart(String str, String stripChars) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return str;
}
int start = 0;
if (stripChars == null) {
while (start != strLen && Character.isWhitespace(str.charAt(start))) {
start++;
}
} else if (stripChars.length() == 0) {
return str;
} else {
while (start != strLen && stripChars.indexOf(str.charAt(start)) != INDEX_NOT_FOUND) {
start++;
}
}
return str.substring(start);
}
public static String stripEnd(String str, String stripChars) {
int end;
if (str == null || (end = str.length()) == 0) {
return str;
}
if (stripChars == null) {
while (end != 0 && Character.isWhitespace(str.charAt(end - 1))) {
end--;
}
} else if (stripChars.length() == 0) {
return str;
} else {
while (end != 0 && stripChars.indexOf(str.charAt(end - 1)) != INDEX_NOT_FOUND) {
end--;
}
}
return str.substring(0, end);
}
public static boolean isEmpty(CharSequence cs) {
return cs == null || cs.length() == 0;
}
public static boolean equals(CharSequence cs1, CharSequence cs2) {
return cs1 == null ? cs2 == null : cs1.equals(cs2);
}
public static boolean contains(String str, String searchStr) {
if (str == null || searchStr == null) {
return false;
}
return str.indexOf(searchStr) >= 0;
}
public static boolean startsWith(String str, String prefix) {
return startsWith(str, prefix, false);
}
private static boolean startsWith(String str, String prefix, boolean ignoreCase) {
if (str == null || prefix == null) {
return (str == null && prefix == null);
}
if (prefix.length() > str.length()) {
return false;
}
return str.regionMatches(ignoreCase, 0, prefix, 0, prefix.length());
}
public static boolean isNotEmpty(String str) {
return !isEmpty(str);
}
public static String lowerCase(String str) {
if (str == null) {
return null;
}
return str.toLowerCase();
}
public static String formatString(String format, Object... args) {
if (format == null || args == null) {
throw new IllegalArgumentException((format == null) ? "format" : "args");
}
StringBuilder sb = new StringBuilder(format.length() + args.length * 8);
int pos = 0;
int len = format.length();
char ch = '0';
while (true) {
int p = pos;
int i = pos;
while (pos < len) {
ch = format.charAt(pos);
pos++;
if (ch == '}') {
if (pos < len && format.charAt(pos) == '}')
pos++;
else
formatError();
}
if (ch == '{') {
if (pos < len && format.charAt(pos) == '{')
pos++;
else {
pos--;
break;
}
}
sb.append(ch);
}
if (pos == len)
break;
pos++;
if (pos == len || (ch = format.charAt(pos)) < '0' || ch > '9')
formatError();
int index = 0;
do {
index = index * 10 + ch - '0';
pos++;
if (pos == len)
formatError();
ch = format.charAt(pos);
} while (ch >= '0' && ch <= '9' && index < 1000000);
if (index >= args.length)
throw new IllegalArgumentException("Index (zero based) must be greater than or equal to zero and less than the size of the argument list");
while (pos < len && (ch = format.charAt(pos)) == ' ') pos++;
boolean leftJustify = false;
int width = 0;
if (ch == ',') {
pos++;
while (pos < len && format.charAt(pos) == ' ') pos++;
if (pos == len)
formatError();
ch = format.charAt(pos);
if (ch == '-') {
leftJustify = true;
pos++;
if (pos == len)
formatError();
ch = format.charAt(pos);
}
if (ch < '0' || ch > '9')
formatError();
do {
width = width * 10 + ch - '0';
pos++;
if (pos == len)
formatError();
ch = format.charAt(pos);
} while (ch >= '0' && ch <= '9' && width < 1000000);
}
while (pos < len && (ch = format.charAt(pos)) == ' ') pos++;
Object arg = args[index];
StringBuilder fmt = null;
if (ch == ':') {
pos++;
p = pos;
i = pos;
while (true) {
if (pos == len)
formatError();
ch = format.charAt(pos);
pos++;
if (ch == '{') {
if (pos < len && format.charAt(pos) == '{')
pos++;
else
formatError();
} else if (ch == '}') {
if (pos < len && format.charAt(pos) == '}')
pos++;
else {
pos--;
break;
}
}
if (fmt == null) {
fmt = new StringBuilder();
}
fmt.append(ch);
}
}
if (ch != '}')
formatError();
pos++;
String sFmt = null;
String s = null;
if (s == null) {
if (arg != null) {
s = arg.toString();
}
}
if (s == null)
s = "";
int pad = width - s.length();
if (!leftJustify && pad > 0)
append(sb, ' ', pad);
sb.append(s);
if (leftJustify && pad > 0)
append(sb, ' ', pad);
}
return sb.toString();
}
private static void formatError() {
throw new IllegalArgumentException("Input string was not in a correct format.");
}
private static void append(StringBuilder stringBuilder, char value, int repeatCount) {
for (int i = 0; i < repeatCount; i++) {
stringBuilder.append(value);
}
}
public static String[] split(String str, char separatorChar) {
return splitWorker(str, separatorChar, false);
}
public static String[] split(String str) {
return split(str, null, -1);
}
public static String[] split(String str, String separatorChars) {
return splitWorker(str, separatorChars, -1, false);
}
public static String[] split(String str, String separatorChars, int max) {
return splitWorker(str, separatorChars, max, false);
}
private static String[] splitWorker(String str, String separatorChars, int max, boolean preserveAllTokens) {
if (str == null) {
return null;
}
int len = str.length();
if (len == 0) {
return ArrayUtils.EMPTY_STRING_ARRAY;
}
List list = new ArrayList();
int sizePlus1 = 1;
int i = 0, start = 0;
boolean match = false;
boolean lastMatch = false;
if (separatorChars == null) {
while (i < len) {
if (Character.isWhitespace(str.charAt(i))) {
if (match || preserveAllTokens) {
lastMatch = true;
if (sizePlus1++ == max) {
i = len;
lastMatch = false;
}
list.add(str.substring(start, i));
match = false;
}
start = ++i;
continue;
}
lastMatch = false;
match = true;
i++;
}
} else if (separatorChars.length() == 1) {
char sep = separatorChars.charAt(0);
while (i < len) {
if (str.charAt(i) == sep) {
if (match || preserveAllTokens) {
lastMatch = true;
if (sizePlus1++ == max) {
i = len;
lastMatch = false;
}
list.add(str.substring(start, i));
match = false;
}
start = ++i;
continue;
}
lastMatch = false;
match = true;
i++;
}
} else {
while (i < len) {
if (separatorChars.indexOf(str.charAt(i)) >= 0) {
if (match || preserveAllTokens) {
lastMatch = true;
if (sizePlus1++ == max) {
i = len;
lastMatch = false;
}
list.add(str.substring(start, i));
match = false;
}
start = ++i;
continue;
}
lastMatch = false;
match = true;
i++;
}
}
if (match || (preserveAllTokens && lastMatch)) {
list.add(str.substring(start, i));
}
return (String[]) list.toArray(new String[list.size()]);
}
private static String[] splitWorker(String str, char separatorChar, boolean preserveAllTokens) {
if (str == null) {
return null;
}
int len = str.length();
if (len == 0) {
return ArrayUtils.EMPTY_STRING_ARRAY;
}
List list = new ArrayList();
int i = 0, start = 0;
boolean match = false;
boolean lastMatch = false;
while (i < len) {
if (str.charAt(i) == separatorChar) {
if (match || preserveAllTokens) {
list.add(str.substring(start, i));
match = false;
lastMatch = true;
}
start = ++i;
continue;
}
lastMatch = false;
match = true;
i++;
}
if (match || (preserveAllTokens && lastMatch)) {
list.add(str.substring(start, i));
}
return (String[]) list.toArray(new String[list.size()]);
}
public static List splitToInt(String string, String separator) {
String[] elements = string.split(separator);
List intElements = new ArrayList<>();
for (String element : elements) {
intElements.add(Integer.parseInt(element));
}
return intElements;
}
public static boolean convertToBoolean(String value) {
boolean returnValue = false;
if ("1".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value)) {
returnValue = true;
}
return returnValue;
}
public static boolean equalsIgnoreCase(String str1, String str2) {
return str1 == null ? str2 == null : str1.equalsIgnoreCase(str2);
}
public static String crc32Checksum(String input) {
byte[] bytes = input.getBytes();
Checksum checksum = new CRC32();
checksum.update(bytes, 0, bytes.length);
return Long.toHexString(checksum.getValue());
}
public static String[] splitAndTrim(String value) {
return splitAndTrim(value, 0);
}
private static String[] splitAndTrim(String value, int limit) {
if (value != null) {
return value.trim().split("\\s*,\\s*|\\s*;\\s*", limit);
}
return new String[] {};
}
public static String[] splitAndTrimSkipEmpty(String value) {
return splitAndTrim(value, -1);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy