Java tutorial
/******************************************************************************* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. *******************************************************************************/ package org.apache.ofbiz.base.util; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.StringTokenizer; import java.util.regex.Pattern; import org.apache.commons.codec.DecoderException; import org.apache.commons.codec.binary.Hex; import org.apache.ofbiz.base.lang.Appender; /** * Misc String Utility Functions * */ public class StringUtil { public static final StringUtil INSTANCE = new StringUtil(); public static final String module = StringUtil.class.getName(); private static final Map<String, Pattern> substitutionPatternMap = createSubstitutionPatternMap(); private static Map<String, Pattern> createSubstitutionPatternMap() { Map<String, Pattern> substitutionPatternMap = new LinkedHashMap<String, Pattern>(); // Preserve insertion order substitutionPatternMap.put("&&", Pattern.compile("@and", Pattern.LITERAL)); substitutionPatternMap.put("||", Pattern.compile("@or", Pattern.LITERAL)); substitutionPatternMap.put("<=", Pattern.compile("@lteq", Pattern.LITERAL)); substitutionPatternMap.put(">=", Pattern.compile("@gteq", Pattern.LITERAL)); substitutionPatternMap.put("<", Pattern.compile("@lt", Pattern.LITERAL)); substitutionPatternMap.put(">", Pattern.compile("@gt", Pattern.LITERAL)); return Collections.unmodifiableMap(substitutionPatternMap); } private StringUtil() { } public static String internString(String value) { return value != null ? value.intern() : null; } /** * Replaces all occurrences of oldString in mainString with newString * @param mainString The original string * @param oldString The string to replace * @param newString The string to insert in place of the old * @return mainString with all occurrences of oldString replaced by newString */ public static String replaceString(String mainString, String oldString, String newString) { if (mainString == null) { return null; } if (UtilValidate.isEmpty(oldString)) { return mainString; } if (newString == null) { newString = ""; } int i = mainString.lastIndexOf(oldString); if (i < 0) return mainString; StringBuilder mainSb = new StringBuilder(mainString); while (i >= 0) { mainSb.replace(i, i + oldString.length(), newString); i = mainString.lastIndexOf(oldString, i - 1); } return mainSb.toString(); } /** * Creates a single string from a List of strings seperated by a delimiter. * @param list a list of strings to join * @param delim the delimiter character(s) to use. (null value will join with no delimiter) * @return a String of all values in the list seperated by the delimiter */ public static String join(List<?> list, String delim) { return join((Collection<?>) list, delim); } /** * Creates a single string from a Collection of strings seperated by a delimiter. * @param col a collection of strings to join * @param delim the delimiter character(s) to use. (null value will join with no delimiter) * @return a String of all values in the collection seperated by the delimiter */ public static String join(Collection<?> col, String delim) { if (UtilValidate.isEmpty(col)) return null; StringBuilder buf = new StringBuilder(); Iterator<?> i = col.iterator(); while (i.hasNext()) { buf.append(i.next()); if (i.hasNext()) buf.append(delim); } return buf.toString(); } /** * Splits a String on a delimiter into a List of Strings. * @param str the String to split * @param delim the delimiter character(s) to join on (null will split on whitespace) * @return a list of Strings */ public static List<String> split(String str, String delim) { List<String> splitList = null; StringTokenizer st; if (str == null) return null; st = (delim != null ? new StringTokenizer(str, delim) : new StringTokenizer(str)); if (st.hasMoreTokens()) { splitList = new LinkedList<>(); while (st.hasMoreTokens()) splitList.add(st.nextToken()); } return splitList; } /** * Splits a String on a delimiter into a List of Strings. * @param str the String to split * @param delim the delimiter character(s) to join on (null will split on whitespace) * @param limit see String.split() method * @return a list of Strings */ public static List<String> split(String str, String delim, int limit) { List<String> splitList = null; String[] st = null; if (str == null) return splitList; if (delim != null) st = Pattern.compile(delim).split(str, limit); else st = str.split("\\s"); if (st != null && st.length > 0) { splitList = new LinkedList<String>(); for (int i = 0; i < st.length; i++) splitList.add(st[i]); } return splitList; } /** * Encloses each of a List of Strings in quotes. * @param list List of String(s) to quote. */ public static List<String> quoteStrList(List<String> list) { List<String> tmpList = list; list = new LinkedList<String>(); for (String str : tmpList) { str = "'" + str + "'"; list.add(str); } return list; } /** * Creates a Map from an encoded name/value pair string * @param str The string to decode and format * @param delim the delimiter character(s) to join on (null will split on whitespace) * @param trim Trim whitespace off fields * @return a Map of name/value pairs */ public static Map<String, String> strToMap(String str, String delim, boolean trim) { return strToMap(str, delim, trim, null); } /** * Creates a Map from a name/value pair string * @param str The string to decode and format * @param delim the delimiter character(s) to join on (null will split on whitespace) * @param trim Trim whitespace off fields * @param pairsSeparator in case you use not encoded name/value pairs strings * and want to replace "=" to avoid clashes with parameters values in a not encoded URL, default to "=" * @return a Map of name/value pairs */ public static Map<String, String> strToMap(String str, String delim, boolean trim, String pairsSeparator) { if (str == null) return null; Map<String, String> decodedMap = new HashMap<String, String>(); List<String> elements = split(str, delim); pairsSeparator = pairsSeparator == null ? "=" : pairsSeparator; for (String s : elements) { List<String> e = split(s, pairsSeparator); if (e.size() != 2) { continue; } String name = e.get(0); String value = e.get(1); if (trim) { if (name != null) { name = name.trim(); } if (value != null) { value = value.trim(); } } try { decodedMap.put(URLDecoder.decode(name, "UTF-8"), URLDecoder.decode(value, "UTF-8")); } catch (UnsupportedEncodingException e1) { Debug.logError(e1, module); } } return decodedMap; } /** * Creates a Map from an encoded name/value pair string * @param str The string to decode and format * @param trim Trim whitespace off fields * @return a Map of name/value pairs */ public static Map<String, String> strToMap(String str, boolean trim) { return strToMap(str, "|", trim); } /** * Creates a Map from an encoded name/value pair string * @param str The string to decode and format * @param delim the delimiter character(s) to join on (null will split on whitespace) * @return a Map of name/value pairs */ public static Map<String, String> strToMap(String str, String delim) { return strToMap(str, delim, false); } /** * Creates a Map from an encoded name/value pair string * @param str The string to decode and format * @return a Map of name/value pairs */ public static Map<String, String> strToMap(String str) { return strToMap(str, "|", false); } /** * Creates an encoded String from a Map of name/value pairs (MUST BE STRINGS!) * @param map The Map of name/value pairs * @return String The encoded String */ public static String mapToStr(Map<? extends Object, ? extends Object> map) { if (map == null) return null; StringBuilder buf = new StringBuilder(); boolean first = true; for (Map.Entry<? extends Object, ? extends Object> entry : map.entrySet()) { Object key = entry.getKey(); Object value = entry.getValue(); if (!(key instanceof String) || !(value instanceof String)) continue; String encodedName = null; try { encodedName = URLEncoder.encode((String) key, "UTF-8"); } catch (UnsupportedEncodingException e) { Debug.logError(e, module); } String encodedValue = null; try { encodedValue = URLEncoder.encode((String) value, "UTF-8"); } catch (UnsupportedEncodingException e) { Debug.logError(e, module); } if (first) first = false; else buf.append("|"); buf.append(encodedName); buf.append("="); buf.append(encodedValue); } return buf.toString(); } /** * Reads a String version of a Map (should contain only strings) and creates a new Map. * Partial Map elements are skipped: <code>{foo=fooValue, bar=}</code> will contain only * the foo element. * * @param s String value of a Map ({n1=v1, n2=v2}) * @return new Map */ public static Map<String, String> toMap(String s) { Map<String, String> newMap = new HashMap<String, String>(); if (s.startsWith("{") && s.endsWith("}")) { s = s.substring(1, s.length() - 1); String[] entries = s.split("\\,\\s"); for (String entry : entries) { String[] nv = entry.split("\\="); if (nv.length == 2) { newMap.put(nv[0], nv[1]); } } } else { throw new IllegalArgumentException("String is not from Map.toString()"); } return newMap; } /** * Reads a String version of a List (should contain only strings) and creates a new List * * @param s String value of a Map ({n1=v1, n2=v2}) * @return new List */ public static List<String> toList(String s) { List<String> newList = new LinkedList<String>(); if (s.startsWith("[") && s.endsWith("]")) { s = s.substring(1, s.length() - 1); String[] entries = s.split("\\,\\s"); for (String entry : entries) { newList.add(entry); } } else { throw new IllegalArgumentException("String is not from List.toString()"); } return newList; } /** * Reads a String version of a Set (should contain only strings) and creates a new Set * * @param s String value of a Map ({n1=v1, n2=v2}) * @return new List */ public static Set<String> toSet(String s) { Set<String> newSet = new LinkedHashSet<String>(); if (s.startsWith("[") && s.endsWith("]")) { s = s.substring(1, s.length() - 1); String[] entries = s.split("\\,\\s"); for (String entry : entries) { newSet.add(entry); } } else { throw new IllegalArgumentException("String is not from Set.toString()"); } return newSet; } /** * Create a Map from a List of keys and a List of values * @param keys List of keys * @param values List of values * @return Map of combined lists * @throws IllegalArgumentException When either List is null or the sizes do not equal */ public static <K, V> Map<K, V> createMap(List<K> keys, List<V> values) { if (keys == null || values == null || keys.size() != values.size()) { throw new IllegalArgumentException("Keys and Values cannot be null and must be the same size"); } Map<K, V> newMap = new HashMap<K, V>(); for (int i = 0; i < keys.size(); i++) { newMap.put(keys.get(i), values.get(i)); } return newMap; } /** Make sure the string starts with a forward slash but does not end with one; converts back-slashes to forward-slashes; if in String is null or empty, returns zero length string. */ public static String cleanUpPathPrefix(String prefix) { if (UtilValidate.isEmpty(prefix)) return ""; StringBuilder cppBuff = new StringBuilder(prefix.replace('\\', '/')); if (cppBuff.charAt(0) != '/') { cppBuff.insert(0, '/'); } if (cppBuff.charAt(cppBuff.length() - 1) == '/') { cppBuff.deleteCharAt(cppBuff.length() - 1); } return cppBuff.toString(); } /** Removes all spaces from a string */ public static String removeSpaces(String str) { return removeRegex(str, "[\\ ]"); } public static String toHexString(byte[] bytes) { return new String(Hex.encodeHex(bytes)); } public static String cleanHexString(String str) { StringBuilder buf = new StringBuilder(); for (int i = 0; i < str.length(); i++) { if (str.charAt(i) != 32 && str.charAt(i) != ':') { buf.append(str.charAt(i)); } } return buf.toString(); } public static byte[] fromHexString(String str) { str = cleanHexString(str); try { return Hex.decodeHex(str.toCharArray()); } catch (DecoderException e) { throw new GeneralRuntimeException(e); } } private static char[] hexChar = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; public static int convertChar(char c) { if ('0' <= c && c <= '9') { return c - '0'; } else if ('a' <= c && c <= 'f') { return c - 'a' + 0xa; } else if ('A' <= c && c <= 'F') { return c - 'A' + 0xa; } else { throw new IllegalArgumentException("Invalid hex character: [" + c + "]"); } } public static char[] encodeInt(int i, int j, char digestChars[]) { if (i < 16) { digestChars[j] = '0'; } j++; do { digestChars[j--] = hexChar[i & 0xf]; i >>>= 4; } while (i != 0); return digestChars; } /** Removes all non-numbers from str */ public static String removeNonNumeric(String str) { return removeRegex(str, "[\\D]"); } /** Removes all numbers from str */ public static String removeNumeric(String str) { return removeRegex(str, "[\\d]"); } /** * @param str * @param regex * Removes all matches of regex from a str */ public static String removeRegex(String str, String regex) { return str.replaceAll(regex, ""); } /** * Add the number to the string, keeping (padding to min of original length) * * @return the new value */ public static String addToNumberString(String numberString, long addAmount) { if (numberString == null) return null; int origLength = numberString.length(); long number = Long.parseLong(numberString); return padNumberString(Long.toString(number + addAmount), origLength); } public static String padNumberString(String numberString, int targetMinLength) { StringBuilder outStrBfr = new StringBuilder(numberString); while (targetMinLength > outStrBfr.length()) { outStrBfr.insert(0, '0'); } return outStrBfr.toString(); } /** Converts operator substitutions (@and, @or, etc) back to their original form. * <p>OFBiz script syntax provides special forms of common operators to make * it easier to embed logical expressions in XML</p> * <table border="1" cellpadding="2"> * <caption>OFBiz XML operators</caption> * <tr><th>OFBiz operator</th><th>Substitution</th></tr> * <tr><td><strong>@and</strong></td><td>&&</td></tr> * <tr><td><strong>@or</strong></td><td>||</td></tr> * <tr><td><strong>@gt</strong></td><td>></td></tr> * <tr><td><strong>@gteq</strong></td><td>>=</td></tr> * <tr><td><strong>@lt</strong></td><td><</td></tr> * <tr><td><strong>@lteq</strong></td><td><=</td></tr> * </table> * @param expression The <code>String</code> to convert * @return The converted <code>String</code> */ public static String convertOperatorSubstitutions(String expression) { String result = expression; if (result != null && (result.contains("@"))) { for (Map.Entry<String, Pattern> entry : substitutionPatternMap.entrySet()) { Pattern pattern = entry.getValue(); result = pattern.matcher(result).replaceAll(entry.getKey()); } if (Debug.verboseOn()) { Debug.logVerbose("Converted " + expression + " to " + result, module); } } return result; } /** * Remove/collapse multiple newline characters * * @param str string to collapse newlines in * @return the converted string */ public static String collapseNewlines(String str) { return collapseCharacter(str, '\n'); } /** * Remove/collapse multiple spaces * * @param str string to collapse spaces in * @return the converted string */ public static String collapseSpaces(String str) { return collapseCharacter(str, ' '); } /** * Remove/collapse multiple characters * * @param str string to collapse characters in * @param c character to collapse * @return the converted string */ public static String collapseCharacter(String str, char c) { StringBuilder sb = new StringBuilder(); char last = str.charAt(0); for (int i = 0; i < str.length(); i++) { char current = str.charAt(i); if (i == 0 || current != c || last != c) { sb.append(current); last = current; } } return sb.toString(); } public static StringWrapper wrapString(String theString) { return makeStringWrapper(theString); } public static StringWrapper makeStringWrapper(String theString) { if (theString == null) return null; if (theString.length() == 0) return StringWrapper.EMPTY_STRING_WRAPPER; return new StringWrapper(theString); } public static StringBuilder appendTo(StringBuilder sb, Iterable<? extends Appender<StringBuilder>> iterable, String prefix, String suffix, String sep) { return appendTo(sb, iterable, prefix, suffix, null, sep, null); } public static StringBuilder appendTo(StringBuilder sb, Iterable<? extends Appender<StringBuilder>> iterable, String prefix, String suffix, String sepPrefix, String sep, String sepSuffix) { Iterator<? extends Appender<StringBuilder>> it = iterable.iterator(); while (it.hasNext()) { if (prefix != null) sb.append(prefix); it.next().appendTo(sb); if (suffix != null) sb.append(suffix); if (it.hasNext() && sep != null) { if (sepPrefix != null) sb.append(sepPrefix); sb.append(sep); if (sepSuffix != null) sb.append(sepSuffix); } } return sb; } public static StringBuilder append(StringBuilder sb, Iterable<? extends Object> iterable, String prefix, String suffix, String sep) { return append(sb, iterable, prefix, suffix, null, sep, null); } public static StringBuilder append(StringBuilder sb, Iterable<? extends Object> iterable, String prefix, String suffix, String sepPrefix, String sep, String sepSuffix) { Iterator<? extends Object> it = iterable.iterator(); while (it.hasNext()) { if (prefix != null) sb.append(prefix); sb.append(it.next()); if (suffix != null) sb.append(suffix); if (it.hasNext() && sep != null) { if (sepPrefix != null) sb.append(sepPrefix); sb.append(sep); if (sepSuffix != null) sb.append(sepSuffix); } } return sb; } /** * A super-lightweight object to wrap a String object. Mainly used with FTL templates * to avoid the general HTML auto-encoding that is now done through the Screen Widget. */ public static class StringWrapper { public static final StringWrapper EMPTY_STRING_WRAPPER = new StringWrapper(""); protected String theString; protected StringWrapper() { } public StringWrapper(String theString) { this.theString = theString; } /** * Fairly simple method used for the plus (+) base concatenation in Groovy. * * @param value * @return the wrapped string, plus the value */ public String plus(Object value) { return this.theString + value; } /** * @return The String this object wraps. */ @Override public String toString() { return this.theString; } } }