| /* |
| * 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.commons.lang3; |
| |
| import java.io.UnsupportedEncodingException; |
| import java.nio.charset.Charset; |
| import java.text.Normalizer; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.function.Supplier; |
| import java.util.regex.Pattern; |
| import java.util.stream.Stream; |
| |
| import org.apache.commons.lang3.function.Suppliers; |
| import org.apache.commons.lang3.function.ToBooleanBiFunction; |
| import org.apache.commons.lang3.stream.LangCollectors; |
| |
| /** |
| * <p>Operations on {@link java.lang.String} that are |
| * {@code null} safe.</p> |
| * |
| * <ul> |
| * <li><b>IsEmpty/IsBlank</b> |
| * - checks if a String contains text</li> |
| * <li><b>Trim/Strip</b> |
| * - removes leading and trailing whitespace</li> |
| * <li><b>Equals/Compare</b> |
| * - compares two strings in a null-safe manner</li> |
| * <li><b>startsWith</b> |
| * - check if a String starts with a prefix in a null-safe manner</li> |
| * <li><b>endsWith</b> |
| * - check if a String ends with a suffix in a null-safe manner</li> |
| * <li><b>IndexOf/LastIndexOf/Contains</b> |
| * - null-safe index-of checks |
| * <li><b>IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut</b> |
| * - index-of any of a set of Strings</li> |
| * <li><b>ContainsOnly/ContainsNone/ContainsAny</b> |
| * - checks if String contains only/none/any of these characters</li> |
| * <li><b>Substring/Left/Right/Mid</b> |
| * - null-safe substring extractions</li> |
| * <li><b>SubstringBefore/SubstringAfter/SubstringBetween</b> |
| * - substring extraction relative to other strings</li> |
| * <li><b>Split/Join</b> |
| * - splits a String into an array of substrings and vice versa</li> |
| * <li><b>Remove/Delete</b> |
| * - removes part of a String</li> |
| * <li><b>Replace/Overlay</b> |
| * - Searches a String and replaces one String with another</li> |
| * <li><b>Chomp/Chop</b> |
| * - removes the last part of a String</li> |
| * <li><b>AppendIfMissing</b> |
| * - appends a suffix to the end of the String if not present</li> |
| * <li><b>PrependIfMissing</b> |
| * - prepends a prefix to the start of the String if not present</li> |
| * <li><b>LeftPad/RightPad/Center/Repeat</b> |
| * - pads a String</li> |
| * <li><b>UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize</b> |
| * - changes the case of a String</li> |
| * <li><b>CountMatches</b> |
| * - counts the number of occurrences of one String in another</li> |
| * <li><b>IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable</b> |
| * - checks the characters in a String</li> |
| * <li><b>DefaultString</b> |
| * - protects against a null input String</li> |
| * <li><b>Rotate</b> |
| * - rotate (circular shift) a String</li> |
| * <li><b>Reverse/ReverseDelimited</b> |
| * - reverses a String</li> |
| * <li><b>Abbreviate</b> |
| * - abbreviates a string using ellipses or another given String</li> |
| * <li><b>Difference</b> |
| * - compares Strings and reports on their differences</li> |
| * <li><b>LevenshteinDistance</b> |
| * - the number of changes needed to change one String into another</li> |
| * </ul> |
| * |
| * <p>The {@link StringUtils} class defines certain words related to |
| * String handling.</p> |
| * |
| * <ul> |
| * <li>null - {@code null}</li> |
| * <li>empty - a zero-length string ({@code ""})</li> |
| * <li>space - the space character ({@code ' '}, char 32)</li> |
| * <li>whitespace - the characters defined by {@link Character#isWhitespace(char)}</li> |
| * <li>trim - the characters <= 32 as in {@link String#trim()}</li> |
| * </ul> |
| * |
| * <p>{@link StringUtils} handles {@code null} input Strings quietly. |
| * That is to say that a {@code null} input will return {@code null}. |
| * Where a {@code boolean} or {@code int} is being returned |
| * details vary by method.</p> |
| * |
| * <p>A side effect of the {@code null} handling is that a |
| * {@link NullPointerException} should be considered a bug in |
| * {@link StringUtils}.</p> |
| * |
| * <p>Methods in this class include sample code in their Javadoc comments to explain their operation. |
| * The symbol {@code *} is used to indicate any input including {@code null}.</p> |
| * |
| * <p>#ThreadSafe#</p> |
| * @see java.lang.String |
| * @since 1.0 |
| */ |
| //@Immutable |
| public class StringUtils { |
| |
| private static final int STRING_BUILDER_SIZE = 256; |
| |
| // Performance testing notes (JDK 1.4, Jul03, scolebourne) |
| // Whitespace: |
| // Character.isWhitespace() is faster than WHITESPACE.indexOf() |
| // where WHITESPACE is a string of all whitespace characters |
| // |
| // Character access: |
| // String.charAt(n) versus toCharArray(), then array[n] |
| // String.charAt(n) is about 15% worse for a 10K string |
| // They are about equal for a length 50 string |
| // String.charAt(n) is about 4 times better for a length 3 string |
| // String.charAt(n) is best bet overall |
| // |
| // Append: |
| // String.concat about twice as fast as StringBuffer.append |
| // (not sure who tested this) |
| |
| /** |
| * A String for a space character. |
| * |
| * @since 3.2 |
| */ |
| public static final String SPACE = " "; |
| |
| /** |
| * The empty String {@code ""}. |
| * @since 2.0 |
| */ |
| public static final String EMPTY = ""; |
| |
| /** |
| * A String for linefeed LF ("\n"). |
| * |
| * @see <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.10.6">JLF: Escape Sequences |
| * for Character and String Literals</a> |
| * @since 3.2 |
| */ |
| public static final String LF = "\n"; |
| |
| /** |
| * A String for carriage return CR ("\r"). |
| * |
| * @see <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.10.6">JLF: Escape Sequences |
| * for Character and String Literals</a> |
| * @since 3.2 |
| */ |
| public static final String CR = "\r"; |
| |
| /** |
| * Represents a failed index search. |
| * @since 2.1 |
| */ |
| public static final int INDEX_NOT_FOUND = -1; |
| |
| /** |
| * <p>The maximum size to which the padding constant(s) can expand.</p> |
| */ |
| private static final int PAD_LIMIT = 8192; |
| |
| /** |
| * Pattern used in {@link #stripAccents(String)}. |
| */ |
| private static final Pattern STRIP_ACCENTS_PATTERN = Pattern.compile("\\p{InCombiningDiacriticalMarks}+"); //$NON-NLS-1$ |
| |
| /** |
| * <p>Abbreviates a String using ellipses. This will turn |
| * "Now is the time for all good men" into "Now is the time for..."</p> |
| * |
| * <p>Specifically:</p> |
| * <ul> |
| * <li>If the number of characters in {@code str} is less than or equal to |
| * {@code maxWidth}, return {@code str}.</li> |
| * <li>Else abbreviate it to {@code (substring(str, 0, max-3) + "...")}.</li> |
| * <li>If {@code maxWidth} is less than {@code 4}, throw an |
| * {@link IllegalArgumentException}.</li> |
| * <li>In no case will it return a String of length greater than |
| * {@code maxWidth}.</li> |
| * </ul> |
| * |
| * <pre> |
| * StringUtils.abbreviate(null, *) = null |
| * StringUtils.abbreviate("", 4) = "" |
| * StringUtils.abbreviate("abcdefg", 6) = "abc..." |
| * StringUtils.abbreviate("abcdefg", 7) = "abcdefg" |
| * StringUtils.abbreviate("abcdefg", 8) = "abcdefg" |
| * StringUtils.abbreviate("abcdefg", 4) = "a..." |
| * StringUtils.abbreviate("abcdefg", 3) = IllegalArgumentException |
| * </pre> |
| * |
| * @param str the String to check, may be null |
| * @param maxWidth maximum length of result String, must be at least 4 |
| * @return abbreviated String, {@code null} if null String input |
| * @throws IllegalArgumentException if the width is too small |
| * @since 2.0 |
| */ |
| public static String abbreviate(final String str, final int maxWidth) { |
| return abbreviate(str, "...", 0, maxWidth); |
| } |
| |
| /** |
| * <p>Abbreviates a String using ellipses. This will turn |
| * "Now is the time for all good men" into "...is the time for..."</p> |
| * |
| * <p>Works like {@code abbreviate(String, int)}, but allows you to specify |
| * a "left edge" offset. Note that this left edge is not necessarily going to |
| * be the leftmost character in the result, or the first character following the |
| * ellipses, but it will appear somewhere in the result. |
| * |
| * <p>In no case will it return a String of length greater than |
| * {@code maxWidth}.</p> |
| * |
| * <pre> |
| * StringUtils.abbreviate(null, *, *) = null |
| * StringUtils.abbreviate("", 0, 4) = "" |
| * StringUtils.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..." |
| * StringUtils.abbreviate("abcdefghijklmno", 0, 10) = "abcdefg..." |
| * StringUtils.abbreviate("abcdefghijklmno", 1, 10) = "abcdefg..." |
| * StringUtils.abbreviate("abcdefghijklmno", 4, 10) = "abcdefg..." |
| * StringUtils.abbreviate("abcdefghijklmno", 5, 10) = "...fghi..." |
| * StringUtils.abbreviate("abcdefghijklmno", 6, 10) = "...ghij..." |
| * StringUtils.abbreviate("abcdefghijklmno", 8, 10) = "...ijklmno" |
| * StringUtils.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno" |
| * StringUtils.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno" |
| * StringUtils.abbreviate("abcdefghij", 0, 3) = IllegalArgumentException |
| * StringUtils.abbreviate("abcdefghij", 5, 6) = IllegalArgumentException |
| * </pre> |
| * |
| * @param str the String to check, may be null |
| * @param offset left edge of source String |
| * @param maxWidth maximum length of result String, must be at least 4 |
| * @return abbreviated String, {@code null} if null String input |
| * @throws IllegalArgumentException if the width is too small |
| * @since 2.0 |
| */ |
| public static String abbreviate(final String str, final int offset, final int maxWidth) { |
| return abbreviate(str, "...", offset, maxWidth); |
| } |
| |
| /** |
| * <p>Abbreviates a String using another given String as replacement marker. This will turn |
| * "Now is the time for all good men" into "Now is the time for..." if "..." was defined |
| * as the replacement marker.</p> |
| * |
| * <p>Specifically:</p> |
| * <ul> |
| * <li>If the number of characters in {@code str} is less than or equal to |
| * {@code maxWidth}, return {@code str}.</li> |
| * <li>Else abbreviate it to {@code (substring(str, 0, max-abbrevMarker.length) + abbrevMarker)}.</li> |
| * <li>If {@code maxWidth} is less than {@code abbrevMarker.length + 1}, throw an |
| * {@link IllegalArgumentException}.</li> |
| * <li>In no case will it return a String of length greater than |
| * {@code maxWidth}.</li> |
| * </ul> |
| * |
| * <pre> |
| * StringUtils.abbreviate(null, "...", *) = null |
| * StringUtils.abbreviate("abcdefg", null, *) = "abcdefg" |
| * StringUtils.abbreviate("", "...", 4) = "" |
| * StringUtils.abbreviate("abcdefg", ".", 5) = "abcd." |
| * StringUtils.abbreviate("abcdefg", ".", 7) = "abcdefg" |
| * StringUtils.abbreviate("abcdefg", ".", 8) = "abcdefg" |
| * StringUtils.abbreviate("abcdefg", "..", 4) = "ab.." |
| * StringUtils.abbreviate("abcdefg", "..", 3) = "a.." |
| * StringUtils.abbreviate("abcdefg", "..", 2) = IllegalArgumentException |
| * StringUtils.abbreviate("abcdefg", "...", 3) = IllegalArgumentException |
| * </pre> |
| * |
| * @param str the String to check, may be null |
| * @param abbrevMarker the String used as replacement marker |
| * @param maxWidth maximum length of result String, must be at least {@code abbrevMarker.length + 1} |
| * @return abbreviated String, {@code null} if null String input |
| * @throws IllegalArgumentException if the width is too small |
| * @since 3.6 |
| */ |
| public static String abbreviate(final String str, final String abbrevMarker, final int maxWidth) { |
| return abbreviate(str, abbrevMarker, 0, maxWidth); |
| } |
| /** |
| * <p>Abbreviates a String using a given replacement marker. This will turn |
| * "Now is the time for all good men" into "...is the time for..." if "..." was defined |
| * as the replacement marker.</p> |
| * |
| * <p>Works like {@code abbreviate(String, String, int)}, but allows you to specify |
| * a "left edge" offset. Note that this left edge is not necessarily going to |
| * be the leftmost character in the result, or the first character following the |
| * replacement marker, but it will appear somewhere in the result. |
| * |
| * <p>In no case will it return a String of length greater than {@code maxWidth}.</p> |
| * |
| * <pre> |
| * StringUtils.abbreviate(null, null, *, *) = null |
| * StringUtils.abbreviate("abcdefghijklmno", null, *, *) = "abcdefghijklmno" |
| * StringUtils.abbreviate("", "...", 0, 4) = "" |
| * StringUtils.abbreviate("abcdefghijklmno", "---", -1, 10) = "abcdefg---" |
| * StringUtils.abbreviate("abcdefghijklmno", ",", 0, 10) = "abcdefghi," |
| * StringUtils.abbreviate("abcdefghijklmno", ",", 1, 10) = "abcdefghi," |
| * StringUtils.abbreviate("abcdefghijklmno", ",", 2, 10) = "abcdefghi," |
| * StringUtils.abbreviate("abcdefghijklmno", "::", 4, 10) = "::efghij::" |
| * StringUtils.abbreviate("abcdefghijklmno", "...", 6, 10) = "...ghij..." |
| * StringUtils.abbreviate("abcdefghijklmno", "*", 9, 10) = "*ghijklmno" |
| * StringUtils.abbreviate("abcdefghijklmno", "'", 10, 10) = "'ghijklmno" |
| * StringUtils.abbreviate("abcdefghijklmno", "!", 12, 10) = "!ghijklmno" |
| * StringUtils.abbreviate("abcdefghij", "abra", 0, 4) = IllegalArgumentException |
| * StringUtils.abbreviate("abcdefghij", "...", 5, 6) = IllegalArgumentException |
| * </pre> |
| * |
| * @param str the String to check, may be null |
| * @param abbrevMarker the String used as replacement marker |
| * @param offset left edge of source String |
| * @param maxWidth maximum length of result String, must be at least 4 |
| * @return abbreviated String, {@code null} if null String input |
| * @throws IllegalArgumentException if the width is too small |
| * @since 3.6 |
| */ |
| public static String abbreviate(final String str, final String abbrevMarker, int offset, final int maxWidth) { |
| if (isNotEmpty(str) && EMPTY.equals(abbrevMarker) && maxWidth > 0) { |
| return substring(str, 0, maxWidth); |
| } |
| if (isAnyEmpty(str, abbrevMarker)) { |
| return str; |
| } |
| final int abbrevMarkerLength = abbrevMarker.length(); |
| final int minAbbrevWidth = abbrevMarkerLength + 1; |
| final int minAbbrevWidthOffset = abbrevMarkerLength + abbrevMarkerLength + 1; |
| |
| if (maxWidth < minAbbrevWidth) { |
| throw new IllegalArgumentException(String.format("Minimum abbreviation width is %d", minAbbrevWidth)); |
| } |
| final int strLen = str.length(); |
| if (strLen <= maxWidth) { |
| return str; |
| } |
| if (offset > strLen) { |
| offset = strLen; |
| } |
| if (strLen - offset < maxWidth - abbrevMarkerLength) { |
| offset = strLen - (maxWidth - abbrevMarkerLength); |
| } |
| if (offset <= abbrevMarkerLength+1) { |
| return str.substring(0, maxWidth - abbrevMarkerLength) + abbrevMarker; |
| } |
| if (maxWidth < minAbbrevWidthOffset) { |
| throw new IllegalArgumentException(String.format("Minimum abbreviation width with offset is %d", minAbbrevWidthOffset)); |
| } |
| if (offset + maxWidth - abbrevMarkerLength < strLen) { |
| return abbrevMarker + abbreviate(str.substring(offset), abbrevMarker, maxWidth - abbrevMarkerLength); |
| } |
| return abbrevMarker + str.substring(strLen - (maxWidth - abbrevMarkerLength)); |
| } |
| |
| /** |
| * <p>Abbreviates a String to the length passed, replacing the middle characters with the supplied |
| * replacement String.</p> |
| * |
| * <p>This abbreviation only occurs if the following criteria is met:</p> |
| * <ul> |
| * <li>Neither the String for abbreviation nor the replacement String are null or empty </li> |
| * <li>The length to truncate to is less than the length of the supplied String</li> |
| * <li>The length to truncate to is greater than 0</li> |
| * <li>The abbreviated String will have enough room for the length supplied replacement String |
| * and the first and last characters of the supplied String for abbreviation</li> |
| * </ul> |
| * <p>Otherwise, the returned String will be the same as the supplied String for abbreviation. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.abbreviateMiddle(null, null, 0) = null |
| * StringUtils.abbreviateMiddle("abc", null, 0) = "abc" |
| * StringUtils.abbreviateMiddle("abc", ".", 0) = "abc" |
| * StringUtils.abbreviateMiddle("abc", ".", 3) = "abc" |
| * StringUtils.abbreviateMiddle("abcdef", ".", 4) = "ab.f" |
| * </pre> |
| * |
| * @param str the String to abbreviate, may be null |
| * @param middle the String to replace the middle characters with, may be null |
| * @param length the length to abbreviate {@code str} to. |
| * @return the abbreviated String if the above criteria is met, or the original String supplied for abbreviation. |
| * @since 2.5 |
| */ |
| public static String abbreviateMiddle(final String str, final String middle, final int length) { |
| if (isAnyEmpty(str, middle) || length >= str.length() || length < middle.length()+2) { |
| return str; |
| } |
| |
| final int targetSting = length-middle.length(); |
| final int startOffset = targetSting/2+targetSting%2; |
| final int endOffset = str.length()-targetSting/2; |
| |
| return str.substring(0, startOffset) + |
| middle + |
| str.substring(endOffset); |
| } |
| |
| /** |
| * Appends the suffix to the end of the string if the string does not |
| * already end with the suffix. |
| * |
| * @param str The string. |
| * @param suffix The suffix to append to the end of the string. |
| * @param ignoreCase Indicates whether the compare should ignore case. |
| * @param suffixes Additional suffixes that are valid terminators (optional). |
| * |
| * @return A new String if suffix was appended, the same string otherwise. |
| */ |
| private static String appendIfMissing(final String str, final CharSequence suffix, final boolean ignoreCase, final CharSequence... suffixes) { |
| if (str == null || isEmpty(suffix) || endsWith(str, suffix, ignoreCase)) { |
| return str; |
| } |
| if (ArrayUtils.isNotEmpty(suffixes)) { |
| for (final CharSequence s : suffixes) { |
| if (endsWith(str, s, ignoreCase)) { |
| return str; |
| } |
| } |
| } |
| return str + suffix.toString(); |
| } |
| |
| /** |
| * Appends the suffix to the end of the string if the string does not |
| * already end with any of the suffixes. |
| * |
| * <pre> |
| * StringUtils.appendIfMissing(null, null) = null |
| * StringUtils.appendIfMissing("abc", null) = "abc" |
| * StringUtils.appendIfMissing("", "xyz") = "xyz" |
| * StringUtils.appendIfMissing("abc", "xyz") = "abcxyz" |
| * StringUtils.appendIfMissing("abcxyz", "xyz") = "abcxyz" |
| * StringUtils.appendIfMissing("abcXYZ", "xyz") = "abcXYZxyz" |
| * </pre> |
| * <p>With additional suffixes,</p> |
| * <pre> |
| * StringUtils.appendIfMissing(null, null, null) = null |
| * StringUtils.appendIfMissing("abc", null, null) = "abc" |
| * StringUtils.appendIfMissing("", "xyz", null) = "xyz" |
| * StringUtils.appendIfMissing("abc", "xyz", new CharSequence[]{null}) = "abcxyz" |
| * StringUtils.appendIfMissing("abc", "xyz", "") = "abc" |
| * StringUtils.appendIfMissing("abc", "xyz", "mno") = "abcxyz" |
| * StringUtils.appendIfMissing("abcxyz", "xyz", "mno") = "abcxyz" |
| * StringUtils.appendIfMissing("abcmno", "xyz", "mno") = "abcmno" |
| * StringUtils.appendIfMissing("abcXYZ", "xyz", "mno") = "abcXYZxyz" |
| * StringUtils.appendIfMissing("abcMNO", "xyz", "mno") = "abcMNOxyz" |
| * </pre> |
| * |
| * @param str The string. |
| * @param suffix The suffix to append to the end of the string. |
| * @param suffixes Additional suffixes that are valid terminators. |
| * |
| * @return A new String if suffix was appended, the same string otherwise. |
| * |
| * @since 3.2 |
| */ |
| public static String appendIfMissing(final String str, final CharSequence suffix, final CharSequence... suffixes) { |
| return appendIfMissing(str, suffix, false, suffixes); |
| } |
| |
| /** |
| * Appends the suffix to the end of the string if the string does not |
| * already end, case-insensitive, with any of the suffixes. |
| * |
| * <pre> |
| * StringUtils.appendIfMissingIgnoreCase(null, null) = null |
| * StringUtils.appendIfMissingIgnoreCase("abc", null) = "abc" |
| * StringUtils.appendIfMissingIgnoreCase("", "xyz") = "xyz" |
| * StringUtils.appendIfMissingIgnoreCase("abc", "xyz") = "abcxyz" |
| * StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz") = "abcxyz" |
| * StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz") = "abcXYZ" |
| * </pre> |
| * <p>With additional suffixes,</p> |
| * <pre> |
| * StringUtils.appendIfMissingIgnoreCase(null, null, null) = null |
| * StringUtils.appendIfMissingIgnoreCase("abc", null, null) = "abc" |
| * StringUtils.appendIfMissingIgnoreCase("", "xyz", null) = "xyz" |
| * StringUtils.appendIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}) = "abcxyz" |
| * StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "") = "abc" |
| * StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "mno") = "abcxyz" |
| * StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz", "mno") = "abcxyz" |
| * StringUtils.appendIfMissingIgnoreCase("abcmno", "xyz", "mno") = "abcmno" |
| * StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz", "mno") = "abcXYZ" |
| * StringUtils.appendIfMissingIgnoreCase("abcMNO", "xyz", "mno") = "abcMNO" |
| * </pre> |
| * |
| * @param str The string. |
| * @param suffix The suffix to append to the end of the string. |
| * @param suffixes Additional suffixes that are valid terminators. |
| * |
| * @return A new String if suffix was appended, the same string otherwise. |
| * |
| * @since 3.2 |
| */ |
| public static String appendIfMissingIgnoreCase(final String str, final CharSequence suffix, final CharSequence... suffixes) { |
| return appendIfMissing(str, suffix, true, suffixes); |
| } |
| |
| /** |
| * <p>Capitalizes a String changing the first character to title case as |
| * per {@link Character#toTitleCase(int)}. No other characters are changed.</p> |
| * |
| * <p>For a word based algorithm, see {@link org.apache.commons.text.WordUtils#capitalize(String)}. |
| * A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.capitalize(null) = null |
| * StringUtils.capitalize("") = "" |
| * StringUtils.capitalize("cat") = "Cat" |
| * StringUtils.capitalize("cAt") = "CAt" |
| * StringUtils.capitalize("'cat'") = "'cat'" |
| * </pre> |
| * |
| * @param str the String to capitalize, may be null |
| * @return the capitalized String, {@code null} if null String input |
| * @see org.apache.commons.text.WordUtils#capitalize(String) |
| * @see #uncapitalize(String) |
| * @since 2.0 |
| */ |
| public static String capitalize(final String str) { |
| final int strLen = length(str); |
| if (strLen == 0) { |
| return str; |
| } |
| |
| final int firstCodepoint = str.codePointAt(0); |
| final int newCodePoint = Character.toTitleCase(firstCodepoint); |
| if (firstCodepoint == newCodePoint) { |
| // already capitalized |
| return str; |
| } |
| |
| final int[] newCodePoints = new int[strLen]; // cannot be longer than the char array |
| int outOffset = 0; |
| newCodePoints[outOffset++] = newCodePoint; // copy the first code point |
| for (int inOffset = Character.charCount(firstCodepoint); inOffset < strLen; ) { |
| final int codePoint = str.codePointAt(inOffset); |
| newCodePoints[outOffset++] = codePoint; // copy the remaining ones |
| inOffset += Character.charCount(codePoint); |
| } |
| return new String(newCodePoints, 0, outOffset); |
| } |
| |
| /** |
| * <p>Centers a String in a larger String of size {@code size} |
| * using the space character (' ').</p> |
| * |
| * <p>If the size is less than the String length, the original String is returned. |
| * A {@code null} String returns {@code null}. |
| * A negative size is treated as zero.</p> |
| * |
| * <p>Equivalent to {@code center(str, size, " ")}.</p> |
| * |
| * <pre> |
| * StringUtils.center(null, *) = null |
| * StringUtils.center("", 4) = " " |
| * StringUtils.center("ab", -1) = "ab" |
| * StringUtils.center("ab", 4) = " ab " |
| * StringUtils.center("abcd", 2) = "abcd" |
| * StringUtils.center("a", 4) = " a " |
| * </pre> |
| * |
| * @param str the String to center, may be null |
| * @param size the int size of new String, negative treated as zero |
| * @return centered String, {@code null} if null String input |
| */ |
| public static String center(final String str, final int size) { |
| return center(str, size, ' '); |
| } |
| |
| /** |
| * <p>Centers a String in a larger String of size {@code size}. |
| * Uses a supplied character as the value to pad the String with.</p> |
| * |
| * <p>If the size is less than the String length, the String is returned. |
| * A {@code null} String returns {@code null}. |
| * A negative size is treated as zero.</p> |
| * |
| * <pre> |
| * StringUtils.center(null, *, *) = null |
| * StringUtils.center("", 4, ' ') = " " |
| * StringUtils.center("ab", -1, ' ') = "ab" |
| * StringUtils.center("ab", 4, ' ') = " ab " |
| * StringUtils.center("abcd", 2, ' ') = "abcd" |
| * StringUtils.center("a", 4, ' ') = " a " |
| * StringUtils.center("a", 4, 'y') = "yayy" |
| * </pre> |
| * |
| * @param str the String to center, may be null |
| * @param size the int size of new String, negative treated as zero |
| * @param padChar the character to pad the new String with |
| * @return centered String, {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String center(String str, final int size, final char padChar) { |
| if (str == null || size <= 0) { |
| return str; |
| } |
| final int strLen = str.length(); |
| final int pads = size - strLen; |
| if (pads <= 0) { |
| return str; |
| } |
| str = leftPad(str, strLen + pads / 2, padChar); |
| str = rightPad(str, size, padChar); |
| return str; |
| } |
| |
| /** |
| * <p>Centers a String in a larger String of size {@code size}. |
| * Uses a supplied String as the value to pad the String with.</p> |
| * |
| * <p>If the size is less than the String length, the String is returned. |
| * A {@code null} String returns {@code null}. |
| * A negative size is treated as zero.</p> |
| * |
| * <pre> |
| * StringUtils.center(null, *, *) = null |
| * StringUtils.center("", 4, " ") = " " |
| * StringUtils.center("ab", -1, " ") = "ab" |
| * StringUtils.center("ab", 4, " ") = " ab " |
| * StringUtils.center("abcd", 2, " ") = "abcd" |
| * StringUtils.center("a", 4, " ") = " a " |
| * StringUtils.center("a", 4, "yz") = "yayz" |
| * StringUtils.center("abc", 7, null) = " abc " |
| * StringUtils.center("abc", 7, "") = " abc " |
| * </pre> |
| * |
| * @param str the String to center, may be null |
| * @param size the int size of new String, negative treated as zero |
| * @param padStr the String to pad the new String with, must not be null or empty |
| * @return centered String, {@code null} if null String input |
| * @throws IllegalArgumentException if padStr is {@code null} or empty |
| */ |
| public static String center(String str, final int size, String padStr) { |
| if (str == null || size <= 0) { |
| return str; |
| } |
| if (isEmpty(padStr)) { |
| padStr = SPACE; |
| } |
| final int strLen = str.length(); |
| final int pads = size - strLen; |
| if (pads <= 0) { |
| return str; |
| } |
| str = leftPad(str, strLen + pads / 2, padStr); |
| str = rightPad(str, size, padStr); |
| return str; |
| } |
| |
| /** |
| * <p>Removes one newline from end of a String if it's there, |
| * otherwise leave it alone. A newline is "{@code \n}", |
| * "{@code \r}", or "{@code \r\n}".</p> |
| * |
| * <p>NOTE: This method changed in 2.0. |
| * It now more closely matches Perl chomp.</p> |
| * |
| * <pre> |
| * StringUtils.chomp(null) = null |
| * StringUtils.chomp("") = "" |
| * StringUtils.chomp("abc \r") = "abc " |
| * StringUtils.chomp("abc\n") = "abc" |
| * StringUtils.chomp("abc\r\n") = "abc" |
| * StringUtils.chomp("abc\r\n\r\n") = "abc\r\n" |
| * StringUtils.chomp("abc\n\r") = "abc\n" |
| * StringUtils.chomp("abc\n\rabc") = "abc\n\rabc" |
| * StringUtils.chomp("\r") = "" |
| * StringUtils.chomp("\n") = "" |
| * StringUtils.chomp("\r\n") = "" |
| * </pre> |
| * |
| * @param str the String to chomp a newline from, may be null |
| * @return String without newline, {@code null} if null String input |
| */ |
| public static String chomp(final String str) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| |
| if (str.length() == 1) { |
| final char ch = str.charAt(0); |
| if (ch == CharUtils.CR || ch == CharUtils.LF) { |
| return EMPTY; |
| } |
| return str; |
| } |
| |
| int lastIdx = str.length() - 1; |
| final char last = str.charAt(lastIdx); |
| |
| if (last == CharUtils.LF) { |
| if (str.charAt(lastIdx - 1) == CharUtils.CR) { |
| lastIdx--; |
| } |
| } else if (last != CharUtils.CR) { |
| lastIdx++; |
| } |
| return str.substring(0, lastIdx); |
| } |
| |
| /** |
| * <p>Removes {@code separator} from the end of |
| * {@code str} if it's there, otherwise leave it alone.</p> |
| * |
| * <p>NOTE: This method changed in version 2.0. |
| * It now more closely matches Perl chomp. |
| * For the previous behavior, use {@link #substringBeforeLast(String, String)}. |
| * This method uses {@link String#endsWith(String)}.</p> |
| * |
| * <pre> |
| * StringUtils.chomp(null, *) = null |
| * StringUtils.chomp("", *) = "" |
| * StringUtils.chomp("foobar", "bar") = "foo" |
| * StringUtils.chomp("foobar", "baz") = "foobar" |
| * StringUtils.chomp("foo", "foo") = "" |
| * StringUtils.chomp("foo ", "foo") = "foo " |
| * StringUtils.chomp(" foo", "foo") = " " |
| * StringUtils.chomp("foo", "foooo") = "foo" |
| * StringUtils.chomp("foo", "") = "foo" |
| * StringUtils.chomp("foo", null) = "foo" |
| * </pre> |
| * |
| * @param str the String to chomp from, may be null |
| * @param separator separator String, may be null |
| * @return String without trailing separator, {@code null} if null String input |
| * @deprecated This feature will be removed in Lang 4.0, use {@link StringUtils#removeEnd(String, String)} instead |
| */ |
| @Deprecated |
| public static String chomp(final String str, final String separator) { |
| return removeEnd(str, separator); |
| } |
| |
| /** |
| * <p>Remove the last character from a String.</p> |
| * |
| * <p>If the String ends in {@code \r\n}, then remove both |
| * of them.</p> |
| * |
| * <pre> |
| * StringUtils.chop(null) = null |
| * StringUtils.chop("") = "" |
| * StringUtils.chop("abc \r") = "abc " |
| * StringUtils.chop("abc\n") = "abc" |
| * StringUtils.chop("abc\r\n") = "abc" |
| * StringUtils.chop("abc") = "ab" |
| * StringUtils.chop("abc\nabc") = "abc\nab" |
| * StringUtils.chop("a") = "" |
| * StringUtils.chop("\r") = "" |
| * StringUtils.chop("\n") = "" |
| * StringUtils.chop("\r\n") = "" |
| * </pre> |
| * |
| * @param str the String to chop last character from, may be null |
| * @return String without last character, {@code null} if null String input |
| */ |
| public static String chop(final String str) { |
| if (str == null) { |
| return null; |
| } |
| final int strLen = str.length(); |
| if (strLen < 2) { |
| return EMPTY; |
| } |
| final int lastIdx = strLen - 1; |
| final String ret = str.substring(0, lastIdx); |
| final char last = str.charAt(lastIdx); |
| if (last == CharUtils.LF && ret.charAt(lastIdx - 1) == CharUtils.CR) { |
| return ret.substring(0, lastIdx - 1); |
| } |
| return ret; |
| } |
| |
| /** |
| * <p>Compare two Strings lexicographically, as per {@link String#compareTo(String)}, returning :</p> |
| * <ul> |
| * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both {@code null})</li> |
| * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li> |
| * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li> |
| * </ul> |
| * |
| * <p>This is a {@code null} safe version of :</p> |
| * <blockquote><pre>str1.compareTo(str2)</pre></blockquote> |
| * |
| * <p>{@code null} value is considered less than non-{@code null} value. |
| * Two {@code null} references are considered equal.</p> |
| * |
| * <pre> |
| * StringUtils.compare(null, null) = 0 |
| * StringUtils.compare(null , "a") < 0 |
| * StringUtils.compare("a", null) > 0 |
| * StringUtils.compare("abc", "abc") = 0 |
| * StringUtils.compare("a", "b") < 0 |
| * StringUtils.compare("b", "a") > 0 |
| * StringUtils.compare("a", "B") > 0 |
| * StringUtils.compare("ab", "abc") < 0 |
| * </pre> |
| * |
| * @see #compare(String, String, boolean) |
| * @see String#compareTo(String) |
| * @param str1 the String to compare from |
| * @param str2 the String to compare to |
| * @return < 0, 0, > 0, if {@code str1} is respectively less, equal or greater than {@code str2} |
| * @since 3.5 |
| */ |
| public static int compare(final String str1, final String str2) { |
| return compare(str1, str2, true); |
| } |
| |
| /** |
| * <p>Compare two Strings lexicographically, as per {@link String#compareTo(String)}, returning :</p> |
| * <ul> |
| * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both {@code null})</li> |
| * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li> |
| * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li> |
| * </ul> |
| * |
| * <p>This is a {@code null} safe version of :</p> |
| * <blockquote><pre>str1.compareTo(str2)</pre></blockquote> |
| * |
| * <p>{@code null} inputs are handled according to the {@code nullIsLess} parameter. |
| * Two {@code null} references are considered equal.</p> |
| * |
| * <pre> |
| * StringUtils.compare(null, null, *) = 0 |
| * StringUtils.compare(null , "a", true) < 0 |
| * StringUtils.compare(null , "a", false) > 0 |
| * StringUtils.compare("a", null, true) > 0 |
| * StringUtils.compare("a", null, false) < 0 |
| * StringUtils.compare("abc", "abc", *) = 0 |
| * StringUtils.compare("a", "b", *) < 0 |
| * StringUtils.compare("b", "a", *) > 0 |
| * StringUtils.compare("a", "B", *) > 0 |
| * StringUtils.compare("ab", "abc", *) < 0 |
| * </pre> |
| * |
| * @see String#compareTo(String) |
| * @param str1 the String to compare from |
| * @param str2 the String to compare to |
| * @param nullIsLess whether consider {@code null} value less than non-{@code null} value |
| * @return < 0, 0, > 0, if {@code str1} is respectively less, equal ou greater than {@code str2} |
| * @since 3.5 |
| */ |
| public static int compare(final String str1, final String str2, final boolean nullIsLess) { |
| if (str1 == str2) { // NOSONARLINT this intentionally uses == to allow for both null |
| return 0; |
| } |
| if (str1 == null) { |
| return nullIsLess ? -1 : 1; |
| } |
| if (str2 == null) { |
| return nullIsLess ? 1 : - 1; |
| } |
| return str1.compareTo(str2); |
| } |
| |
| /** |
| * <p>Compare two Strings lexicographically, ignoring case differences, |
| * as per {@link String#compareToIgnoreCase(String)}, returning :</p> |
| * <ul> |
| * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both {@code null})</li> |
| * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li> |
| * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li> |
| * </ul> |
| * |
| * <p>This is a {@code null} safe version of :</p> |
| * <blockquote><pre>str1.compareToIgnoreCase(str2)</pre></blockquote> |
| * |
| * <p>{@code null} value is considered less than non-{@code null} value. |
| * Two {@code null} references are considered equal. |
| * Comparison is case insensitive.</p> |
| * |
| * <pre> |
| * StringUtils.compareIgnoreCase(null, null) = 0 |
| * StringUtils.compareIgnoreCase(null , "a") < 0 |
| * StringUtils.compareIgnoreCase("a", null) > 0 |
| * StringUtils.compareIgnoreCase("abc", "abc") = 0 |
| * StringUtils.compareIgnoreCase("abc", "ABC") = 0 |
| * StringUtils.compareIgnoreCase("a", "b") < 0 |
| * StringUtils.compareIgnoreCase("b", "a") > 0 |
| * StringUtils.compareIgnoreCase("a", "B") < 0 |
| * StringUtils.compareIgnoreCase("A", "b") < 0 |
| * StringUtils.compareIgnoreCase("ab", "ABC") < 0 |
| * </pre> |
| * |
| * @see #compareIgnoreCase(String, String, boolean) |
| * @see String#compareToIgnoreCase(String) |
| * @param str1 the String to compare from |
| * @param str2 the String to compare to |
| * @return < 0, 0, > 0, if {@code str1} is respectively less, equal ou greater than {@code str2}, |
| * ignoring case differences. |
| * @since 3.5 |
| */ |
| public static int compareIgnoreCase(final String str1, final String str2) { |
| return compareIgnoreCase(str1, str2, true); |
| } |
| |
| /** |
| * <p>Compare two Strings lexicographically, ignoring case differences, |
| * as per {@link String#compareToIgnoreCase(String)}, returning :</p> |
| * <ul> |
| * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both {@code null})</li> |
| * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li> |
| * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li> |
| * </ul> |
| * |
| * <p>This is a {@code null} safe version of :</p> |
| * <blockquote><pre>str1.compareToIgnoreCase(str2)</pre></blockquote> |
| * |
| * <p>{@code null} inputs are handled according to the {@code nullIsLess} parameter. |
| * Two {@code null} references are considered equal. |
| * Comparison is case insensitive.</p> |
| * |
| * <pre> |
| * StringUtils.compareIgnoreCase(null, null, *) = 0 |
| * StringUtils.compareIgnoreCase(null , "a", true) < 0 |
| * StringUtils.compareIgnoreCase(null , "a", false) > 0 |
| * StringUtils.compareIgnoreCase("a", null, true) > 0 |
| * StringUtils.compareIgnoreCase("a", null, false) < 0 |
| * StringUtils.compareIgnoreCase("abc", "abc", *) = 0 |
| * StringUtils.compareIgnoreCase("abc", "ABC", *) = 0 |
| * StringUtils.compareIgnoreCase("a", "b", *) < 0 |
| * StringUtils.compareIgnoreCase("b", "a", *) > 0 |
| * StringUtils.compareIgnoreCase("a", "B", *) < 0 |
| * StringUtils.compareIgnoreCase("A", "b", *) < 0 |
| * StringUtils.compareIgnoreCase("ab", "abc", *) < 0 |
| * </pre> |
| * |
| * @see String#compareToIgnoreCase(String) |
| * @param str1 the String to compare from |
| * @param str2 the String to compare to |
| * @param nullIsLess whether consider {@code null} value less than non-{@code null} value |
| * @return < 0, 0, > 0, if {@code str1} is respectively less, equal ou greater than {@code str2}, |
| * ignoring case differences. |
| * @since 3.5 |
| */ |
| public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess) { |
| if (str1 == str2) { // NOSONARLINT this intentionally uses == to allow for both null |
| return 0; |
| } |
| if (str1 == null) { |
| return nullIsLess ? -1 : 1; |
| } |
| if (str2 == null) { |
| return nullIsLess ? 1 : - 1; |
| } |
| return str1.compareToIgnoreCase(str2); |
| } |
| |
| /** |
| * <p>Checks if CharSequence contains a search CharSequence, handling {@code null}. |
| * This method uses {@link String#indexOf(String)} if possible.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.contains(null, *) = false |
| * StringUtils.contains(*, null) = false |
| * StringUtils.contains("", "") = true |
| * StringUtils.contains("abc", "") = true |
| * StringUtils.contains("abc", "a") = true |
| * StringUtils.contains("abc", "z") = false |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchSeq the CharSequence to find, may be null |
| * @return true if the CharSequence contains the search CharSequence, |
| * false if not or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from contains(String, String) to contains(CharSequence, CharSequence) |
| */ |
| public static boolean contains(final CharSequence seq, final CharSequence searchSeq) { |
| if (seq == null || searchSeq == null) { |
| return false; |
| } |
| return CharSequenceUtils.indexOf(seq, searchSeq, 0) >= 0; |
| } |
| |
| /** |
| * <p>Checks if CharSequence contains a search character, handling {@code null}. |
| * This method uses {@link String#indexOf(int)} if possible.</p> |
| * |
| * <p>A {@code null} or empty ("") CharSequence will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.contains(null, *) = false |
| * StringUtils.contains("", *) = false |
| * StringUtils.contains("abc", 'a') = true |
| * StringUtils.contains("abc", 'z') = false |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchChar the character to find |
| * @return true if the CharSequence contains the search character, |
| * false if not or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from contains(String, int) to contains(CharSequence, int) |
| */ |
| public static boolean contains(final CharSequence seq, final int searchChar) { |
| if (isEmpty(seq)) { |
| return false; |
| } |
| return CharSequenceUtils.indexOf(seq, searchChar, 0) >= 0; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains any character in the given |
| * set of characters.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code false}. |
| * A {@code null} or zero length search array will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.containsAny(null, *) = false |
| * StringUtils.containsAny("", *) = false |
| * StringUtils.containsAny(*, null) = false |
| * StringUtils.containsAny(*, []) = false |
| * StringUtils.containsAny("zzabyycdxx", ['z', 'a']) = true |
| * StringUtils.containsAny("zzabyycdxx", ['b', 'y']) = true |
| * StringUtils.containsAny("zzabyycdxx", ['z', 'y']) = true |
| * StringUtils.containsAny("aba", ['z']) = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @param searchChars the chars to search for, may be null |
| * @return the {@code true} if any of the chars are found, |
| * {@code false} if no match or null input |
| * @since 2.4 |
| * @since 3.0 Changed signature from containsAny(String, char[]) to containsAny(CharSequence, char...) |
| */ |
| public static boolean containsAny(final CharSequence cs, final char... searchChars) { |
| if (isEmpty(cs) || ArrayUtils.isEmpty(searchChars)) { |
| return false; |
| } |
| final int csLength = cs.length(); |
| final int searchLength = searchChars.length; |
| final int csLast = csLength - 1; |
| final int searchLast = searchLength - 1; |
| for (int i = 0; i < csLength; i++) { |
| final char ch = cs.charAt(i); |
| for (int j = 0; j < searchLength; j++) { |
| if (searchChars[j] == ch) { |
| if (!Character.isHighSurrogate(ch)) { |
| // ch is in the Basic Multilingual Plane |
| return true; |
| } |
| if (j == searchLast) { |
| // missing low surrogate, fine, like String.indexOf(String) |
| return true; |
| } |
| if (i < csLast && searchChars[j + 1] == cs.charAt(i + 1)) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p> |
| * Checks if the CharSequence contains any character in the given set of characters. |
| * </p> |
| * |
| * <p> |
| * A {@code null} CharSequence will return {@code false}. A {@code null} search CharSequence will return |
| * {@code false}. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.containsAny(null, *) = false |
| * StringUtils.containsAny("", *) = false |
| * StringUtils.containsAny(*, null) = false |
| * StringUtils.containsAny(*, "") = false |
| * StringUtils.containsAny("zzabyycdxx", "za") = true |
| * StringUtils.containsAny("zzabyycdxx", "by") = true |
| * StringUtils.containsAny("zzabyycdxx", "zy") = true |
| * StringUtils.containsAny("zzabyycdxx", "\tx") = true |
| * StringUtils.containsAny("zzabyycdxx", "$.#yF") = true |
| * StringUtils.containsAny("aba", "z") = false |
| * </pre> |
| * |
| * @param cs |
| * the CharSequence to check, may be null |
| * @param searchChars |
| * the chars to search for, may be null |
| * @return the {@code true} if any of the chars are found, {@code false} if no match or null input |
| * @since 2.4 |
| * @since 3.0 Changed signature from containsAny(String, String) to containsAny(CharSequence, CharSequence) |
| */ |
| public static boolean containsAny(final CharSequence cs, final CharSequence searchChars) { |
| if (searchChars == null) { |
| return false; |
| } |
| return containsAny(cs, CharSequenceUtils.toCharArray(searchChars)); |
| } |
| |
| /** |
| * <p> |
| * Checks if the CharSequence contains any of the CharSequences in the given array. |
| * </p> |
| * |
| * <p> |
| * A {@code null} {@code cs} CharSequence will return {@code false}. A {@code null} or zero length search array will |
| * return {@code false}. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.containsAny(null, *) = false |
| * StringUtils.containsAny("", *) = false |
| * StringUtils.containsAny(*, null) = false |
| * StringUtils.containsAny(*, []) = false |
| * StringUtils.containsAny("abcd", "ab", null) = true |
| * StringUtils.containsAny("abcd", "ab", "cd") = true |
| * StringUtils.containsAny("abc", "d", "abc") = true |
| * </pre> |
| * |
| * |
| * @param cs The CharSequence to check, may be null |
| * @param searchCharSequences The array of CharSequences to search for, may be null. Individual CharSequences may be |
| * null as well. |
| * @return {@code true} if any of the search CharSequences are found, {@code false} otherwise |
| * @since 3.4 |
| */ |
| public static boolean containsAny(final CharSequence cs, final CharSequence... searchCharSequences) { |
| return containsAny(StringUtils::contains, cs, searchCharSequences); |
| } |
| |
| /** |
| * <p> |
| * Checks if the CharSequence contains any of the CharSequences in the given array. |
| * </p> |
| * |
| * <p> |
| * A {@code null} {@code cs} CharSequence will return {@code false}. A {@code null} or zero length search array will |
| * return {@code false}. |
| * </p> |
| * |
| * @param cs The CharSequence to check, may be null |
| * @param searchCharSequences The array of CharSequences to search for, may be null. Individual CharSequences may be |
| * null as well. |
| * @return {@code true} if any of the search CharSequences are found, {@code false} otherwise |
| * @since 3.12.0 |
| */ |
| private static boolean containsAny(final ToBooleanBiFunction<CharSequence, CharSequence> test, |
| final CharSequence cs, final CharSequence... searchCharSequences) { |
| if (isEmpty(cs) || ArrayUtils.isEmpty(searchCharSequences)) { |
| return false; |
| } |
| for (final CharSequence searchCharSequence : searchCharSequences) { |
| if (test.applyAsBoolean(cs, searchCharSequence)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p> |
| * Checks if the CharSequence contains any of the CharSequences in the given array, ignoring case. |
| * </p> |
| * |
| * <p> |
| * A {@code null} {@code cs} CharSequence will return {@code false}. A {@code null} or zero length search array will |
| * return {@code false}. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.containsAny(null, *) = false |
| * StringUtils.containsAny("", *) = false |
| * StringUtils.containsAny(*, null) = false |
| * StringUtils.containsAny(*, []) = false |
| * StringUtils.containsAny("abcd", "ab", null) = true |
| * StringUtils.containsAny("abcd", "ab", "cd") = true |
| * StringUtils.containsAny("abc", "d", "abc") = true |
| * StringUtils.containsAny("abc", "D", "ABC") = true |
| * StringUtils.containsAny("ABC", "d", "abc") = true |
| * </pre> |
| * |
| * |
| * @param cs The CharSequence to check, may be null |
| * @param searchCharSequences The array of CharSequences to search for, may be null. Individual CharSequences may be |
| * null as well. |
| * @return {@code true} if any of the search CharSequences are found, {@code false} otherwise |
| * @since 3.12.0 |
| */ |
| public static boolean containsAnyIgnoreCase(final CharSequence cs, final CharSequence... searchCharSequences) { |
| return containsAny(StringUtils::containsIgnoreCase, cs, searchCharSequences); |
| } |
| |
| /** |
| * <p>Checks if CharSequence contains a search CharSequence irrespective of case, |
| * handling {@code null}. Case-insensitivity is defined as by |
| * {@link String#equalsIgnoreCase(String)}. |
| * |
| * <p>A {@code null} CharSequence will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.containsIgnoreCase(null, *) = false |
| * StringUtils.containsIgnoreCase(*, null) = false |
| * StringUtils.containsIgnoreCase("", "") = true |
| * StringUtils.containsIgnoreCase("abc", "") = true |
| * StringUtils.containsIgnoreCase("abc", "a") = true |
| * StringUtils.containsIgnoreCase("abc", "z") = false |
| * StringUtils.containsIgnoreCase("abc", "A") = true |
| * StringUtils.containsIgnoreCase("abc", "Z") = false |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @return true if the CharSequence contains the search CharSequence irrespective of |
| * case or false if not or {@code null} string input |
| * @since 3.0 Changed signature from containsIgnoreCase(String, String) to containsIgnoreCase(CharSequence, CharSequence) |
| */ |
| public static boolean containsIgnoreCase(final CharSequence str, final CharSequence searchStr) { |
| if (str == null || searchStr == null) { |
| return false; |
| } |
| final int len = searchStr.length(); |
| final int max = str.length() - len; |
| for (int i = 0; i <= max; i++) { |
| if (CharSequenceUtils.regionMatches(str, true, i, searchStr, 0, len)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p>Checks that the CharSequence does not contain certain characters.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code true}. |
| * A {@code null} invalid character array will return {@code true}. |
| * An empty CharSequence (length()=0) always returns true.</p> |
| * |
| * <pre> |
| * StringUtils.containsNone(null, *) = true |
| * StringUtils.containsNone(*, null) = true |
| * StringUtils.containsNone("", *) = true |
| * StringUtils.containsNone("ab", '') = true |
| * StringUtils.containsNone("abab", 'xyz') = true |
| * StringUtils.containsNone("ab1", 'xyz') = true |
| * StringUtils.containsNone("abz", 'xyz') = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @param searchChars an array of invalid chars, may be null |
| * @return true if it contains none of the invalid chars, or is null |
| * @since 2.0 |
| * @since 3.0 Changed signature from containsNone(String, char[]) to containsNone(CharSequence, char...) |
| */ |
| public static boolean containsNone(final CharSequence cs, final char... searchChars) { |
| if (cs == null || searchChars == null) { |
| return true; |
| } |
| final int csLen = cs.length(); |
| final int csLast = csLen - 1; |
| final int searchLen = searchChars.length; |
| final int searchLast = searchLen - 1; |
| for (int i = 0; i < csLen; i++) { |
| final char ch = cs.charAt(i); |
| for (int j = 0; j < searchLen; j++) { |
| if (searchChars[j] == ch) { |
| if (!Character.isHighSurrogate(ch)) { |
| // ch is in the Basic Multilingual Plane |
| return false; |
| } |
| if (j == searchLast) { |
| // missing low surrogate, fine, like String.indexOf(String) |
| return false; |
| } |
| if (i < csLast && searchChars[j + 1] == cs.charAt(i + 1)) { |
| return false; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks that the CharSequence does not contain certain characters.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code true}. |
| * A {@code null} invalid character array will return {@code true}. |
| * An empty String ("") always returns true.</p> |
| * |
| * <pre> |
| * StringUtils.containsNone(null, *) = true |
| * StringUtils.containsNone(*, null) = true |
| * StringUtils.containsNone("", *) = true |
| * StringUtils.containsNone("ab", "") = true |
| * StringUtils.containsNone("abab", "xyz") = true |
| * StringUtils.containsNone("ab1", "xyz") = true |
| * StringUtils.containsNone("abz", "xyz") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @param invalidChars a String of invalid chars, may be null |
| * @return true if it contains none of the invalid chars, or is null |
| * @since 2.0 |
| * @since 3.0 Changed signature from containsNone(String, String) to containsNone(CharSequence, String) |
| */ |
| public static boolean containsNone(final CharSequence cs, final String invalidChars) { |
| if (invalidChars == null) { |
| return true; |
| } |
| return containsNone(cs, invalidChars.toCharArray()); |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only certain characters.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code false}. |
| * A {@code null} valid character array will return {@code false}. |
| * An empty CharSequence (length()=0) always returns {@code true}.</p> |
| * |
| * <pre> |
| * StringUtils.containsOnly(null, *) = false |
| * StringUtils.containsOnly(*, null) = false |
| * StringUtils.containsOnly("", *) = true |
| * StringUtils.containsOnly("ab", '') = false |
| * StringUtils.containsOnly("abab", 'abc') = true |
| * StringUtils.containsOnly("ab1", 'abc') = false |
| * StringUtils.containsOnly("abz", 'abc') = false |
| * </pre> |
| * |
| * @param cs the String to check, may be null |
| * @param valid an array of valid chars, may be null |
| * @return true if it only contains valid chars and is non-null |
| * @since 3.0 Changed signature from containsOnly(String, char[]) to containsOnly(CharSequence, char...) |
| */ |
| public static boolean containsOnly(final CharSequence cs, final char... valid) { |
| // All these pre-checks are to maintain API with an older version |
| if (valid == null || cs == null) { |
| return false; |
| } |
| if (cs.length() == 0) { |
| return true; |
| } |
| if (valid.length == 0) { |
| return false; |
| } |
| return indexOfAnyBut(cs, valid) == INDEX_NOT_FOUND; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only certain characters.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code false}. |
| * A {@code null} valid character String will return {@code false}. |
| * An empty String (length()=0) always returns {@code true}.</p> |
| * |
| * <pre> |
| * StringUtils.containsOnly(null, *) = false |
| * StringUtils.containsOnly(*, null) = false |
| * StringUtils.containsOnly("", *) = true |
| * StringUtils.containsOnly("ab", "") = false |
| * StringUtils.containsOnly("abab", "abc") = true |
| * StringUtils.containsOnly("ab1", "abc") = false |
| * StringUtils.containsOnly("abz", "abc") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @param validChars a String of valid chars, may be null |
| * @return true if it only contains valid chars and is non-null |
| * @since 2.0 |
| * @since 3.0 Changed signature from containsOnly(String, String) to containsOnly(CharSequence, String) |
| */ |
| public static boolean containsOnly(final CharSequence cs, final String validChars) { |
| if (cs == null || validChars == null) { |
| return false; |
| } |
| return containsOnly(cs, validChars.toCharArray()); |
| } |
| |
| /** |
| * <p>Check whether the given CharSequence contains any whitespace characters.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * @param seq the CharSequence to check (may be {@code null}) |
| * @return {@code true} if the CharSequence is not empty and |
| * contains at least 1 (breaking) whitespace character |
| * @since 3.0 |
| */ |
| // From org.springframework.util.StringUtils, under Apache License 2.0 |
| public static boolean containsWhitespace(final CharSequence seq) { |
| if (isEmpty(seq)) { |
| return false; |
| } |
| final int strLen = seq.length(); |
| for (int i = 0; i < strLen; i++) { |
| if (Character.isWhitespace(seq.charAt(i))) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private static void convertRemainingAccentCharacters(final StringBuilder decomposed) { |
| for (int i = 0; i < decomposed.length(); i++) { |
| if (decomposed.charAt(i) == '\u0141') { |
| decomposed.setCharAt(i, 'L'); |
| } else if (decomposed.charAt(i) == '\u0142') { |
| decomposed.setCharAt(i, 'l'); |
| } |
| } |
| } |
| |
| /** |
| * <p>Counts how many times the char appears in the given string.</p> |
| * |
| * <p>A {@code null} or empty ("") String input returns {@code 0}.</p> |
| * |
| * <pre> |
| * StringUtils.countMatches(null, *) = 0 |
| * StringUtils.countMatches("", *) = 0 |
| * StringUtils.countMatches("abba", 0) = 0 |
| * StringUtils.countMatches("abba", 'a') = 2 |
| * StringUtils.countMatches("abba", 'b') = 2 |
| * StringUtils.countMatches("abba", 'x') = 0 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param ch the char to count |
| * @return the number of occurrences, 0 if the CharSequence is {@code null} |
| * @since 3.4 |
| */ |
| public static int countMatches(final CharSequence str, final char ch) { |
| if (isEmpty(str)) { |
| return 0; |
| } |
| int count = 0; |
| // We could also call str.toCharArray() for faster lookups but that would generate more garbage. |
| for (int i = 0; i < str.length(); i++) { |
| if (ch == str.charAt(i)) { |
| count++; |
| } |
| } |
| return count; |
| } |
| |
| /** |
| * <p>Counts how many times the substring appears in the larger string. |
| * Note that the code only counts non-overlapping matches.</p> |
| * |
| * <p>A {@code null} or empty ("") String input returns {@code 0}.</p> |
| * |
| * <pre> |
| * StringUtils.countMatches(null, *) = 0 |
| * StringUtils.countMatches("", *) = 0 |
| * StringUtils.countMatches("abba", null) = 0 |
| * StringUtils.countMatches("abba", "") = 0 |
| * StringUtils.countMatches("abba", "a") = 2 |
| * StringUtils.countMatches("abba", "ab") = 1 |
| * StringUtils.countMatches("abba", "xxx") = 0 |
| * StringUtils.countMatches("ababa", "aba") = 1 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param sub the substring to count, may be null |
| * @return the number of occurrences, 0 if either CharSequence is {@code null} |
| * @since 3.0 Changed signature from countMatches(String, String) to countMatches(CharSequence, CharSequence) |
| */ |
| public static int countMatches(final CharSequence str, final CharSequence sub) { |
| if (isEmpty(str) || isEmpty(sub)) { |
| return 0; |
| } |
| int count = 0; |
| int idx = 0; |
| while ((idx = CharSequenceUtils.indexOf(str, sub, idx)) != INDEX_NOT_FOUND) { |
| count++; |
| idx += sub.length(); |
| } |
| return count; |
| } |
| |
| /** |
| * <p>Returns either the passed in CharSequence, or if the CharSequence is |
| * whitespace, empty ("") or {@code null}, the value of {@code defaultStr}.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.defaultIfBlank(null, "NULL") = "NULL" |
| * StringUtils.defaultIfBlank("", "NULL") = "NULL" |
| * StringUtils.defaultIfBlank(" ", "NULL") = "NULL" |
| * StringUtils.defaultIfBlank("bat", "NULL") = "bat" |
| * StringUtils.defaultIfBlank("", null) = null |
| * </pre> |
| * @param <T> the specific kind of CharSequence |
| * @param str the CharSequence to check, may be null |
| * @param defaultStr the default CharSequence to return |
| * if the input is whitespace, empty ("") or {@code null}, may be null |
| * @return the passed in CharSequence, or the default |
| * @see StringUtils#defaultString(String, String) |
| */ |
| public static <T extends CharSequence> T defaultIfBlank(final T str, final T defaultStr) { |
| return isBlank(str) ? defaultStr : str; |
| } |
| |
| /** |
| * <p>Returns either the passed in CharSequence, or if the CharSequence is |
| * empty or {@code null}, the value of {@code defaultStr}.</p> |
| * |
| * <pre> |
| * StringUtils.defaultIfEmpty(null, "NULL") = "NULL" |
| * StringUtils.defaultIfEmpty("", "NULL") = "NULL" |
| * StringUtils.defaultIfEmpty(" ", "NULL") = " " |
| * StringUtils.defaultIfEmpty("bat", "NULL") = "bat" |
| * StringUtils.defaultIfEmpty("", null) = null |
| * </pre> |
| * @param <T> the specific kind of CharSequence |
| * @param str the CharSequence to check, may be null |
| * @param defaultStr the default CharSequence to return |
| * if the input is empty ("") or {@code null}, may be null |
| * @return the passed in CharSequence, or the default |
| * @see StringUtils#defaultString(String, String) |
| */ |
| public static <T extends CharSequence> T defaultIfEmpty(final T str, final T defaultStr) { |
| return isEmpty(str) ? defaultStr : str; |
| } |
| |
| /** |
| * <p>Returns either the passed in String, |
| * or if the String is {@code null}, an empty String ("").</p> |
| * |
| * <pre> |
| * StringUtils.defaultString(null) = "" |
| * StringUtils.defaultString("") = "" |
| * StringUtils.defaultString("bat") = "bat" |
| * </pre> |
| * |
| * @see Objects#toString(Object, String) |
| * @see String#valueOf(Object) |
| * @param str the String to check, may be null |
| * @return the passed in String, or the empty String if it |
| * was {@code null} |
| */ |
| public static String defaultString(final String str) { |
| return Objects.toString(str, EMPTY); |
| } |
| |
| /** |
| * Returns either the given String, or if the String is |
| * {@code null}, {@code nullDefault}. |
| * |
| * <pre> |
| * StringUtils.defaultString(null, "NULL") = "NULL" |
| * StringUtils.defaultString("", "NULL") = "" |
| * StringUtils.defaultString("bat", "NULL") = "bat" |
| * </pre> |
| * |
| * @see Objects#toString(Object, String) |
| * @see String#valueOf(Object) |
| * @param str the String to check, may be null |
| * @param nullDefault the default String to return |
| * if the input is {@code null}, may be null |
| * @return the passed in String, or the default if it was {@code null} |
| * @deprecated Use {@link Objects#toString(Object, String)} |
| */ |
| @Deprecated |
| public static String defaultString(final String str, final String nullDefault) { |
| return Objects.toString(str, nullDefault); |
| } |
| |
| /** |
| * <p>Deletes all whitespaces from a String as defined by |
| * {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.deleteWhitespace(null) = null |
| * StringUtils.deleteWhitespace("") = "" |
| * StringUtils.deleteWhitespace("abc") = "abc" |
| * StringUtils.deleteWhitespace(" ab c ") = "abc" |
| * </pre> |
| * |
| * @param str the String to delete whitespace from, may be null |
| * @return the String without whitespaces, {@code null} if null String input |
| */ |
| public static String deleteWhitespace(final String str) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| final int sz = str.length(); |
| final char[] chs = new char[sz]; |
| int count = 0; |
| for (int i = 0; i < sz; i++) { |
| if (!Character.isWhitespace(str.charAt(i))) { |
| chs[count++] = str.charAt(i); |
| } |
| } |
| if (count == sz) { |
| return str; |
| } |
| if (count == 0) { |
| return EMPTY; |
| } |
| return new String(chs, 0, count); |
| } |
| |
| /** |
| * <p>Compares two Strings, and returns the portion where they differ. |
| * More precisely, return the remainder of the second String, |
| * starting from where it's different from the first. This means that |
| * the difference between "abc" and "ab" is the empty String and not "c". </p> |
| * |
| * <p>For example, |
| * {@code difference("i am a machine", "i am a robot") -> "robot"}.</p> |
| * |
| * <pre> |
| * StringUtils.difference(null, null) = null |
| * StringUtils.difference("", "") = "" |
| * StringUtils.difference("", "abc") = "abc" |
| * StringUtils.difference("abc", "") = "" |
| * StringUtils.difference("abc", "abc") = "" |
| * StringUtils.difference("abc", "ab") = "" |
| * StringUtils.difference("ab", "abxyz") = "xyz" |
| * StringUtils.difference("abcde", "abxyz") = "xyz" |
| * StringUtils.difference("abcde", "xyz") = "xyz" |
| * </pre> |
| * |
| * @param str1 the first String, may be null |
| * @param str2 the second String, may be null |
| * @return the portion of str2 where it differs from str1; returns the |
| * empty String if they are equal |
| * @see #indexOfDifference(CharSequence,CharSequence) |
| * @since 2.0 |
| */ |
| public static String difference(final String str1, final String str2) { |
| if (str1 == null) { |
| return str2; |
| } |
| if (str2 == null) { |
| return str1; |
| } |
| final int at = indexOfDifference(str1, str2); |
| if (at == INDEX_NOT_FOUND) { |
| return EMPTY; |
| } |
| return str2.substring(at); |
| } |
| |
| /** |
| * <p>Check if a CharSequence ends with a specified suffix.</p> |
| * |
| * <p>{@code null}s are handled without exceptions. Two {@code null} |
| * references are considered to be equal. The comparison is case-sensitive.</p> |
| * |
| * <pre> |
| * StringUtils.endsWith(null, null) = true |
| * StringUtils.endsWith(null, "def") = false |
| * StringUtils.endsWith("abcdef", null) = false |
| * StringUtils.endsWith("abcdef", "def") = true |
| * StringUtils.endsWith("ABCDEF", "def") = false |
| * StringUtils.endsWith("ABCDEF", "cde") = false |
| * StringUtils.endsWith("ABCDEF", "") = true |
| * </pre> |
| * |
| * @see java.lang.String#endsWith(String) |
| * @param str the CharSequence to check, may be null |
| * @param suffix the suffix to find, may be null |
| * @return {@code true} if the CharSequence ends with the suffix, case-sensitive, or |
| * both {@code null} |
| * @since 2.4 |
| * @since 3.0 Changed signature from endsWith(String, String) to endsWith(CharSequence, CharSequence) |
| */ |
| public static boolean endsWith(final CharSequence str, final CharSequence suffix) { |
| return endsWith(str, suffix, false); |
| } |
| |
| /** |
| * <p>Check if a CharSequence ends with a specified suffix (optionally case insensitive).</p> |
| * |
| * @see java.lang.String#endsWith(String) |
| * @param str the CharSequence to check, may be null |
| * @param suffix the suffix to find, may be null |
| * @param ignoreCase indicates whether the compare should ignore case |
| * (case-insensitive) or not. |
| * @return {@code true} if the CharSequence starts with the prefix or |
| * both {@code null} |
| */ |
| private static boolean endsWith(final CharSequence str, final CharSequence suffix, final boolean ignoreCase) { |
| if (str == null || suffix == null) { |
| return str == suffix; |
| } |
| if (suffix.length() > str.length()) { |
| return false; |
| } |
| final int strOffset = str.length() - suffix.length(); |
| return CharSequenceUtils.regionMatches(str, ignoreCase, strOffset, suffix, 0, suffix.length()); |
| } |
| |
| /** |
| * <p>Check if a CharSequence ends with any of the provided case-sensitive suffixes.</p> |
| * |
| * <pre> |
| * StringUtils.endsWithAny(null, null) = false |
| * StringUtils.endsWithAny(null, new String[] {"abc"}) = false |
| * StringUtils.endsWithAny("abcxyz", null) = false |
| * StringUtils.endsWithAny("abcxyz", new String[] {""}) = true |
| * StringUtils.endsWithAny("abcxyz", new String[] {"xyz"}) = true |
| * StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true |
| * StringUtils.endsWithAny("abcXYZ", "def", "XYZ") = true |
| * StringUtils.endsWithAny("abcXYZ", "def", "xyz") = false |
| * </pre> |
| * |
| * @param sequence the CharSequence to check, may be null |
| * @param searchStrings the case-sensitive CharSequences to find, may be empty or contain {@code null} |
| * @see StringUtils#endsWith(CharSequence, CharSequence) |
| * @return {@code true} if the input {@code sequence} is {@code null} AND no {@code searchStrings} are provided, or |
| * the input {@code sequence} ends in any of the provided case-sensitive {@code searchStrings}. |
| * @since 3.0 |
| */ |
| public static boolean endsWithAny(final CharSequence sequence, final CharSequence... searchStrings) { |
| if (isEmpty(sequence) || ArrayUtils.isEmpty(searchStrings)) { |
| return false; |
| } |
| for (final CharSequence searchString : searchStrings) { |
| if (endsWith(sequence, searchString)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p>Case insensitive check if a CharSequence ends with a specified suffix.</p> |
| * |
| * <p>{@code null}s are handled without exceptions. Two {@code null} |
| * references are considered to be equal. The comparison is case insensitive.</p> |
| * |
| * <pre> |
| * StringUtils.endsWithIgnoreCase(null, null) = true |
| * StringUtils.endsWithIgnoreCase(null, "def") = false |
| * StringUtils.endsWithIgnoreCase("abcdef", null) = false |
| * StringUtils.endsWithIgnoreCase("abcdef", "def") = true |
| * StringUtils.endsWithIgnoreCase("ABCDEF", "def") = true |
| * StringUtils.endsWithIgnoreCase("ABCDEF", "cde") = false |
| * </pre> |
| * |
| * @see java.lang.String#endsWith(String) |
| * @param str the CharSequence to check, may be null |
| * @param suffix the suffix to find, may be null |
| * @return {@code true} if the CharSequence ends with the suffix, case-insensitive, or |
| * both {@code null} |
| * @since 2.4 |
| * @since 3.0 Changed signature from endsWithIgnoreCase(String, String) to endsWithIgnoreCase(CharSequence, CharSequence) |
| */ |
| public static boolean endsWithIgnoreCase(final CharSequence str, final CharSequence suffix) { |
| return endsWith(str, suffix, true); |
| } |
| |
| /** |
| * <p>Compares two CharSequences, returning {@code true} if they represent |
| * equal sequences of characters.</p> |
| * |
| * <p>{@code null}s are handled without exceptions. Two {@code null} |
| * references are considered to be equal. The comparison is <strong>case-sensitive</strong>.</p> |
| * |
| * <pre> |
| * StringUtils.equals(null, null) = true |
| * StringUtils.equals(null, "abc") = false |
| * StringUtils.equals("abc", null) = false |
| * StringUtils.equals("abc", "abc") = true |
| * StringUtils.equals("abc", "ABC") = false |
| * </pre> |
| * |
| * @param cs1 the first CharSequence, may be {@code null} |
| * @param cs2 the second CharSequence, may be {@code null} |
| * @return {@code true} if the CharSequences are equal (case-sensitive), or both {@code null} |
| * @since 3.0 Changed signature from equals(String, String) to equals(CharSequence, CharSequence) |
| * @see Object#equals(Object) |
| * @see #equalsIgnoreCase(CharSequence, CharSequence) |
| */ |
| public static boolean equals(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; |
| } |
| if (cs1 instanceof String && cs2 instanceof String) { |
| return cs1.equals(cs2); |
| } |
| // Step-wise comparison |
| final int length = cs1.length(); |
| for (int i = 0; i < length; i++) { |
| if (cs1.charAt(i) != cs2.charAt(i)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Compares given {@code string} to a CharSequences vararg of {@code searchStrings}, |
| * returning {@code true} if the {@code string} is equal to any of the {@code searchStrings}.</p> |
| * |
| * <pre> |
| * StringUtils.equalsAny(null, (CharSequence[]) null) = false |
| * StringUtils.equalsAny(null, null, null) = true |
| * StringUtils.equalsAny(null, "abc", "def") = false |
| * StringUtils.equalsAny("abc", null, "def") = false |
| * StringUtils.equalsAny("abc", "abc", "def") = true |
| * StringUtils.equalsAny("abc", "ABC", "DEF") = false |
| * </pre> |
| * |
| * @param string to compare, may be {@code null}. |
| * @param searchStrings a vararg of strings, may be {@code null}. |
| * @return {@code true} if the string is equal (case-sensitive) to any other element of {@code searchStrings}; |
| * {@code false} if {@code searchStrings} is null or contains no matches. |
| * @since 3.5 |
| */ |
| public static boolean equalsAny(final CharSequence string, final CharSequence... searchStrings) { |
| if (ArrayUtils.isNotEmpty(searchStrings)) { |
| for (final CharSequence next : searchStrings) { |
| if (equals(string, next)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p>Compares given {@code string} to a CharSequences vararg of {@code searchStrings}, |
| * returning {@code true} if the {@code string} is equal to any of the {@code searchStrings}, ignoring case.</p> |
| * |
| * <pre> |
| * StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null) = false |
| * StringUtils.equalsAnyIgnoreCase(null, null, null) = true |
| * StringUtils.equalsAnyIgnoreCase(null, "abc", "def") = false |
| * StringUtils.equalsAnyIgnoreCase("abc", null, "def") = false |
| * StringUtils.equalsAnyIgnoreCase("abc", "abc", "def") = true |
| * StringUtils.equalsAnyIgnoreCase("abc", "ABC", "DEF") = true |
| * </pre> |
| * |
| * @param string to compare, may be {@code null}. |
| * @param searchStrings a vararg of strings, may be {@code null}. |
| * @return {@code true} if the string is equal (case-insensitive) to any other element of {@code searchStrings}; |
| * {@code false} if {@code searchStrings} is null or contains no matches. |
| * @since 3.5 |
| */ |
| public static boolean equalsAnyIgnoreCase(final CharSequence string, final CharSequence...searchStrings) { |
| if (ArrayUtils.isNotEmpty(searchStrings)) { |
| for (final CharSequence next : searchStrings) { |
| if (equalsIgnoreCase(string, next)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p>Compares two CharSequences, returning {@code true} if they represent |
| * equal sequences of characters, ignoring case.</p> |
| * |
| * <p>{@code null}s are handled without exceptions. Two {@code null} |
| * references are considered equal. The comparison is <strong>case insensitive</strong>.</p> |
| * |
| * <pre> |
| * StringUtils.equalsIgnoreCase(null, null) = true |
| * StringUtils.equalsIgnoreCase(null, "abc") = false |
| * StringUtils.equalsIgnoreCase("abc", null) = false |
| * StringUtils.equalsIgnoreCase("abc", "abc") = true |
| * StringUtils.equalsIgnoreCase("abc", "ABC") = true |
| * </pre> |
| * |
| * @param cs1 the first CharSequence, may be {@code null} |
| * @param cs2 the second CharSequence, may be {@code null} |
| * @return {@code true} if the CharSequences are equal (case-insensitive), or both {@code null} |
| * @since 3.0 Changed signature from equalsIgnoreCase(String, String) to equalsIgnoreCase(CharSequence, CharSequence) |
| * @see #equals(CharSequence, CharSequence) |
| */ |
| 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 CharSequenceUtils.regionMatches(cs1, true, 0, cs2, 0, cs1.length()); |
| } |
| |
| /** |
| * <p>Returns the first value in the array which is not empty (""), |
| * {@code null} or whitespace only.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>If all values are blank or the array is {@code null} |
| * or empty then {@code null} is returned.</p> |
| * |
| * <pre> |
| * StringUtils.firstNonBlank(null, null, null) = null |
| * StringUtils.firstNonBlank(null, "", " ") = null |
| * StringUtils.firstNonBlank("abc") = "abc" |
| * StringUtils.firstNonBlank(null, "xyz") = "xyz" |
| * StringUtils.firstNonBlank(null, "", " ", "xyz") = "xyz" |
| * StringUtils.firstNonBlank(null, "xyz", "abc") = "xyz" |
| * StringUtils.firstNonBlank() = null |
| * </pre> |
| * |
| * @param <T> the specific kind of CharSequence |
| * @param values the values to test, may be {@code null} or empty |
| * @return the first value from {@code values} which is not blank, |
| * or {@code null} if there are no non-blank values |
| * @since 3.8 |
| */ |
| @SafeVarargs |
| public static <T extends CharSequence> T firstNonBlank(final T... values) { |
| if (values != null) { |
| for (final T val : values) { |
| if (isNotBlank(val)) { |
| return val; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * <p>Returns the first value in the array which is not empty.</p> |
| * |
| * <p>If all values are empty or the array is {@code null} |
| * or empty then {@code null} is returned.</p> |
| * |
| * <pre> |
| * StringUtils.firstNonEmpty(null, null, null) = null |
| * StringUtils.firstNonEmpty(null, null, "") = null |
| * StringUtils.firstNonEmpty(null, "", " ") = " " |
| * StringUtils.firstNonEmpty("abc") = "abc" |
| * StringUtils.firstNonEmpty(null, "xyz") = "xyz" |
| * StringUtils.firstNonEmpty("", "xyz") = "xyz" |
| * StringUtils.firstNonEmpty(null, "xyz", "abc") = "xyz" |
| * StringUtils.firstNonEmpty() = null |
| * </pre> |
| * |
| * @param <T> the specific kind of CharSequence |
| * @param values the values to test, may be {@code null} or empty |
| * @return the first value from {@code values} which is not empty, |
| * or {@code null} if there are no non-empty values |
| * @since 3.8 |
| */ |
| @SafeVarargs |
| public static <T extends CharSequence> T firstNonEmpty(final T... values) { |
| if (values != null) { |
| for (final T val : values) { |
| if (isNotEmpty(val)) { |
| return val; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Calls {@link String#getBytes(Charset)} in a null-safe manner. |
| * |
| * @param string input string |
| * @param charset The {@link Charset} to encode the {@link String}. If null, then use the default Charset. |
| * @return The empty byte[] if {@code string} is null, the result of {@link String#getBytes(Charset)} otherwise. |
| * @see String#getBytes(Charset) |
| * @since 3.10 |
| */ |
| public static byte[] getBytes(final String string, final Charset charset) { |
| return string == null ? ArrayUtils.EMPTY_BYTE_ARRAY : string.getBytes(Charsets.toCharset(charset)); |
| } |
| |
| /** |
| * Calls {@link String#getBytes(String)} in a null-safe manner. |
| * |
| * @param string input string |
| * @param charset The {@link Charset} name to encode the {@link String}. If null, then use the default Charset. |
| * @return The empty byte[] if {@code string} is null, the result of {@link String#getBytes(String)} otherwise. |
| * @throws UnsupportedEncodingException Thrown when the named charset is not supported. |
| * @see String#getBytes(String) |
| * @since 3.10 |
| */ |
| public static byte[] getBytes(final String string, final String charset) throws UnsupportedEncodingException { |
| return string == null ? ArrayUtils.EMPTY_BYTE_ARRAY : string.getBytes(Charsets.toCharsetName(charset)); |
| } |
| |
| /** |
| * <p>Compares all Strings in an array and returns the initial sequence of |
| * characters that is common to all of them.</p> |
| * |
| * <p>For example, |
| * {@code getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) -> "i am a "}</p> |
| * |
| * <pre> |
| * StringUtils.getCommonPrefix(null) = "" |
| * StringUtils.getCommonPrefix(new String[] {}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"abc"}) = "abc" |
| * StringUtils.getCommonPrefix(new String[] {null, null}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"", ""}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"", null}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"abc", null, null}) = "" |
| * StringUtils.getCommonPrefix(new String[] {null, null, "abc"}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"", "abc"}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"abc", ""}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"abc", "abc"}) = "abc" |
| * StringUtils.getCommonPrefix(new String[] {"abc", "a"}) = "a" |
| * StringUtils.getCommonPrefix(new String[] {"ab", "abxyz"}) = "ab" |
| * StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"}) = "ab" |
| * StringUtils.getCommonPrefix(new String[] {"abcde", "xyz"}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"xyz", "abcde"}) = "" |
| * StringUtils.getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) = "i am a " |
| * </pre> |
| * |
| * @param strs array of String objects, entries may be null |
| * @return the initial sequence of characters that are common to all Strings |
| * in the array; empty String if the array is null, the elements are all null |
| * or if there is no common prefix. |
| * @since 2.4 |
| */ |
| public static String getCommonPrefix(final String... strs) { |
| if (ArrayUtils.isEmpty(strs)) { |
| return EMPTY; |
| } |
| final int smallestIndexOfDiff = indexOfDifference(strs); |
| if (smallestIndexOfDiff == INDEX_NOT_FOUND) { |
| // all strings were identical |
| if (strs[0] == null) { |
| return EMPTY; |
| } |
| return strs[0]; |
| } |
| if (smallestIndexOfDiff == 0) { |
| // there were no common initial characters |
| return EMPTY; |
| } |
| // we found a common initial character sequence |
| return strs[0].substring(0, smallestIndexOfDiff); |
| } |
| |
| /** |
| * <p>Checks if a String {@code str} contains Unicode digits, |
| * if yes then concatenate all the digits in {@code str} and return it as a String.</p> |
| * |
| * <p>An empty ("") String will be returned if no digits found in {@code str}.</p> |
| * |
| * <pre> |
| * StringUtils.getDigits(null) = null |
| * StringUtils.getDigits("") = "" |
| * StringUtils.getDigits("abc") = "" |
| * StringUtils.getDigits("1000$") = "1000" |
| * StringUtils.getDigits("1123~45") = "112345" |
| * StringUtils.getDigits("(541) 754-3010") = "5417543010" |
| * StringUtils.getDigits("\u0967\u0968\u0969") = "\u0967\u0968\u0969" |
| * </pre> |
| * |
| * @param str the String to extract digits from, may be null |
| * @return String with only digits, |
| * or an empty ("") String if no digits found, |
| * or {@code null} String if {@code str} is null |
| * @since 3.6 |
| */ |
| public static String getDigits(final String str) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| final int sz = str.length(); |
| final StringBuilder strDigits = new StringBuilder(sz); |
| for (int i = 0; i < sz; i++) { |
| final char tempChar = str.charAt(i); |
| if (Character.isDigit(tempChar)) { |
| strDigits.append(tempChar); |
| } |
| } |
| return strDigits.toString(); |
| } |
| |
| /** |
| * <p>Find the Fuzzy Distance which indicates the similarity score between two Strings.</p> |
| * |
| * <p>This string matching algorithm is similar to the algorithms of editors such as Sublime Text, |
| * TextMate, Atom and others. One point is given for every matched character. Subsequent |
| * matches yield two bonus points. A higher score indicates a higher similarity.</p> |
| * |
| * <pre> |
| * StringUtils.getFuzzyDistance(null, null, null) = IllegalArgumentException |
| * StringUtils.getFuzzyDistance("", "", Locale.ENGLISH) = 0 |
| * StringUtils.getFuzzyDistance("Workshop", "b", Locale.ENGLISH) = 0 |
| * StringUtils.getFuzzyDistance("Room", "o", Locale.ENGLISH) = 1 |
| * StringUtils.getFuzzyDistance("Workshop", "w", Locale.ENGLISH) = 1 |
| * StringUtils.getFuzzyDistance("Workshop", "ws", Locale.ENGLISH) = 2 |
| * StringUtils.getFuzzyDistance("Workshop", "wo", Locale.ENGLISH) = 4 |
| * StringUtils.getFuzzyDistance("Apache Software Foundation", "asf", Locale.ENGLISH) = 3 |
| * </pre> |
| * |
| * @param term a full term that should be matched against, must not be null |
| * @param query the query that will be matched against a term, must not be null |
| * @param locale This string matching logic is case-insensitive. A locale is necessary to normalize |
| * both Strings to lower case. |
| * @return result score |
| * @throws IllegalArgumentException if either String input {@code null} or Locale input {@code null} |
| * @since 3.4 |
| * @deprecated As of 3.6, use Apache Commons Text |
| * <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/FuzzyScore.html"> |
| * FuzzyScore</a> instead |
| */ |
| @Deprecated |
| public static int getFuzzyDistance(final CharSequence term, final CharSequence query, final Locale locale) { |
| if (term == null || query == null) { |
| throw new IllegalArgumentException("Strings must not be null"); |
| } |
| if (locale == null) { |
| throw new IllegalArgumentException("Locale must not be null"); |
| } |
| |
| // fuzzy logic is case-insensitive. We normalize the Strings to lower |
| // case right from the start. Turning characters to lower case |
| // via Character.toLowerCase(char) is unfortunately insufficient |
| // as it does not accept a locale. |
| final String termLowerCase = term.toString().toLowerCase(locale); |
| final String queryLowerCase = query.toString().toLowerCase(locale); |
| |
| // the resulting score |
| int score = 0; |
| |
| // the position in the term which will be scanned next for potential |
| // query character matches |
| int termIndex = 0; |
| |
| // index of the previously matched character in the term |
| int previousMatchingCharacterIndex = Integer.MIN_VALUE; |
| |
| for (int queryIndex = 0; queryIndex < queryLowerCase.length(); queryIndex++) { |
| final char queryChar = queryLowerCase.charAt(queryIndex); |
| |
| boolean termCharacterMatchFound = false; |
| for (; termIndex < termLowerCase.length() && !termCharacterMatchFound; termIndex++) { |
| final char termChar = termLowerCase.charAt(termIndex); |
| |
| if (queryChar == termChar) { |
| // simple character matches result in one point |
| score++; |
| |
| // subsequent character matches further improve |
| // the score. |
| if (previousMatchingCharacterIndex + 1 == termIndex) { |
| score += 2; |
| } |
| |
| previousMatchingCharacterIndex = termIndex; |
| |
| // we can leave the nested loop. Every character in the |
| // query can match at most one character in the term. |
| termCharacterMatchFound = true; |
| } |
| } |
| } |
| |
| return score; |
| } |
| |
| /** |
| * <p>Returns either the passed in CharSequence, or if the CharSequence is |
| * whitespace, empty ("") or {@code null}, the value supplied by {@code defaultStrSupplier}.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>Caller responsible for thread-safety and exception handling of default value supplier</p> |
| * |
| * <pre> |
| * {@code |
| * StringUtils.getIfBlank(null, () -> "NULL") = "NULL" |
| * StringUtils.getIfBlank("", () -> "NULL") = "NULL" |
| * StringUtils.getIfBlank(" ", () -> "NULL") = "NULL" |
| * StringUtils.getIfBlank("bat", () -> "NULL") = "bat" |
| * StringUtils.getIfBlank("", () -> null) = null |
| * StringUtils.getIfBlank("", null) = null |
| * }</pre> |
| * @param <T> the specific kind of CharSequence |
| * @param str the CharSequence to check, may be null |
| * @param defaultSupplier the supplier of default CharSequence to return |
| * if the input is whitespace, empty ("") or {@code null}, may be null |
| * @return the passed in CharSequence, or the default |
| * @see StringUtils#defaultString(String, String) |
| * @since 3.10 |
| */ |
| public static <T extends CharSequence> T getIfBlank(final T str, final Supplier<T> defaultSupplier) { |
| return isBlank(str) ? Suppliers.get(defaultSupplier) : str; |
| } |
| |
| /** |
| * <p>Returns either the passed in CharSequence, or if the CharSequence is |
| * empty or {@code null}, the value supplied by {@code defaultStrSupplier}.</p> |
| * |
| * <p>Caller responsible for thread-safety and exception handling of default value supplier</p> |
| * |
| * <pre> |
| * {@code |
| * StringUtils.getIfEmpty(null, () -> "NULL") = "NULL" |
| * StringUtils.getIfEmpty("", () -> "NULL") = "NULL" |
| * StringUtils.getIfEmpty(" ", () -> "NULL") = " " |
| * StringUtils.getIfEmpty("bat", () -> "NULL") = "bat" |
| * StringUtils.getIfEmpty("", () -> null) = null |
| * StringUtils.getIfEmpty("", null) = null |
| * } |
| * </pre> |
| * @param <T> the specific kind of CharSequence |
| * @param str the CharSequence to check, may be null |
| * @param defaultSupplier the supplier of default CharSequence to return |
| * if the input is empty ("") or {@code null}, may be null |
| * @return the passed in CharSequence, or the default |
| * @see StringUtils#defaultString(String, String) |
| * @since 3.10 |
| */ |
| public static <T extends CharSequence> T getIfEmpty(final T str, final Supplier<T> defaultSupplier) { |
| return isEmpty(str) ? Suppliers.get(defaultSupplier) : str; |
| } |
| |
| /** |
| * <p>Find the Jaro Winkler Distance which indicates the similarity score between two Strings.</p> |
| * |
| * <p>The Jaro measure is the weighted sum of percentage of matched characters from each file and transposed characters. |
| * Winkler increased this measure for matching initial characters.</p> |
| * |
| * <p>This implementation is based on the Jaro Winkler similarity algorithm |
| * from <a href="http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance">http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance</a>.</p> |
| * |
| * <pre> |
| * StringUtils.getJaroWinklerDistance(null, null) = IllegalArgumentException |
| * StringUtils.getJaroWinklerDistance("", "") = 0.0 |
| * StringUtils.getJaroWinklerDistance("", "a") = 0.0 |
| * StringUtils.getJaroWinklerDistance("aaapppp", "") = 0.0 |
| * StringUtils.getJaroWinklerDistance("frog", "fog") = 0.93 |
| * StringUtils.getJaroWinklerDistance("fly", "ant") = 0.0 |
| * StringUtils.getJaroWinklerDistance("elephant", "hippo") = 0.44 |
| * StringUtils.getJaroWinklerDistance("hippo", "elephant") = 0.44 |
| * StringUtils.getJaroWinklerDistance("hippo", "zzzzzzzz") = 0.0 |
| * StringUtils.getJaroWinklerDistance("hello", "hallo") = 0.88 |
| * StringUtils.getJaroWinklerDistance("ABC Corporation", "ABC Corp") = 0.93 |
| * StringUtils.getJaroWinklerDistance("D N H Enterprises Inc", "D & H Enterprises, Inc.") = 0.95 |
| * StringUtils.getJaroWinklerDistance("My Gym Children's Fitness Center", "My Gym. Childrens Fitness") = 0.92 |
| * StringUtils.getJaroWinklerDistance("PENNSYLVANIA", "PENNCISYLVNIA") = 0.88 |
| * </pre> |
| * |
| * @param first the first String, must not be null |
| * @param second the second String, must not be null |
| * @return result distance |
| * @throws IllegalArgumentException if either String input {@code null} |
| * @since 3.3 |
| * @deprecated As of 3.6, use Apache Commons Text |
| * <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/JaroWinklerDistance.html"> |
| * JaroWinklerDistance</a> instead |
| */ |
| @Deprecated |
| public static double getJaroWinklerDistance(final CharSequence first, final CharSequence second) { |
| final double DEFAULT_SCALING_FACTOR = 0.1; |
| |
| if (first == null || second == null) { |
| throw new IllegalArgumentException("Strings must not be null"); |
| } |
| |
| final int[] mtp = matches(first, second); |
| final double m = mtp[0]; |
| if (m == 0) { |
| return 0D; |
| } |
| final double j = (m / first.length() + m / second.length() + (m - mtp[1]) / m) / 3; |
| final double jw = j < 0.7D ? j : j + Math.min(DEFAULT_SCALING_FACTOR, 1D / mtp[3]) * mtp[2] * (1D - j); |
| return Math.round(jw * 100.0D) / 100.0D; |
| } |
| |
| /** |
| * <p>Find the Levenshtein distance between two Strings.</p> |
| * |
| * <p>This is the number of changes needed to change one String into |
| * another, where each change is a single character modification (deletion, |
| * insertion or substitution).</p> |
| * |
| * <p>The implementation uses a single-dimensional array of length s.length() + 1. See |
| * <a href="http://blog.softwx.net/2014/12/optimizing-levenshtein-algorithm-in-c.html"> |
| * http://blog.softwx.net/2014/12/optimizing-levenshtein-algorithm-in-c.html</a> for details.</p> |
| * |
| * <pre> |
| * StringUtils.getLevenshteinDistance(null, *) = IllegalArgumentException |
| * StringUtils.getLevenshteinDistance(*, null) = IllegalArgumentException |
| * StringUtils.getLevenshteinDistance("", "") = 0 |
| * StringUtils.getLevenshteinDistance("", "a") = 1 |
| * StringUtils.getLevenshteinDistance("aaapppp", "") = 7 |
| * StringUtils.getLevenshteinDistance("frog", "fog") = 1 |
| * StringUtils.getLevenshteinDistance("fly", "ant") = 3 |
| * StringUtils.getLevenshteinDistance("elephant", "hippo") = 7 |
| * StringUtils.getLevenshteinDistance("hippo", "elephant") = 7 |
| * StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz") = 8 |
| * StringUtils.getLevenshteinDistance("hello", "hallo") = 1 |
| * </pre> |
| * |
| * @param s the first String, must not be null |
| * @param t the second String, must not be null |
| * @return result distance |
| * @throws IllegalArgumentException if either String input {@code null} |
| * @since 3.0 Changed signature from getLevenshteinDistance(String, String) to |
| * getLevenshteinDistance(CharSequence, CharSequence) |
| * @deprecated As of 3.6, use Apache Commons Text |
| * <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/LevenshteinDistance.html"> |
| * LevenshteinDistance</a> instead |
| */ |
| @Deprecated |
| public static int getLevenshteinDistance(CharSequence s, CharSequence t) { |
| if (s == null || t == null) { |
| throw new IllegalArgumentException("Strings must not be null"); |
| } |
| |
| int n = s.length(); |
| int m = t.length(); |
| |
| if (n == 0) { |
| return m; |
| } |
| if (m == 0) { |
| return n; |
| } |
| |
| if (n > m) { |
| // swap the input strings to consume less memory |
| final CharSequence tmp = s; |
| s = t; |
| t = tmp; |
| n = m; |
| m = t.length(); |
| } |
| |
| final int[] p = new int[n + 1]; |
| // indexes into strings s and t |
| int i; // iterates through s |
| int j; // iterates through t |
| int upper_left; |
| int upper; |
| |
| char t_j; // jth character of t |
| int cost; |
| |
| for (i = 0; i <= n; i++) { |
| p[i] = i; |
| } |
| |
| for (j = 1; j <= m; j++) { |
| upper_left = p[0]; |
| t_j = t.charAt(j - 1); |
| p[0] = j; |
| |
| for (i = 1; i <= n; i++) { |
| upper = p[i]; |
| cost = s.charAt(i - 1) == t_j ? 0 : 1; |
| // minimum of cell to the left+1, to the top+1, diagonally left and up +cost |
| p[i] = Math.min(Math.min(p[i - 1] + 1, p[i] + 1), upper_left + cost); |
| upper_left = upper; |
| } |
| } |
| |
| return p[n]; |
| } |
| |
| /** |
| * <p>Find the Levenshtein distance between two Strings if it's less than or equal to a given |
| * threshold.</p> |
| * |
| * <p>This is the number of changes needed to change one String into |
| * another, where each change is a single character modification (deletion, |
| * insertion or substitution).</p> |
| * |
| * <p>This implementation follows from Algorithms on Strings, Trees and Sequences by Dan Gusfield |
| * and Chas Emerick's implementation of the Levenshtein distance algorithm from |
| * <a href="http://www.merriampark.com/ld.htm">http://www.merriampark.com/ld.htm</a></p> |
| * |
| * <pre> |
| * StringUtils.getLevenshteinDistance(null, *, *) = IllegalArgumentException |
| * StringUtils.getLevenshteinDistance(*, null, *) = IllegalArgumentException |
| * StringUtils.getLevenshteinDistance(*, *, -1) = IllegalArgumentException |
| * StringUtils.getLevenshteinDistance("", "", 0) = 0 |
| * StringUtils.getLevenshteinDistance("aaapppp", "", 8) = 7 |
| * StringUtils.getLevenshteinDistance("aaapppp", "", 7) = 7 |
| * StringUtils.getLevenshteinDistance("aaapppp", "", 6)) = -1 |
| * StringUtils.getLevenshteinDistance("elephant", "hippo", 7) = 7 |
| * StringUtils.getLevenshteinDistance("elephant", "hippo", 6) = -1 |
| * StringUtils.getLevenshteinDistance("hippo", "elephant", 7) = 7 |
| * StringUtils.getLevenshteinDistance("hippo", "elephant", 6) = -1 |
| * </pre> |
| * |
| * @param s the first String, must not be null |
| * @param t the second String, must not be null |
| * @param threshold the target threshold, must not be negative |
| * @return result distance, or {@code -1} if the distance would be greater than the threshold |
| * @throws IllegalArgumentException if either String input {@code null} or negative threshold |
| * @deprecated As of 3.6, use Apache Commons Text |
| * <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/LevenshteinDistance.html"> |
| * LevenshteinDistance</a> instead |
| */ |
| @Deprecated |
| public static int getLevenshteinDistance(CharSequence s, CharSequence t, final int threshold) { |
| if (s == null || t == null) { |
| throw new IllegalArgumentException("Strings must not be null"); |
| } |
| if (threshold < 0) { |
| throw new IllegalArgumentException("Threshold must not be negative"); |
| } |
| |
| /* |
| This implementation only computes the distance if it's less than or equal to the |
| threshold value, returning -1 if it's greater. The advantage is performance: unbounded |
| distance is O(nm), but a bound of k allows us to reduce it to O(km) time by only |
| computing a diagonal stripe of width 2k + 1 of the cost table. |
| It is also possible to use this to compute the unbounded Levenshtein distance by starting |
| the threshold at 1 and doubling each time until the distance is found; this is O(dm), where |
| d is the distance. |
| |
| One subtlety comes from needing to ignore entries on the border of our stripe |
| eg. |
| p[] = |#|#|#|* |
| d[] = *|#|#|#| |
| We must ignore the entry to the left of the leftmost member |
| We must ignore the entry above the rightmost member |
| |
| Another subtlety comes from our stripe running off the matrix if the strings aren't |
| of the same size. Since string s is always swapped to be the shorter of the two, |
| the stripe will always run off to the upper right instead of the lower left of the matrix. |
| |
| As a concrete example, suppose s is of length 5, t is of length 7, and our threshold is 1. |
| In this case we're going to walk a stripe of length 3. The matrix would look like so: |
| |
| 1 2 3 4 5 |
| 1 |#|#| | | | |
| 2 |#|#|#| | | |
| 3 | |#|#|#| | |
| 4 | | |#|#|#| |
| 5 | | | |#|#| |
| 6 | | | | |#| |
| 7 | | | | | | |
| |
| Note how the stripe leads off the table as there is no possible way to turn a string of length 5 |
| into one of length 7 in edit distance of 1. |
| |
| Additionally, this implementation decreases memory usage by using two |
| single-dimensional arrays and swapping them back and forth instead of allocating |
| an entire n by m matrix. This requires a few minor changes, such as immediately returning |
| when it's detected that the stripe has run off the matrix and initially filling the arrays with |
| large values so that entries we don't compute are ignored. |
| |
| See Algorithms on Strings, Trees and Sequences by Dan Gusfield for some discussion. |
| */ |
| |
| int n = s.length(); // length of s |
| int m = t.length(); // length of t |
| |
| // if one string is empty, the edit distance is necessarily the length of the other |
| if (n == 0) { |
| return m <= threshold ? m : -1; |
| } |
| if (m == 0) { |
| return n <= threshold ? n : -1; |
| } |
| if (Math.abs(n - m) > threshold) { |
| // no need to calculate the distance if the length difference is greater than the threshold |
| return -1; |
| } |
| |
| if (n > m) { |
| // swap the two strings to consume less memory |
| final CharSequence tmp = s; |
| s = t; |
| t = tmp; |
| n = m; |
| m = t.length(); |
| } |
| |
| int[] p = new int[n + 1]; // 'previous' cost array, horizontally |
| int[] d = new int[n + 1]; // cost array, horizontally |
| int[] tmp; // placeholder to assist in swapping p and d |
| |
| // fill in starting table values |
| final int boundary = Math.min(n, threshold) + 1; |
| for (int i = 0; i < boundary; i++) { |
| p[i] = i; |
| } |
| // these fills ensure that the value above the rightmost entry of our |
| // stripe will be ignored in following loop iterations |
| Arrays.fill(p, boundary, p.length, Integer.MAX_VALUE); |
| Arrays.fill(d, Integer.MAX_VALUE); |
| |
| // iterates through t |
| for (int j = 1; j <= m; j++) { |
| final char t_j = t.charAt(j - 1); // jth character of t |
| d[0] = j; |
| |
| // compute stripe indices, constrain to array size |
| final int min = Math.max(1, j - threshold); |
| final int max = j > Integer.MAX_VALUE - threshold ? n : Math.min(n, j + threshold); |
| |
| // the stripe may lead off of the table if s and t are of different sizes |
| if (min > max) { |
| return -1; |
| } |
| |
| // ignore entry left of leftmost |
| if (min > 1) { |
| d[min - 1] = Integer.MAX_VALUE; |
| } |
| |
| // iterates through [min, max] in s |
| for (int i = min; i <= max; i++) { |
| if (s.charAt(i - 1) == t_j) { |
| // diagonally left and up |
| d[i] = p[i - 1]; |
| } else { |
| // 1 + minimum of cell to the left, to the top, diagonally left and up |
| d[i] = 1 + Math.min(Math.min(d[i - 1], p[i]), p[i - 1]); |
| } |
| } |
| |
| // copy current distance counts to 'previous row' distance counts |
| tmp = p; |
| p = d; |
| d = tmp; |
| } |
| |
| // if p[n] is greater than the threshold, there's no guarantee on it being the correct |
| // distance |
| if (p[n] <= threshold) { |
| return p[n]; |
| } |
| return -1; |
| } |
| |
| /** |
| * <p>Finds the first index within a CharSequence, handling {@code null}. |
| * This method uses {@link String#indexOf(String, int)} if possible.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.indexOf(null, *) = -1 |
| * StringUtils.indexOf(*, null) = -1 |
| * StringUtils.indexOf("", "") = 0 |
| * StringUtils.indexOf("", *) = -1 (except when * = "") |
| * StringUtils.indexOf("aabaabaa", "a") = 0 |
| * StringUtils.indexOf("aabaabaa", "b") = 2 |
| * StringUtils.indexOf("aabaabaa", "ab") = 1 |
| * StringUtils.indexOf("aabaabaa", "") = 0 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchSeq the CharSequence to find, may be null |
| * @return the first index of the search CharSequence, |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOf(String, String) to indexOf(CharSequence, CharSequence) |
| */ |
| public static int indexOf(final CharSequence seq, final CharSequence searchSeq) { |
| if (seq == null || searchSeq == null) { |
| return INDEX_NOT_FOUND; |
| } |
| return CharSequenceUtils.indexOf(seq, searchSeq, 0); |
| } |
| |
| /** |
| * <p>Finds the first index within a CharSequence, handling {@code null}. |
| * This method uses {@link String#indexOf(String, int)} if possible.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A negative start position is treated as zero. |
| * An empty ("") search CharSequence always matches. |
| * A start position greater than the string length only matches |
| * an empty search CharSequence.</p> |
| * |
| * <pre> |
| * StringUtils.indexOf(null, *, *) = -1 |
| * StringUtils.indexOf(*, null, *) = -1 |
| * StringUtils.indexOf("", "", 0) = 0 |
| * StringUtils.indexOf("", *, 0) = -1 (except when * = "") |
| * StringUtils.indexOf("aabaabaa", "a", 0) = 0 |
| * StringUtils.indexOf("aabaabaa", "b", 0) = 2 |
| * StringUtils.indexOf("aabaabaa", "ab", 0) = 1 |
| * StringUtils.indexOf("aabaabaa", "b", 3) = 5 |
| * StringUtils.indexOf("aabaabaa", "b", 9) = -1 |
| * StringUtils.indexOf("aabaabaa", "b", -1) = 2 |
| * StringUtils.indexOf("aabaabaa", "", 2) = 2 |
| * StringUtils.indexOf("abc", "", 9) = 3 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchSeq the CharSequence to find, may be null |
| * @param startPos the start position, negative treated as zero |
| * @return the first index of the search CharSequence (always ≥ startPos), |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOf(String, String, int) to indexOf(CharSequence, CharSequence, int) |
| */ |
| public static int indexOf(final CharSequence seq, final CharSequence searchSeq, final int startPos) { |
| if (seq == null || searchSeq == null) { |
| return INDEX_NOT_FOUND; |
| } |
| return CharSequenceUtils.indexOf(seq, searchSeq, startPos); |
| } |
| |
| /** |
| * Returns the index within {@code seq} of the first occurrence of |
| * the specified character. If a character with value |
| * {@code searchChar} occurs in the character sequence represented by |
| * {@code seq} {@link CharSequence} object, then the index (in Unicode |
| * code units) of the first such occurrence is returned. For |
| * values of {@code searchChar} in the range from 0 to 0xFFFF |
| * (inclusive), this is the smallest value <i>k</i> such that: |
| * <blockquote><pre> |
| * this.charAt(<i>k</i>) == searchChar |
| * </pre></blockquote> |
| * is true. For other values of {@code searchChar}, it is the |
| * smallest value <i>k</i> such that: |
| * <blockquote><pre> |
| * this.codePointAt(<i>k</i>) == searchChar |
| * </pre></blockquote> |
| * is true. In either case, if no such character occurs in {@code seq}, |
| * then {@code INDEX_NOT_FOUND (-1)} is returned. |
| * |
| * <p>Furthermore, a {@code null} or empty ("") CharSequence will |
| * return {@code INDEX_NOT_FOUND (-1)}.</p> |
| * |
| * <pre> |
| * StringUtils.indexOf(null, *) = -1 |
| * StringUtils.indexOf("", *) = -1 |
| * StringUtils.indexOf("aabaabaa", 'a') = 0 |
| * StringUtils.indexOf("aabaabaa", 'b') = 2 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchChar the character to find |
| * @return the first index of the search character, |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOf(String, int) to indexOf(CharSequence, int) |
| * @since 3.6 Updated {@link CharSequenceUtils} call to behave more like {@link String} |
| */ |
| public static int indexOf(final CharSequence seq, final int searchChar) { |
| if (isEmpty(seq)) { |
| return INDEX_NOT_FOUND; |
| } |
| return CharSequenceUtils.indexOf(seq, searchChar, 0); |
| } |
| |
| /** |
| * |
| * Returns the index within {@code seq} of the first occurrence of the |
| * specified character, starting the search at the specified index. |
| * <p> |
| * If a character with value {@code searchChar} occurs in the |
| * character sequence represented by the {@code seq} {@link CharSequence} |
| * object at an index no smaller than {@code startPos}, then |
| * the index of the first such occurrence is returned. For values |
| * of {@code searchChar} in the range from 0 to 0xFFFF (inclusive), |
| * this is the smallest value <i>k</i> such that: |
| * <blockquote><pre> |
| * (this.charAt(<i>k</i>) == searchChar) && (<i>k</i> >= startPos) |
| * </pre></blockquote> |
| * is true. For other values of {@code searchChar}, it is the |
| * smallest value <i>k</i> such that: |
| * <blockquote><pre> |
| * (this.codePointAt(<i>k</i>) == searchChar) && (<i>k</i> >= startPos) |
| * </pre></blockquote> |
| * is true. In either case, if no such character occurs in {@code seq} |
| * at or after position {@code startPos}, then |
| * {@code -1} is returned. |
| * |
| * <p> |
| * There is no restriction on the value of {@code startPos}. If it |
| * is negative, it has the same effect as if it were zero: this entire |
| * string may be searched. If it is greater than the length of this |
| * string, it has the same effect as if it were equal to the length of |
| * this string: {@code (INDEX_NOT_FOUND) -1} is returned. Furthermore, a |
| * {@code null} or empty ("") CharSequence will |
| * return {@code (INDEX_NOT_FOUND) -1}. |
| * |
| * <p>All indices are specified in {@code char} values |
| * (Unicode code units). |
| * |
| * <pre> |
| * StringUtils.indexOf(null, *, *) = -1 |
| * StringUtils.indexOf("", *, *) = -1 |
| * StringUtils.indexOf("aabaabaa", 'b', 0) = 2 |
| * StringUtils.indexOf("aabaabaa", 'b', 3) = 5 |
| * StringUtils.indexOf("aabaabaa", 'b', 9) = -1 |
| * StringUtils.indexOf("aabaabaa", 'b', -1) = 2 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchChar the character to find |
| * @param startPos the start position, negative treated as zero |
| * @return the first index of the search character (always ≥ startPos), |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOf(String, int, int) to indexOf(CharSequence, int, int) |
| * @since 3.6 Updated {@link CharSequenceUtils} call to behave more like {@link String} |
| */ |
| public static int indexOf(final CharSequence seq, final int searchChar, final int startPos) { |
| if (isEmpty(seq)) { |
| return INDEX_NOT_FOUND; |
| } |
| return CharSequenceUtils.indexOf(seq, searchChar, startPos); |
| } |
| |
| /** |
| * <p>Search a CharSequence to find the first index of any |
| * character in the given set of characters.</p> |
| * |
| * <p>A {@code null} String will return {@code -1}. |
| * A {@code null} or zero length search array will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.indexOfAny(null, *) = -1 |
| * StringUtils.indexOfAny("", *) = -1 |
| * StringUtils.indexOfAny(*, null) = -1 |
| * StringUtils.indexOfAny(*, []) = -1 |
| * StringUtils.indexOfAny("zzabyycdxx", ['z', 'a']) = 0 |
| * StringUtils.indexOfAny("zzabyycdxx", ['b', 'y']) = 3 |
| * StringUtils.indexOfAny("aba", ['z']) = -1 |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @param searchChars the chars to search for, may be null |
| * @return the index of any of the chars, -1 if no match or null input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOfAny(String, char[]) to indexOfAny(CharSequence, char...) |
| */ |
| public static int indexOfAny(final CharSequence cs, final char... searchChars) { |
| if (isEmpty(cs) || ArrayUtils.isEmpty(searchChars)) { |
| return INDEX_NOT_FOUND; |
| } |
| final int csLen = cs.length(); |
| final int csLast = csLen - 1; |
| final int searchLen = searchChars.length; |
| final int searchLast = searchLen - 1; |
| for (int i = 0; i < csLen; i++) { |
| final char ch = cs.charAt(i); |
| for (int j = 0; j < searchLen; j++) { |
| if (searchChars[j] == ch) { |
| if ((i >= csLast) || (j >= searchLast) || !Character.isHighSurrogate(ch)) { |
| return i; |
| } |
| // ch is a supplementary character |
| if (searchChars[j + 1] == cs.charAt(i + 1)) { |
| return i; |
| } |
| } |
| } |
| } |
| return INDEX_NOT_FOUND; |
| } |
| |
| /** |
| * <p>Find the first index of any of a set of potential substrings.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A {@code null} or zero length search array will return {@code -1}. |
| * A {@code null} search array entry will be ignored, but a search |
| * array containing "" will return {@code 0} if {@code str} is not |
| * null. This method uses {@link String#indexOf(String)} if possible.</p> |
| * |
| * <pre> |
| * StringUtils.indexOfAny(null, *) = -1 |
| * StringUtils.indexOfAny(*, null) = -1 |
| * StringUtils.indexOfAny(*, []) = -1 |
| * StringUtils.indexOfAny("zzabyycdxx", ["ab", "cd"]) = 2 |
| * StringUtils.indexOfAny("zzabyycdxx", ["cd", "ab"]) = 2 |
| * StringUtils.indexOfAny("zzabyycdxx", ["mn", "op"]) = -1 |
| * StringUtils.indexOfAny("zzabyycdxx", ["zab", "aby"]) = 1 |
| * StringUtils.indexOfAny("zzabyycdxx", [""]) = 0 |
| * StringUtils.indexOfAny("", [""]) = 0 |
| * StringUtils.indexOfAny("", ["a"]) = -1 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStrs the CharSequences to search for, may be null |
| * @return the first index of any of the searchStrs in str, -1 if no match |
| * @since 3.0 Changed signature from indexOfAny(String, String[]) to indexOfAny(CharSequence, CharSequence...) |
| */ |
| public static int indexOfAny(final CharSequence str, final CharSequence... searchStrs) { |
| if (str == null || searchStrs == null) { |
| return INDEX_NOT_FOUND; |
| } |
| |
| // String's can't have a MAX_VALUEth index. |
| int ret = Integer.MAX_VALUE; |
| |
| int tmp; |
| for (final CharSequence search : searchStrs) { |
| if (search == null) { |
| continue; |
| } |
| tmp = CharSequenceUtils.indexOf(str, search, 0); |
| if (tmp == INDEX_NOT_FOUND) { |
| continue; |
| } |
| |
| if (tmp < ret) { |
| ret = tmp; |
| } |
| } |
| |
| return ret == Integer.MAX_VALUE ? INDEX_NOT_FOUND : ret; |
| } |
| |
| /** |
| * <p>Search a CharSequence to find the first index of any |
| * character in the given set of characters.</p> |
| * |
| * <p>A {@code null} String will return {@code -1}. |
| * A {@code null} search string will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.indexOfAny(null, *) = -1 |
| * StringUtils.indexOfAny("", *) = -1 |
| * StringUtils.indexOfAny(*, null) = -1 |
| * StringUtils.indexOfAny(*, "") = -1 |
| * StringUtils.indexOfAny("zzabyycdxx", "za") = 0 |
| * StringUtils.indexOfAny("zzabyycdxx", "by") = 3 |
| * StringUtils.indexOfAny("aba", "z") = -1 |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @param searchChars the chars to search for, may be null |
| * @return the index of any of the chars, -1 if no match or null input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOfAny(String, String) to indexOfAny(CharSequence, String) |
| */ |
| public static int indexOfAny(final CharSequence cs, final String searchChars) { |
| if (isEmpty(cs) || isEmpty(searchChars)) { |
| return INDEX_NOT_FOUND; |
| } |
| return indexOfAny(cs, searchChars.toCharArray()); |
| } |
| |
| /** |
| * <p>Searches a CharSequence to find the first index of any |
| * character not in the given set of characters.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A {@code null} or zero length search array will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.indexOfAnyBut(null, *) = -1 |
| * StringUtils.indexOfAnyBut("", *) = -1 |
| * StringUtils.indexOfAnyBut(*, null) = -1 |
| * StringUtils.indexOfAnyBut(*, []) = -1 |
| * StringUtils.indexOfAnyBut("zzabyycdxx", new char[] {'z', 'a'} ) = 3 |
| * StringUtils.indexOfAnyBut("aba", new char[] {'z'} ) = 0 |
| * StringUtils.indexOfAnyBut("aba", new char[] {'a', 'b'} ) = -1 |
| |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @param searchChars the chars to search for, may be null |
| * @return the index of any of the chars, -1 if no match or null input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOfAnyBut(String, char[]) to indexOfAnyBut(CharSequence, char...) |
| */ |
| public static int indexOfAnyBut(final CharSequence cs, final char... searchChars) { |
| if (isEmpty(cs) || ArrayUtils.isEmpty(searchChars)) { |
| return INDEX_NOT_FOUND; |
| } |
| final int csLen = cs.length(); |
| final int csLast = csLen - 1; |
| final int searchLen = searchChars.length; |
| final int searchLast = searchLen - 1; |
| outer: |
| for (int i = 0; i < csLen; i++) { |
| final char ch = cs.charAt(i); |
| for (int j = 0; j < searchLen; j++) { |
| if (searchChars[j] == ch) { |
| if ((i >= csLast) || (j >= searchLast) || !Character.isHighSurrogate(ch)) { |
| continue outer; |
| } |
| if (searchChars[j + 1] == cs.charAt(i + 1)) { |
| continue outer; |
| } |
| } |
| } |
| return i; |
| } |
| return INDEX_NOT_FOUND; |
| } |
| |
| /** |
| * <p>Search a CharSequence to find the first index of any |
| * character not in the given set of characters.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A {@code null} or empty search string will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.indexOfAnyBut(null, *) = -1 |
| * StringUtils.indexOfAnyBut("", *) = -1 |
| * StringUtils.indexOfAnyBut(*, null) = -1 |
| * StringUtils.indexOfAnyBut(*, "") = -1 |
| * StringUtils.indexOfAnyBut("zzabyycdxx", "za") = 3 |
| * StringUtils.indexOfAnyBut("zzabyycdxx", "") = -1 |
| * StringUtils.indexOfAnyBut("aba", "ab") = -1 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchChars the chars to search for, may be null |
| * @return the index of any of the chars, -1 if no match or null input |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOfAnyBut(String, String) to indexOfAnyBut(CharSequence, CharSequence) |
| */ |
| public static int indexOfAnyBut(final CharSequence seq, final CharSequence searchChars) { |
| if (isEmpty(seq) || isEmpty(searchChars)) { |
| return INDEX_NOT_FOUND; |
| } |
| final int strLen = seq.length(); |
| for (int i = 0; i < strLen; i++) { |
| final char ch = seq.charAt(i); |
| final boolean chFound = CharSequenceUtils.indexOf(searchChars, ch, 0) >= 0; |
| if (i + 1 < strLen && Character.isHighSurrogate(ch)) { |
| final char ch2 = seq.charAt(i + 1); |
| if (chFound && CharSequenceUtils.indexOf(searchChars, ch2, 0) < 0) { |
| return i; |
| } |
| } else if (!chFound) { |
| return i; |
| } |
| } |
| return INDEX_NOT_FOUND; |
| } |
| |
| /** |
| * <p>Compares all CharSequences in an array and returns the index at which the |
| * CharSequences begin to differ.</p> |
| * |
| * <p>For example, |
| * {@code indexOfDifference(new String[] {"i am a machine", "i am a robot"}) -> 7}</p> |
| * |
| * <pre> |
| * StringUtils.indexOfDifference(null) = -1 |
| * StringUtils.indexOfDifference(new String[] {}) = -1 |
| * StringUtils.indexOfDifference(new String[] {"abc"}) = -1 |
| * StringUtils.indexOfDifference(new String[] {null, null}) = -1 |
| * StringUtils.indexOfDifference(new String[] {"", ""}) = -1 |
| * StringUtils.indexOfDifference(new String[] {"", null}) = 0 |
| * StringUtils.indexOfDifference(new String[] {"abc", null, null}) = 0 |
| * StringUtils.indexOfDifference(new String[] {null, null, "abc"}) = 0 |
| * StringUtils.indexOfDifference(new String[] {"", "abc"}) = 0 |
| * StringUtils.indexOfDifference(new String[] {"abc", ""}) = 0 |
| * StringUtils.indexOfDifference(new String[] {"abc", "abc"}) = -1 |
| * StringUtils.indexOfDifference(new String[] {"abc", "a"}) = 1 |
| * StringUtils.indexOfDifference(new String[] {"ab", "abxyz"}) = 2 |
| * StringUtils.indexOfDifference(new String[] {"abcde", "abxyz"}) = 2 |
| * StringUtils.indexOfDifference(new String[] {"abcde", "xyz"}) = 0 |
| * StringUtils.indexOfDifference(new String[] {"xyz", "abcde"}) = 0 |
| * StringUtils.indexOfDifference(new String[] {"i am a machine", "i am a robot"}) = 7 |
| * </pre> |
| * |
| * @param css array of CharSequences, entries may be null |
| * @return the index where the strings begin to differ; -1 if they are all equal |
| * @since 2.4 |
| * @since 3.0 Changed signature from indexOfDifference(String...) to indexOfDifference(CharSequence...) |
| */ |
| public static int indexOfDifference(final CharSequence... css) { |
| if (ArrayUtils.getLength(css) <= 1) { |
| return INDEX_NOT_FOUND; |
| } |
| boolean anyStringNull = false; |
| boolean allStringsNull = true; |
| final int arrayLen = css.length; |
| int shortestStrLen = Integer.MAX_VALUE; |
| int longestStrLen = 0; |
| |
| // find the min and max string lengths; this avoids checking to make |
| // sure we are not exceeding the length of the string each time through |
| // the bottom loop. |
| for (final CharSequence cs : css) { |
| if (cs == null) { |
| anyStringNull = true; |
| shortestStrLen = 0; |
| } else { |
| allStringsNull = false; |
| shortestStrLen = Math.min(cs.length(), shortestStrLen); |
| longestStrLen = Math.max(cs.length(), longestStrLen); |
| } |
| } |
| |
| // handle lists containing all nulls or all empty strings |
| if (allStringsNull || longestStrLen == 0 && !anyStringNull) { |
| return INDEX_NOT_FOUND; |
| } |
| |
| // handle lists containing some nulls or some empty strings |
| if (shortestStrLen == 0) { |
| return 0; |
| } |
| |
| // find the position with the first difference across all strings |
| int firstDiff = -1; |
| for (int stringPos = 0; stringPos < shortestStrLen; stringPos++) { |
| final char comparisonChar = css[0].charAt(stringPos); |
| for (int arrayPos = 1; arrayPos < arrayLen; arrayPos++) { |
| if (css[arrayPos].charAt(stringPos) != comparisonChar) { |
| firstDiff = stringPos; |
| break; |
| } |
| } |
| if (firstDiff != -1) { |
| break; |
| } |
| } |
| |
| if (firstDiff == -1 && shortestStrLen != longestStrLen) { |
| // we compared all of the characters up to the length of the |
| // shortest string and didn't find a match, but the string lengths |
| // vary, so return the length of the shortest string. |
| return shortestStrLen; |
| } |
| return firstDiff; |
| } |
| |
| /** |
| * <p>Compares two CharSequences, and returns the index at which the |
| * CharSequences begin to differ.</p> |
| * |
| * <p>For example, |
| * {@code indexOfDifference("i am a machine", "i am a robot") -> 7}</p> |
| * |
| * <pre> |
| * StringUtils.indexOfDifference(null, null) = -1 |
| * StringUtils.indexOfDifference("", "") = -1 |
| * StringUtils.indexOfDifference("", "abc") = 0 |
| * StringUtils.indexOfDifference("abc", "") = 0 |
| * StringUtils.indexOfDifference("abc", "abc") = -1 |
| * StringUtils.indexOfDifference("ab", "abxyz") = 2 |
| * StringUtils.indexOfDifference("abcde", "abxyz") = 2 |
| * StringUtils.indexOfDifference("abcde", "xyz") = 0 |
| * </pre> |
| * |
| * @param cs1 the first CharSequence, may be null |
| * @param cs2 the second CharSequence, may be null |
| * @return the index where cs1 and cs2 begin to differ; -1 if they are equal |
| * @since 2.0 |
| * @since 3.0 Changed signature from indexOfDifference(String, String) to |
| * indexOfDifference(CharSequence, CharSequence) |
| */ |
| public static int indexOfDifference(final CharSequence cs1, final CharSequence cs2) { |
| if (cs1 == cs2) { |
| return INDEX_NOT_FOUND; |
| } |
| if (cs1 == null || cs2 == null) { |
| return 0; |
| } |
| int i; |
| for (i = 0; i < cs1.length() && i < cs2.length(); ++i) { |
| if (cs1.charAt(i) != cs2.charAt(i)) { |
| break; |
| } |
| } |
| if (i < cs2.length() || i < cs1.length()) { |
| return i; |
| } |
| return INDEX_NOT_FOUND; |
| } |
| |
| /** |
| * <p>Case in-sensitive find of the first index within a CharSequence.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A negative start position is treated as zero. |
| * An empty ("") search CharSequence always matches. |
| * A start position greater than the string length only matches |
| * an empty search CharSequence.</p> |
| * |
| * <pre> |
| * StringUtils.indexOfIgnoreCase(null, *) = -1 |
| * StringUtils.indexOfIgnoreCase(*, null) = -1 |
| * StringUtils.indexOfIgnoreCase("", "") = 0 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "a") = 0 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "b") = 2 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "ab") = 1 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @return the first index of the search CharSequence, |
| * -1 if no match or {@code null} string input |
| * @since 2.5 |
| * @since 3.0 Changed signature from indexOfIgnoreCase(String, String) to indexOfIgnoreCase(CharSequence, CharSequence) |
| */ |
| public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr) { |
| return indexOfIgnoreCase(str, searchStr, 0); |
| } |
| |
| /** |
| * <p>Case in-sensitive find of the first index within a CharSequence |
| * from the specified position.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A negative start position is treated as zero. |
| * An empty ("") search CharSequence always matches. |
| * A start position greater than the string length only matches |
| * an empty search CharSequence.</p> |
| * |
| * <pre> |
| * StringUtils.indexOfIgnoreCase(null, *, *) = -1 |
| * StringUtils.indexOfIgnoreCase(*, null, *) = -1 |
| * StringUtils.indexOfIgnoreCase("", "", 0) = 0 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "A", 0) = 0 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "B", 0) = 2 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "B", 3) = 5 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "B", 9) = -1 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "B", -1) = 2 |
| * StringUtils.indexOfIgnoreCase("aabaabaa", "", 2) = 2 |
| * StringUtils.indexOfIgnoreCase("abc", "", 9) = -1 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @param startPos the start position, negative treated as zero |
| * @return the first index of the search CharSequence (always ≥ startPos), |
| * -1 if no match or {@code null} string input |
| * @since 2.5 |
| * @since 3.0 Changed signature from indexOfIgnoreCase(String, String, int) to indexOfIgnoreCase(CharSequence, CharSequence, int) |
| */ |
| public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int startPos) { |
| if (str == null || searchStr == null) { |
| return INDEX_NOT_FOUND; |
| } |
| if (startPos < 0) { |
| startPos = 0; |
| } |
| final int endLimit = str.length() - searchStr.length() + 1; |
| if (startPos > endLimit) { |
| return INDEX_NOT_FOUND; |
| } |
| if (searchStr.length() == 0) { |
| return startPos; |
| } |
| for (int i = startPos; i < endLimit; i++) { |
| if (CharSequenceUtils.regionMatches(str, true, i, searchStr, 0, searchStr.length())) { |
| return i; |
| } |
| } |
| return INDEX_NOT_FOUND; |
| } |
| |
| /** |
| * <p>Checks if all of the CharSequences are empty (""), null or whitespace only.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.isAllBlank(null) = true |
| * StringUtils.isAllBlank(null, "foo") = false |
| * StringUtils.isAllBlank(null, null) = true |
| * StringUtils.isAllBlank("", "bar") = false |
| * StringUtils.isAllBlank("bob", "") = false |
| * StringUtils.isAllBlank(" bob ", null) = false |
| * StringUtils.isAllBlank(" ", "bar") = false |
| * StringUtils.isAllBlank("foo", "bar") = false |
| * StringUtils.isAllBlank(new String[] {}) = true |
| * </pre> |
| * |
| * @param css the CharSequences to check, may be null or empty |
| * @return {@code true} if all of the CharSequences are empty or null or whitespace only |
| * @since 3.6 |
| */ |
| public static boolean isAllBlank(final CharSequence... css) { |
| if (ArrayUtils.isEmpty(css)) { |
| return true; |
| } |
| for (final CharSequence cs : css) { |
| if (isNotBlank(cs)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if all of the CharSequences are empty ("") or null.</p> |
| * |
| * <pre> |
| * StringUtils.isAllEmpty(null) = true |
| * StringUtils.isAllEmpty(null, "") = true |
| * StringUtils.isAllEmpty(new String[] {}) = true |
| * StringUtils.isAllEmpty(null, "foo") = false |
| * StringUtils.isAllEmpty("", "bar") = false |
| * StringUtils.isAllEmpty("bob", "") = false |
| * StringUtils.isAllEmpty(" bob ", null) = false |
| * StringUtils.isAllEmpty(" ", "bar") = false |
| * StringUtils.isAllEmpty("foo", "bar") = false |
| * </pre> |
| * |
| * @param css the CharSequences to check, may be null or empty |
| * @return {@code true} if all of the CharSequences are empty or null |
| * @since 3.6 |
| */ |
| public static boolean isAllEmpty(final CharSequence... css) { |
| if (ArrayUtils.isEmpty(css)) { |
| return true; |
| } |
| for (final CharSequence cs : css) { |
| if (isNotEmpty(cs)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only lowercase characters.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.isAllLowerCase(null) = false |
| * StringUtils.isAllLowerCase("") = false |
| * StringUtils.isAllLowerCase(" ") = false |
| * StringUtils.isAllLowerCase("abc") = true |
| * StringUtils.isAllLowerCase("abC") = false |
| * StringUtils.isAllLowerCase("ab c") = false |
| * StringUtils.isAllLowerCase("ab1c") = false |
| * StringUtils.isAllLowerCase("ab/c") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains lowercase characters, and is non-null |
| * @since 2.5 |
| * @since 3.0 Changed signature from isAllLowerCase(String) to isAllLowerCase(CharSequence) |
| */ |
| public static boolean isAllLowerCase(final CharSequence cs) { |
| if (isEmpty(cs)) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (!Character.isLowerCase(cs.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only uppercase characters.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty String (length()=0) will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.isAllUpperCase(null) = false |
| * StringUtils.isAllUpperCase("") = false |
| * StringUtils.isAllUpperCase(" ") = false |
| * StringUtils.isAllUpperCase("ABC") = true |
| * StringUtils.isAllUpperCase("aBC") = false |
| * StringUtils.isAllUpperCase("A C") = false |
| * StringUtils.isAllUpperCase("A1C") = false |
| * StringUtils.isAllUpperCase("A/C") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains uppercase characters, and is non-null |
| * @since 2.5 |
| * @since 3.0 Changed signature from isAllUpperCase(String) to isAllUpperCase(CharSequence) |
| */ |
| public static boolean isAllUpperCase(final CharSequence cs) { |
| if (isEmpty(cs)) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (!Character.isUpperCase(cs.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only Unicode letters.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.isAlpha(null) = false |
| * StringUtils.isAlpha("") = false |
| * StringUtils.isAlpha(" ") = false |
| * StringUtils.isAlpha("abc") = true |
| * StringUtils.isAlpha("ab2c") = false |
| * StringUtils.isAlpha("ab-c") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains letters, and is non-null |
| * @since 3.0 Changed signature from isAlpha(String) to isAlpha(CharSequence) |
| * @since 3.0 Changed "" to return false and not true |
| */ |
| public static boolean isAlpha(final CharSequence cs) { |
| if (isEmpty(cs)) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (!Character.isLetter(cs.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only Unicode letters or digits.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.isAlphanumeric(null) = false |
| * StringUtils.isAlphanumeric("") = false |
| * StringUtils.isAlphanumeric(" ") = false |
| * StringUtils.isAlphanumeric("abc") = true |
| * StringUtils.isAlphanumeric("ab c") = false |
| * StringUtils.isAlphanumeric("ab2c") = true |
| * StringUtils.isAlphanumeric("ab-c") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains letters or digits, |
| * and is non-null |
| * @since 3.0 Changed signature from isAlphanumeric(String) to isAlphanumeric(CharSequence) |
| * @since 3.0 Changed "" to return false and not true |
| */ |
| public static boolean isAlphanumeric(final CharSequence cs) { |
| if (isEmpty(cs)) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (!Character.isLetterOrDigit(cs.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only Unicode letters, digits |
| * or space ({@code ' '}).</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code true}.</p> |
| * |
| * <pre> |
| * StringUtils.isAlphanumericSpace(null) = false |
| * StringUtils.isAlphanumericSpace("") = true |
| * StringUtils.isAlphanumericSpace(" ") = true |
| * StringUtils.isAlphanumericSpace("abc") = true |
| * StringUtils.isAlphanumericSpace("ab c") = true |
| * StringUtils.isAlphanumericSpace("ab2c") = true |
| * StringUtils.isAlphanumericSpace("ab-c") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains letters, digits or space, |
| * and is non-null |
| * @since 3.0 Changed signature from isAlphanumericSpace(String) to isAlphanumericSpace(CharSequence) |
| */ |
| public static boolean isAlphanumericSpace(final CharSequence cs) { |
| if (cs == null) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| final char nowChar = cs.charAt(i); |
| if (nowChar != ' ' && !Character.isLetterOrDigit(nowChar) ) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only Unicode letters and |
| * space (' ').</p> |
| * |
| * <p>{@code null} will return {@code false} |
| * An empty CharSequence (length()=0) will return {@code true}.</p> |
| * |
| * <pre> |
| * StringUtils.isAlphaSpace(null) = false |
| * StringUtils.isAlphaSpace("") = true |
| * StringUtils.isAlphaSpace(" ") = true |
| * StringUtils.isAlphaSpace("abc") = true |
| * StringUtils.isAlphaSpace("ab c") = true |
| * StringUtils.isAlphaSpace("ab2c") = false |
| * StringUtils.isAlphaSpace("ab-c") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains letters and space, |
| * and is non-null |
| * @since 3.0 Changed signature from isAlphaSpace(String) to isAlphaSpace(CharSequence) |
| */ |
| public static boolean isAlphaSpace(final CharSequence cs) { |
| if (cs == null) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| final char nowChar = cs.charAt(i); |
| if (nowChar != ' ' && !Character.isLetter(nowChar)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if any of the CharSequences are empty ("") or null or whitespace only.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.isAnyBlank((String) null) = true |
| * StringUtils.isAnyBlank((String[]) null) = false |
| * StringUtils.isAnyBlank(null, "foo") = true |
| * StringUtils.isAnyBlank(null, null) = true |
| * StringUtils.isAnyBlank("", "bar") = true |
| * StringUtils.isAnyBlank("bob", "") = true |
| * StringUtils.isAnyBlank(" bob ", null) = true |
| * StringUtils.isAnyBlank(" ", "bar") = true |
| * StringUtils.isAnyBlank(new String[] {}) = false |
| * StringUtils.isAnyBlank(new String[]{""}) = true |
| * StringUtils.isAnyBlank("foo", "bar") = false |
| * </pre> |
| * |
| * @param css the CharSequences to check, may be null or empty |
| * @return {@code true} if any of the CharSequences are empty or null or whitespace only |
| * @since 3.2 |
| */ |
| public static boolean isAnyBlank(final CharSequence... css) { |
| if (ArrayUtils.isEmpty(css)) { |
| return false; |
| } |
| for (final CharSequence cs : css) { |
| if (isBlank(cs)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p>Checks if any of the CharSequences are empty ("") or null.</p> |
| * |
| * <pre> |
| * StringUtils.isAnyEmpty((String) null) = true |
| * StringUtils.isAnyEmpty((String[]) null) = false |
| * StringUtils.isAnyEmpty(null, "foo") = true |
| * StringUtils.isAnyEmpty("", "bar") = true |
| * StringUtils.isAnyEmpty("bob", "") = true |
| * StringUtils.isAnyEmpty(" bob ", null) = true |
| * StringUtils.isAnyEmpty(" ", "bar") = false |
| * StringUtils.isAnyEmpty("foo", "bar") = false |
| * StringUtils.isAnyEmpty(new String[]{}) = false |
| * StringUtils.isAnyEmpty(new String[]{""}) = true |
| * </pre> |
| * |
| * @param css the CharSequences to check, may be null or empty |
| * @return {@code true} if any of the CharSequences are empty or null |
| * @since 3.2 |
| */ |
| public static boolean isAnyEmpty(final CharSequence... css) { |
| if (ArrayUtils.isEmpty(css)) { |
| return false; |
| } |
| for (final CharSequence cs : css) { |
| if (isEmpty(cs)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only ASCII printable characters.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code true}.</p> |
| * |
| * <pre> |
| * StringUtils.isAsciiPrintable(null) = false |
| * StringUtils.isAsciiPrintable("") = true |
| * StringUtils.isAsciiPrintable(" ") = true |
| * StringUtils.isAsciiPrintable("Ceki") = true |
| * StringUtils.isAsciiPrintable("ab2c") = true |
| * StringUtils.isAsciiPrintable("!ab-c~") = true |
| * StringUtils.isAsciiPrintable("\u0020") = true |
| * StringUtils.isAsciiPrintable("\u0021") = true |
| * StringUtils.isAsciiPrintable("\u007e") = true |
| * StringUtils.isAsciiPrintable("\u007f") = false |
| * StringUtils.isAsciiPrintable("Ceki G\u00fclc\u00fc") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if every character is in the range |
| * 32 through 126 |
| * @since 2.1 |
| * @since 3.0 Changed signature from isAsciiPrintable(String) to isAsciiPrintable(CharSequence) |
| */ |
| public static boolean isAsciiPrintable(final CharSequence cs) { |
| if (cs == null) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (!CharUtils.isAsciiPrintable(cs.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if a CharSequence is empty (""), null or whitespace only.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.isBlank(null) = true |
| * StringUtils.isBlank("") = true |
| * StringUtils.isBlank(" ") = true |
| * StringUtils.isBlank("bob") = false |
| * StringUtils.isBlank(" bob ") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if the CharSequence is null, empty or whitespace only |
| * @since 2.0 |
| * @since 3.0 Changed signature from isBlank(String) to isBlank(CharSequence) |
| */ |
| 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; |
| } |
| |
| /** |
| * <p>Checks if a CharSequence is empty ("") or null.</p> |
| * |
| * <pre> |
| * StringUtils.isEmpty(null) = true |
| * StringUtils.isEmpty("") = true |
| * StringUtils.isEmpty(" ") = false |
| * StringUtils.isEmpty("bob") = false |
| * StringUtils.isEmpty(" bob ") = false |
| * </pre> |
| * |
| * <p>NOTE: This method changed in Lang version 2.0. |
| * It no longer trims the CharSequence. |
| * That functionality is available in isBlank().</p> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if the CharSequence is empty or null |
| * @since 3.0 Changed signature from isEmpty(String) to isEmpty(CharSequence) |
| */ |
| public static boolean isEmpty(final CharSequence cs) { |
| return cs == null || cs.length() == 0; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains mixed casing of both uppercase and lowercase characters.</p> |
| * |
| * <p>{@code null} will return {@code false}. An empty CharSequence ({@code length()=0}) will return |
| * {@code false}.</p> |
| * |
| * <pre> |
| * StringUtils.isMixedCase(null) = false |
| * StringUtils.isMixedCase("") = false |
| * StringUtils.isMixedCase("ABC") = false |
| * StringUtils.isMixedCase("abc") = false |
| * StringUtils.isMixedCase("aBc") = true |
| * StringUtils.isMixedCase("A c") = true |
| * StringUtils.isMixedCase("A1c") = true |
| * StringUtils.isMixedCase("a/C") = true |
| * StringUtils.isMixedCase("aC\t") = true |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if the CharSequence contains both uppercase and lowercase characters |
| * @since 3.5 |
| */ |
| public static boolean isMixedCase(final CharSequence cs) { |
| if (isEmpty(cs) || cs.length() == 1) { |
| return false; |
| } |
| boolean containsUppercase = false; |
| boolean containsLowercase = false; |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (containsUppercase && containsLowercase) { |
| return true; |
| } |
| if (Character.isUpperCase(cs.charAt(i))) { |
| containsUppercase = true; |
| } else if (Character.isLowerCase(cs.charAt(i))) { |
| containsLowercase = true; |
| } |
| } |
| return containsUppercase && containsLowercase; |
| } |
| |
| /** |
| * <p>Checks if none of the CharSequences are empty (""), null or whitespace only.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.isNoneBlank((String) null) = false |
| * StringUtils.isNoneBlank((String[]) null) = true |
| * StringUtils.isNoneBlank(null, "foo") = false |
| * StringUtils.isNoneBlank(null, null) = false |
| * StringUtils.isNoneBlank("", "bar") = false |
| * StringUtils.isNoneBlank("bob", "") = false |
| * StringUtils.isNoneBlank(" bob ", null) = false |
| * StringUtils.isNoneBlank(" ", "bar") = false |
| * StringUtils.isNoneBlank(new String[] {}) = true |
| * StringUtils.isNoneBlank(new String[]{""}) = false |
| * StringUtils.isNoneBlank("foo", "bar") = true |
| * </pre> |
| * |
| * @param css the CharSequences to check, may be null or empty |
| * @return {@code true} if none of the CharSequences are empty or null or whitespace only |
| * @since 3.2 |
| */ |
| public static boolean isNoneBlank(final CharSequence... css) { |
| return !isAnyBlank(css); |
| } |
| |
| /** |
| * <p>Checks if none of the CharSequences are empty ("") or null.</p> |
| * |
| * <pre> |
| * StringUtils.isNoneEmpty((String) null) = false |
| * StringUtils.isNoneEmpty((String[]) null) = true |
| * StringUtils.isNoneEmpty(null, "foo") = false |
| * StringUtils.isNoneEmpty("", "bar") = false |
| * StringUtils.isNoneEmpty("bob", "") = false |
| * StringUtils.isNoneEmpty(" bob ", null) = false |
| * StringUtils.isNoneEmpty(new String[] {}) = true |
| * StringUtils.isNoneEmpty(new String[]{""}) = false |
| * StringUtils.isNoneEmpty(" ", "bar") = true |
| * StringUtils.isNoneEmpty("foo", "bar") = true |
| * </pre> |
| * |
| * @param css the CharSequences to check, may be null or empty |
| * @return {@code true} if none of the CharSequences are empty or null |
| * @since 3.2 |
| */ |
| public static boolean isNoneEmpty(final CharSequence... css) { |
| return !isAnyEmpty(css); |
| } |
| |
| /** |
| * <p>Checks if a CharSequence is not empty (""), not null and not whitespace only.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.isNotBlank(null) = false |
| * StringUtils.isNotBlank("") = false |
| * StringUtils.isNotBlank(" ") = false |
| * StringUtils.isNotBlank("bob") = true |
| * StringUtils.isNotBlank(" bob ") = true |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if the CharSequence is |
| * not empty and not null and not whitespace only |
| * @since 2.0 |
| * @since 3.0 Changed signature from isNotBlank(String) to isNotBlank(CharSequence) |
| */ |
| public static boolean isNotBlank(final CharSequence cs) { |
| return !isBlank(cs); |
| } |
| |
| /** |
| * <p>Checks if a CharSequence is not empty ("") and not null.</p> |
| * |
| * <pre> |
| * StringUtils.isNotEmpty(null) = false |
| * StringUtils.isNotEmpty("") = false |
| * StringUtils.isNotEmpty(" ") = true |
| * StringUtils.isNotEmpty("bob") = true |
| * StringUtils.isNotEmpty(" bob ") = true |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if the CharSequence is not empty and not null |
| * @since 3.0 Changed signature from isNotEmpty(String) to isNotEmpty(CharSequence) |
| */ |
| public static boolean isNotEmpty(final CharSequence cs) { |
| return !isEmpty(cs); |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only Unicode digits. |
| * A decimal point is not a Unicode digit and returns false.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code false}.</p> |
| * |
| * <p>Note that the method does not allow for a leading sign, either positive or negative. |
| * Also, if a String passes the numeric test, it may still generate a NumberFormatException |
| * when parsed by Integer.parseInt or Long.parseLong, e.g. if the value is outside the range |
| * for int or long respectively.</p> |
| * |
| * <pre> |
| * StringUtils.isNumeric(null) = false |
| * StringUtils.isNumeric("") = false |
| * StringUtils.isNumeric(" ") = false |
| * StringUtils.isNumeric("123") = true |
| * StringUtils.isNumeric("\u0967\u0968\u0969") = true |
| * StringUtils.isNumeric("12 3") = false |
| * StringUtils.isNumeric("ab2c") = false |
| * StringUtils.isNumeric("12-3") = false |
| * StringUtils.isNumeric("12.3") = false |
| * StringUtils.isNumeric("-123") = false |
| * StringUtils.isNumeric("+123") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains digits, and is non-null |
| * @since 3.0 Changed signature from isNumeric(String) to isNumeric(CharSequence) |
| * @since 3.0 Changed "" to return false and not true |
| */ |
| public static boolean isNumeric(final CharSequence cs) { |
| if (isEmpty(cs)) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (!Character.isDigit(cs.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only Unicode digits or space |
| * ({@code ' '}). |
| * A decimal point is not a Unicode digit and returns false.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code true}.</p> |
| * |
| * <pre> |
| * StringUtils.isNumericSpace(null) = false |
| * StringUtils.isNumericSpace("") = true |
| * StringUtils.isNumericSpace(" ") = true |
| * StringUtils.isNumericSpace("123") = true |
| * StringUtils.isNumericSpace("12 3") = true |
| * StringUtils.isNumericSpace("\u0967\u0968\u0969") = true |
| * StringUtils.isNumericSpace("\u0967\u0968 \u0969") = true |
| * StringUtils.isNumericSpace("ab2c") = false |
| * StringUtils.isNumericSpace("12-3") = false |
| * StringUtils.isNumericSpace("12.3") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains digits or space, |
| * and is non-null |
| * @since 3.0 Changed signature from isNumericSpace(String) to isNumericSpace(CharSequence) |
| */ |
| public static boolean isNumericSpace(final CharSequence cs) { |
| if (cs == null) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| final char nowChar = cs.charAt(i); |
| if (nowChar != ' ' && !Character.isDigit(nowChar)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p>Checks if the CharSequence contains only whitespace.</p> |
| * |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>{@code null} will return {@code false}. |
| * An empty CharSequence (length()=0) will return {@code true}.</p> |
| * |
| * <pre> |
| * StringUtils.isWhitespace(null) = false |
| * StringUtils.isWhitespace("") = true |
| * StringUtils.isWhitespace(" ") = true |
| * StringUtils.isWhitespace("abc") = false |
| * StringUtils.isWhitespace("ab2c") = false |
| * StringUtils.isWhitespace("ab-c") = false |
| * </pre> |
| * |
| * @param cs the CharSequence to check, may be null |
| * @return {@code true} if only contains whitespace, and is non-null |
| * @since 2.0 |
| * @since 3.0 Changed signature from isWhitespace(String) to isWhitespace(CharSequence) |
| */ |
| public static boolean isWhitespace(final CharSequence cs) { |
| if (cs == null) { |
| return false; |
| } |
| final int sz = cs.length(); |
| for (int i = 0; i < sz; i++) { |
| if (!Character.isWhitespace(cs.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([false, false], ';') = "false;false" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.12.0 |
| */ |
| public static String join(final boolean[] array, final char delimiter) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, delimiter, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([true, false, true], ';') = "true;false;true" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.12.0 |
| */ |
| public static String join(final boolean[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(array.length * 5 + array.length - 1); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final byte[] array, final char delimiter) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, delimiter, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final byte[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final char[] array, final char delimiter) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, delimiter, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final char[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(array.length * 2 - 1); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final double[] array, final char delimiter) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, delimiter, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final double[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final float[] array, final char delimiter) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, delimiter, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final float[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param separator |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final int[] array, final char separator) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, separator, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final int[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided {@link Iterable} into |
| * a single String containing the provided elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. Null objects or empty |
| * strings within the iteration are represented by empty strings.</p> |
| * |
| * <p>See the examples here: {@link #join(Object[],char)}. </p> |
| * |
| * @param iterable the {@link Iterable} providing the values to join together, may be null |
| * @param separator the separator character to use |
| * @return the joined String, {@code null} if null iterator input |
| * @since 2.3 |
| */ |
| public static String join(final Iterable<?> iterable, final char separator) { |
| return iterable != null ? join(iterable.iterator(), separator) : null; |
| } |
| |
| /** |
| * <p>Joins the elements of the provided {@link Iterable} into |
| * a single String containing the provided elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * A {@code null} separator is the same as an empty String ("").</p> |
| * |
| * <p>See the examples here: {@link #join(Object[],String)}. </p> |
| * |
| * @param iterable the {@link Iterable} providing the values to join together, may be null |
| * @param separator the separator character to use, null treated as "" |
| * @return the joined String, {@code null} if null iterator input |
| * @since 2.3 |
| */ |
| public static String join(final Iterable<?> iterable, final String separator) { |
| return iterable != null ? join(iterable.iterator(), separator) : null; |
| } |
| |
| /** |
| * <p>Joins the elements of the provided {@link Iterator} into |
| * a single String containing the provided elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. Null objects or empty |
| * strings within the iteration are represented by empty strings.</p> |
| * |
| * <p>See the examples here: {@link #join(Object[],char)}. </p> |
| * |
| * @param iterator the {@link Iterator} of values to join together, may be null |
| * @param separator the separator character to use |
| * @return the joined String, {@code null} if null iterator input |
| * @since 2.0 |
| */ |
| public static String join(final Iterator<?> iterator, final char separator) { |
| |
| // handle null, zero and one elements before building a buffer |
| if (iterator == null) { |
| return null; |
| } |
| if (!iterator.hasNext()) { |
| return EMPTY; |
| } |
| |
| // two or more elements |
| final StringBuilder buf = new StringBuilder(STRING_BUILDER_SIZE); // Java default is 16, probably too small |
| |
| while (iterator.hasNext()) { |
| final Object obj = iterator.next(); |
| if (obj != null) { |
| buf.append(obj); |
| } |
| if (iterator.hasNext()) { |
| buf.append(separator); |
| } |
| |
| } |
| |
| return buf.toString(); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided {@link Iterator} into |
| * a single String containing the provided elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * A {@code null} separator is the same as an empty String ("").</p> |
| * |
| * <p>See the examples here: {@link #join(Object[],String)}. </p> |
| * |
| * @param iterator the {@link Iterator} of values to join together, may be null |
| * @param separator the separator character to use, null treated as "" |
| * @return the joined String, {@code null} if null iterator input |
| */ |
| public static String join(final Iterator<?> iterator, final String separator) { |
| // handle null, zero and one elements before building a buffer |
| if (iterator == null) { |
| return null; |
| } |
| if (!iterator.hasNext()) { |
| return EMPTY; |
| } |
| |
| // two or more elements |
| final StringBuilder buf = new StringBuilder(STRING_BUILDER_SIZE); // Java default is 16, probably too small |
| |
| while (iterator.hasNext()) { |
| final Object obj = iterator.next(); |
| if (obj != null) { |
| buf.append(obj); |
| } |
| if (separator != null && iterator.hasNext()) { |
| buf.append(separator); |
| } |
| } |
| return buf.toString(); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided {@link List} into a single String |
| * containing the provided list of elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * Null objects or empty strings within the array are represented by |
| * empty strings.</p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join(["a", "b", "c"], ';') = "a;b;c" |
| * StringUtils.join(["a", "b", "c"], null) = "abc" |
| * StringUtils.join([null, "", "a"], ';') = ";;a" |
| * </pre> |
| * |
| * @param list the {@link List} of values to join together, may be null |
| * @param separator the separator character to use |
| * @param startIndex the first index to start joining from. It is |
| * an error to pass in a start index past the end of the list |
| * @param endIndex the index to stop joining from (exclusive). It is |
| * an error to pass in an end index past the end of the list |
| * @return the joined String, {@code null} if null list input |
| * @since 3.8 |
| */ |
| public static String join(final List<?> list, final char separator, final int startIndex, final int endIndex) { |
| if (list == null) { |
| return null; |
| } |
| final int noOfItems = endIndex - startIndex; |
| if (noOfItems <= 0) { |
| return EMPTY; |
| } |
| final List<?> subList = list.subList(startIndex, endIndex); |
| return join(subList.iterator(), separator); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided {@link List} into a single String |
| * containing the provided list of elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * Null objects or empty strings within the array are represented by |
| * empty strings.</p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join(["a", "b", "c"], ';') = "a;b;c" |
| * StringUtils.join(["a", "b", "c"], null) = "abc" |
| * StringUtils.join([null, "", "a"], ';') = ";;a" |
| * </pre> |
| * |
| * @param list the {@link List} of values to join together, may be null |
| * @param separator the separator character to use |
| * @param startIndex the first index to start joining from. It is |
| * an error to pass in a start index past the end of the list |
| * @param endIndex the index to stop joining from (exclusive). It is |
| * an error to pass in an end index past the end of the list |
| * @return the joined String, {@code null} if null list input |
| * @since 3.8 |
| */ |
| public static String join(final List<?> list, final String separator, final int startIndex, final int endIndex) { |
| if (list == null) { |
| return null; |
| } |
| final int noOfItems = endIndex - startIndex; |
| if (noOfItems <= 0) { |
| return EMPTY; |
| } |
| final List<?> subList = list.subList(startIndex, endIndex); |
| return join(subList.iterator(), separator); |
| } |
| |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param separator |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final long[] array, final char separator) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, separator, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final long[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided array into a single String |
| * containing the provided list of elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * Null objects or empty strings within the array are represented by |
| * empty strings.</p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join(["a", "b", "c"], ';') = "a;b;c" |
| * StringUtils.join(["a", "b", "c"], null) = "abc" |
| * StringUtils.join([null, "", "a"], ';') = ";;a" |
| * </pre> |
| * |
| * @param array the array of values to join together, may be null |
| * @param delimiter the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 2.0 |
| */ |
| public static String join(final Object[] array, final char delimiter) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, delimiter, 0, array.length); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided array into a single String |
| * containing the provided list of elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * Null objects or empty strings within the array are represented by |
| * empty strings.</p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join(["a", "b", "c"], ';') = "a;b;c" |
| * StringUtils.join(["a", "b", "c"], null) = "abc" |
| * StringUtils.join([null, "", "a"], ';') = ";;a" |
| * </pre> |
| * |
| * @param array the array of values to join together, may be null |
| * @param delimiter the separator character to use |
| * @param startIndex the first index to start joining from. It is |
| * an error to pass in a start index past the end of the array |
| * @param endIndex the index to stop joining from (exclusive). It is |
| * an error to pass in an end index past the end of the array |
| * @return the joined String, {@code null} if null array input |
| * @since 2.0 |
| */ |
| public static String join(final Object[] array, final char delimiter, final int startIndex, final int endIndex) { |
| return join(array, String.valueOf(delimiter), startIndex, endIndex); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided array into a single String |
| * containing the provided list of elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * A {@code null} separator is the same as an empty String (""). |
| * Null objects or empty strings within the array are represented by |
| * empty strings.</p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join(["a", "b", "c"], "--") = "a--b--c" |
| * StringUtils.join(["a", "b", "c"], null) = "abc" |
| * StringUtils.join(["a", "b", "c"], "") = "abc" |
| * StringUtils.join([null, "", "a"], ',') = ",,a" |
| * </pre> |
| * |
| * @param array the array of values to join together, may be null |
| * @param delimiter the separator character to use, null treated as "" |
| * @return the joined String, {@code null} if null array input |
| */ |
| public static String join(final Object[] array, final String delimiter) { |
| return array != null ? join(array, toStringOrEmpty(delimiter), 0, array.length) : null; |
| } |
| |
| /** |
| * <p>Joins the elements of the provided array into a single String |
| * containing the provided list of elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * A {@code null} separator is the same as an empty String (""). |
| * Null objects or empty strings within the array are represented by |
| * empty strings.</p> |
| * |
| * <pre> |
| * StringUtils.join(null, *, *, *) = null |
| * StringUtils.join([], *, *, *) = "" |
| * StringUtils.join([null], *, *, *) = "" |
| * StringUtils.join(["a", "b", "c"], "--", 0, 3) = "a--b--c" |
| * StringUtils.join(["a", "b", "c"], "--", 1, 3) = "b--c" |
| * StringUtils.join(["a", "b", "c"], "--", 2, 3) = "c" |
| * StringUtils.join(["a", "b", "c"], "--", 2, 2) = "" |
| * StringUtils.join(["a", "b", "c"], null, 0, 3) = "abc" |
| * StringUtils.join(["a", "b", "c"], "", 0, 3) = "abc" |
| * StringUtils.join([null, "", "a"], ',', 0, 3) = ",,a" |
| * </pre> |
| * |
| * @param array the array of values to join together, may be null |
| * @param delimiter the separator character to use, null treated as "" |
| * @param startIndex the first index to start joining from. |
| * @param endIndex the index to stop joining from (exclusive). |
| * @return the joined String, {@code null} if null array input; or the empty string |
| * if {@code endIndex - startIndex <= 0}. The number of joined entries is given by |
| * {@code endIndex - startIndex} |
| * @throws ArrayIndexOutOfBoundsException ife<br> |
| * {@code startIndex < 0} or <br> |
| * {@code startIndex >= array.length()} or <br> |
| * {@code endIndex < 0} or <br> |
| * {@code endIndex > array.length()} |
| */ |
| public static String join(final Object[] array, final String delimiter, final int startIndex, final int endIndex) { |
| return array != null ? Stream.of(array).skip(startIndex).limit(Math.max(0, endIndex - startIndex)) |
| .collect(LangCollectors.joining(delimiter, EMPTY, EMPTY, StringUtils::toStringOrEmpty)) : null; |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final short[] array, final char delimiter) { |
| if (array == null) { |
| return null; |
| } |
| return join(array, delimiter, 0, array.length); |
| } |
| |
| /** |
| * <p> |
| * Joins the elements of the provided array into a single String containing the provided list of elements. |
| * </p> |
| * |
| * <p> |
| * No delimiter is added before or after the list. Null objects or empty strings within the array are represented |
| * by empty strings. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.join(null, *) = null |
| * StringUtils.join([], *) = "" |
| * StringUtils.join([null], *) = "" |
| * StringUtils.join([1, 2, 3], ';') = "1;2;3" |
| * StringUtils.join([1, 2, 3], null) = "123" |
| * </pre> |
| * |
| * @param array |
| * the array of values to join together, may be null |
| * @param delimiter |
| * the separator character to use |
| * @param startIndex |
| * the first index to start joining from. It is an error to pass in a start index past the end of the |
| * array |
| * @param endIndex |
| * the index to stop joining from (exclusive). It is an error to pass in an end index past the end of |
| * the array |
| * @return the joined String, {@code null} if null array input |
| * @since 3.2 |
| */ |
| public static String join(final short[] array, final char delimiter, final int startIndex, final int endIndex) { |
| if (array == null) { |
| return null; |
| } |
| if (endIndex - startIndex <= 0) { |
| return EMPTY; |
| } |
| final StringBuilder stringBuilder = new StringBuilder(); |
| for (int i = startIndex; i < endIndex; i++) { |
| stringBuilder |
| .append(array[i]) |
| .append(delimiter); |
| } |
| return stringBuilder.substring(0, stringBuilder.length() - 1); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided array into a single String |
| * containing the provided list of elements.</p> |
| * |
| * <p>No separator is added to the joined String. |
| * Null objects or empty strings within the array are represented by |
| * empty strings.</p> |
| * |
| * <pre> |
| * StringUtils.join(null) = null |
| * StringUtils.join([]) = "" |
| * StringUtils.join([null]) = "" |
| * StringUtils.join(["a", "b", "c"]) = "abc" |
| * StringUtils.join([null, "", "a"]) = "a" |
| * </pre> |
| * |
| * @param <T> the specific type of values to join together |
| * @param elements the values to join together, may be null |
| * @return the joined String, {@code null} if null array input |
| * @since 2.0 |
| * @since 3.0 Changed signature to use varargs |
| */ |
| @SafeVarargs |
| public static <T> String join(final T... elements) { |
| return join(elements, null); |
| } |
| |
| /** |
| * <p>Joins the elements of the provided varargs into a |
| * single String containing the provided elements.</p> |
| * |
| * <p>No delimiter is added before or after the list. |
| * {@code null} elements and separator are treated as empty Strings ("").</p> |
| * |
| * <pre> |
| * StringUtils.joinWith(",", {"a", "b"}) = "a,b" |
| * StringUtils.joinWith(",", {"a", "b",""}) = "a,b," |
| * StringUtils.joinWith(",", {"a", null, "b"}) = "a,,b" |
| * StringUtils.joinWith(null, {"a", "b"}) = "ab" |
| * </pre> |
| * |
| * @param delimiter the separator character to use, null treated as "" |
| * @param array the varargs providing the values to join together. {@code null} elements are treated as "" |
| * @return the joined String. |
| * @throws IllegalArgumentException if a null varargs is provided |
| * @since 3.5 |
| */ |
| public static String joinWith(final String delimiter, final Object... array) { |
| if (array == null) { |
| throw new IllegalArgumentException("Object varargs must not be null"); |
| } |
| return join(array, delimiter); |
| } |
| |
| /** |
| * <p>Finds the last index within a CharSequence, handling {@code null}. |
| * This method uses {@link String#lastIndexOf(String)} if possible.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.lastIndexOf(null, *) = -1 |
| * StringUtils.lastIndexOf(*, null) = -1 |
| * StringUtils.lastIndexOf("", "") = 0 |
| * StringUtils.lastIndexOf("aabaabaa", "a") = 7 |
| * StringUtils.lastIndexOf("aabaabaa", "b") = 5 |
| * StringUtils.lastIndexOf("aabaabaa", "ab") = 4 |
| * StringUtils.lastIndexOf("aabaabaa", "") = 8 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchSeq the CharSequence to find, may be null |
| * @return the last index of the search String, |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from lastIndexOf(String, String) to lastIndexOf(CharSequence, CharSequence) |
| */ |
| public static int lastIndexOf(final CharSequence seq, final CharSequence searchSeq) { |
| if (seq == null) { |
| return INDEX_NOT_FOUND; |
| } |
| return CharSequenceUtils.lastIndexOf(seq, searchSeq, seq.length()); |
| } |
| |
| /** |
| * <p>Finds the last index within a CharSequence, handling {@code null}. |
| * This method uses {@link String#lastIndexOf(String, int)} if possible.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A negative start position returns {@code -1}. |
| * An empty ("") search CharSequence always matches unless the start position is negative. |
| * A start position greater than the string length searches the whole string. |
| * The search starts at the startPos and works backwards; matches starting after the start |
| * position are ignored. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.lastIndexOf(null, *, *) = -1 |
| * StringUtils.lastIndexOf(*, null, *) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", "a", 8) = 7 |
| * StringUtils.lastIndexOf("aabaabaa", "b", 8) = 5 |
| * StringUtils.lastIndexOf("aabaabaa", "ab", 8) = 4 |
| * StringUtils.lastIndexOf("aabaabaa", "b", 9) = 5 |
| * StringUtils.lastIndexOf("aabaabaa", "b", -1) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", "a", 0) = 0 |
| * StringUtils.lastIndexOf("aabaabaa", "b", 0) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", "b", 1) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", "b", 2) = 2 |
| * StringUtils.lastIndexOf("aabaabaa", "ba", 2) = 2 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchSeq the CharSequence to find, may be null |
| * @param startPos the start position, negative treated as zero |
| * @return the last index of the search CharSequence (always ≤ startPos), |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from lastIndexOf(String, String, int) to lastIndexOf(CharSequence, CharSequence, int) |
| */ |
| public static int lastIndexOf(final CharSequence seq, final CharSequence searchSeq, final int startPos) { |
| return CharSequenceUtils.lastIndexOf(seq, searchSeq, startPos); |
| } |
| |
| /** |
| * Returns the index within {@code seq} of the last occurrence of |
| * the specified character. For values of {@code searchChar} in the |
| * range from 0 to 0xFFFF (inclusive), the index (in Unicode code |
| * units) returned is the largest value <i>k</i> such that: |
| * <blockquote><pre> |
| * this.charAt(<i>k</i>) == searchChar |
| * </pre></blockquote> |
| * is true. For other values of {@code searchChar}, it is the |
| * largest value <i>k</i> such that: |
| * <blockquote><pre> |
| * this.codePointAt(<i>k</i>) == searchChar |
| * </pre></blockquote> |
| * is true. In either case, if no such character occurs in this |
| * string, then {@code -1} is returned. Furthermore, a {@code null} or empty ("") |
| * {@link CharSequence} will return {@code -1}. The |
| * {@code seq} {@link CharSequence} object is searched backwards |
| * starting at the last character. |
| * |
| * <pre> |
| * StringUtils.lastIndexOf(null, *) = -1 |
| * StringUtils.lastIndexOf("", *) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", 'a') = 7 |
| * StringUtils.lastIndexOf("aabaabaa", 'b') = 5 |
| * </pre> |
| * |
| * @param seq the {@link CharSequence} to check, may be null |
| * @param searchChar the character to find |
| * @return the last index of the search character, |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from lastIndexOf(String, int) to lastIndexOf(CharSequence, int) |
| * @since 3.6 Updated {@link CharSequenceUtils} call to behave more like {@link String} |
| */ |
| public static int lastIndexOf(final CharSequence seq, final int searchChar) { |
| if (isEmpty(seq)) { |
| return INDEX_NOT_FOUND; |
| } |
| return CharSequenceUtils.lastIndexOf(seq, searchChar, seq.length()); |
| } |
| |
| /** |
| * Returns the index within {@code seq} of the last occurrence of |
| * the specified character, searching backward starting at the |
| * specified index. For values of {@code searchChar} in the range |
| * from 0 to 0xFFFF (inclusive), the index returned is the largest |
| * value <i>k</i> such that: |
| * <blockquote><pre> |
| * (this.charAt(<i>k</i>) == searchChar) && (<i>k</i> <= startPos) |
| * </pre></blockquote> |
| * is true. For other values of {@code searchChar}, it is the |
| * largest value <i>k</i> such that: |
| * <blockquote><pre> |
| * (this.codePointAt(<i>k</i>) == searchChar) && (<i>k</i> <= startPos) |
| * </pre></blockquote> |
| * is true. In either case, if no such character occurs in {@code seq} |
| * at or before position {@code startPos}, then |
| * {@code -1} is returned. Furthermore, a {@code null} or empty ("") |
| * {@link CharSequence} will return {@code -1}. A start position greater |
| * than the string length searches the whole string. |
| * The search starts at the {@code startPos} and works backwards; |
| * matches starting after the start position are ignored. |
| * |
| * <p>All indices are specified in {@code char} values |
| * (Unicode code units). |
| * |
| * <pre> |
| * StringUtils.lastIndexOf(null, *, *) = -1 |
| * StringUtils.lastIndexOf("", *, *) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", 'b', 8) = 5 |
| * StringUtils.lastIndexOf("aabaabaa", 'b', 4) = 2 |
| * StringUtils.lastIndexOf("aabaabaa", 'b', 0) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", 'b', 9) = 5 |
| * StringUtils.lastIndexOf("aabaabaa", 'b', -1) = -1 |
| * StringUtils.lastIndexOf("aabaabaa", 'a', 0) = 0 |
| * </pre> |
| * |
| * @param seq the CharSequence to check, may be null |
| * @param searchChar the character to find |
| * @param startPos the start position |
| * @return the last index of the search character (always ≤ startPos), |
| * -1 if no match or {@code null} string input |
| * @since 2.0 |
| * @since 3.0 Changed signature from lastIndexOf(String, int, int) to lastIndexOf(CharSequence, int, int) |
| */ |
| public static int lastIndexOf(final CharSequence seq, final int searchChar, final int startPos) { |
| if (isEmpty(seq)) { |
| return INDEX_NOT_FOUND; |
| } |
| return CharSequenceUtils.lastIndexOf(seq, searchChar, startPos); |
| } |
| |
| /** |
| * <p>Find the latest index of any substring in a set of potential substrings.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A {@code null} search array will return {@code -1}. |
| * A {@code null} or zero length search array entry will be ignored, |
| * but a search array containing "" will return the length of {@code str} |
| * if {@code str} is not null. This method uses {@link String#indexOf(String)} if possible</p> |
| * |
| * <pre> |
| * StringUtils.lastIndexOfAny(null, *) = -1 |
| * StringUtils.lastIndexOfAny(*, null) = -1 |
| * StringUtils.lastIndexOfAny(*, []) = -1 |
| * StringUtils.lastIndexOfAny(*, [null]) = -1 |
| * StringUtils.lastIndexOfAny("zzabyycdxx", ["ab", "cd"]) = 6 |
| * StringUtils.lastIndexOfAny("zzabyycdxx", ["cd", "ab"]) = 6 |
| * StringUtils.lastIndexOfAny("zzabyycdxx", ["mn", "op"]) = -1 |
| * StringUtils.lastIndexOfAny("zzabyycdxx", ["mn", "op"]) = -1 |
| * StringUtils.lastIndexOfAny("zzabyycdxx", ["mn", ""]) = 10 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStrs the CharSequences to search for, may be null |
| * @return the last index of any of the CharSequences, -1 if no match |
| * @since 3.0 Changed signature from lastIndexOfAny(String, String[]) to lastIndexOfAny(CharSequence, CharSequence) |
| */ |
| public static int lastIndexOfAny(final CharSequence str, final CharSequence... searchStrs) { |
| if (str == null || searchStrs == null) { |
| return INDEX_NOT_FOUND; |
| } |
| int ret = INDEX_NOT_FOUND; |
| int tmp; |
| for (final CharSequence search : searchStrs) { |
| if (search == null) { |
| continue; |
| } |
| tmp = CharSequenceUtils.lastIndexOf(str, search, str.length()); |
| if (tmp > ret) { |
| ret = tmp; |
| } |
| } |
| return ret; |
| } |
| |
| /** |
| * <p>Case in-sensitive find of the last index within a CharSequence.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A negative start position returns {@code -1}. |
| * An empty ("") search CharSequence always matches unless the start position is negative. |
| * A start position greater than the string length searches the whole string.</p> |
| * |
| * <pre> |
| * StringUtils.lastIndexOfIgnoreCase(null, *) = -1 |
| * StringUtils.lastIndexOfIgnoreCase(*, null) = -1 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A") = 7 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B") = 5 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB") = 4 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @return the first index of the search CharSequence, |
| * -1 if no match or {@code null} string input |
| * @since 2.5 |
| * @since 3.0 Changed signature from lastIndexOfIgnoreCase(String, String) to lastIndexOfIgnoreCase(CharSequence, CharSequence) |
| */ |
| public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr) { |
| if (str == null || searchStr == null) { |
| return INDEX_NOT_FOUND; |
| } |
| return lastIndexOfIgnoreCase(str, searchStr, str.length()); |
| } |
| |
| /** |
| * <p>Case in-sensitive find of the last index within a CharSequence |
| * from the specified position.</p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}. |
| * A negative start position returns {@code -1}. |
| * An empty ("") search CharSequence always matches unless the start position is negative. |
| * A start position greater than the string length searches the whole string. |
| * The search starts at the startPos and works backwards; matches starting after the start |
| * position are ignored. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.lastIndexOfIgnoreCase(null, *, *) = -1 |
| * StringUtils.lastIndexOfIgnoreCase(*, null, *) = -1 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8) = 7 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8) = 5 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8) = 4 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9) = 5 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1) = -1 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0) = 0 |
| * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0) = -1 |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @param startPos the start position |
| * @return the last index of the search CharSequence (always ≤ startPos), |
| * -1 if no match or {@code null} input |
| * @since 2.5 |
| * @since 3.0 Changed signature from lastIndexOfIgnoreCase(String, String, int) to lastIndexOfIgnoreCase(CharSequence, CharSequence, int) |
| */ |
| public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int startPos) { |
| if (str == null || searchStr == null) { |
| return INDEX_NOT_FOUND; |
| } |
| final int searchStrLength = searchStr.length(); |
| final int strLength = str.length(); |
| if (startPos > strLength - searchStrLength) { |
| startPos = strLength - searchStrLength; |
| } |
| if (startPos < 0) { |
| return INDEX_NOT_FOUND; |
| } |
| if (searchStrLength == 0) { |
| return startPos; |
| } |
| |
| for (int i = startPos; i >= 0; i--) { |
| if (CharSequenceUtils.regionMatches(str, true, i, searchStr, 0, searchStrLength)) { |
| return i; |
| } |
| } |
| return INDEX_NOT_FOUND; |
| } |
| |
| /** |
| * <p>Finds the n-th last index within a String, handling {@code null}. |
| * This method uses {@link String#lastIndexOf(String)}.</p> |
| * |
| * <p>A {@code null} String will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.lastOrdinalIndexOf(null, *, *) = -1 |
| * StringUtils.lastOrdinalIndexOf(*, null, *) = -1 |
| * StringUtils.lastOrdinalIndexOf("", "", *) = 0 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1) = 7 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2) = 6 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1) = 5 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2) = 2 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) = 4 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) = 1 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1) = 8 |
| * StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2) = 8 |
| * </pre> |
| * |
| * <p>Note that 'tail(CharSequence str, int n)' may be implemented as: </p> |
| * |
| * <pre> |
| * str.substring(lastOrdinalIndexOf(str, "\n", n) + 1) |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @param ordinal the n-th last {@code searchStr} to find |
| * @return the n-th last index of the search CharSequence, |
| * {@code -1} ({@code INDEX_NOT_FOUND}) if no match or {@code null} string input |
| * @since 2.5 |
| * @since 3.0 Changed signature from lastOrdinalIndexOf(String, String, int) to lastOrdinalIndexOf(CharSequence, CharSequence, int) |
| */ |
| public static int lastOrdinalIndexOf(final CharSequence str, final CharSequence searchStr, final int ordinal) { |
| return ordinalIndexOf(str, searchStr, ordinal, true); |
| } |
| |
| /** |
| * <p>Gets the leftmost {@code len} characters of a String.</p> |
| * |
| * <p>If {@code len} characters are not available, or the |
| * String is {@code null}, the String will be returned without |
| * an exception. An empty String is returned if len is negative.</p> |
| * |
| * <pre> |
| * StringUtils.left(null, *) = null |
| * StringUtils.left(*, -ve) = "" |
| * StringUtils.left("", *) = "" |
| * StringUtils.left("abc", 0) = "" |
| * StringUtils.left("abc", 2) = "ab" |
| * StringUtils.left("abc", 4) = "abc" |
| * </pre> |
| * |
| * @param str the String to get the leftmost characters from, may be null |
| * @param len the length of the required String |
| * @return the leftmost characters, {@code null} if null String input |
| */ |
| public static String left(final String str, final int len) { |
| if (str == null) { |
| return null; |
| } |
| if (len < 0) { |
| return EMPTY; |
| } |
| if (str.length() <= len) { |
| return str; |
| } |
| return str.substring(0, len); |
| } |
| |
| /** |
| * <p>Left pad a String with spaces (' ').</p> |
| * |
| * <p>The String is padded to the size of {@code size}.</p> |
| * |
| * <pre> |
| * StringUtils.leftPad(null, *) = null |
| * StringUtils.leftPad("", 3) = " " |
| * StringUtils.leftPad("bat", 3) = "bat" |
| * StringUtils.leftPad("bat", 5) = " bat" |
| * StringUtils.leftPad("bat", 1) = "bat" |
| * StringUtils.leftPad("bat", -1) = "bat" |
| * </pre> |
| * |
| * @param str the String to pad out, may be null |
| * @param size the size to pad to |
| * @return left padded String or original String if no padding is necessary, |
| * {@code null} if null String input |
| */ |
| public static String leftPad(final String str, final int size) { |
| return leftPad(str, size, ' '); |
| } |
| |
| /** |
| * <p>Left pad a String with a specified character.</p> |
| * |
| * <p>Pad to a size of {@code size}.</p> |
| * |
| * <pre> |
| * StringUtils.leftPad(null, *, *) = null |
| * StringUtils.leftPad("", 3, 'z') = "zzz" |
| * StringUtils.leftPad("bat", 3, 'z') = "bat" |
| * StringUtils.leftPad("bat", 5, 'z') = "zzbat" |
| * StringUtils.leftPad("bat", 1, 'z') = "bat" |
| * StringUtils.leftPad("bat", -1, 'z') = "bat" |
| * </pre> |
| * |
| * @param str the String to pad out, may be null |
| * @param size the size to pad to |
| * @param padChar the character to pad with |
| * @return left padded String or original String if no padding is necessary, |
| * {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String leftPad(final String str, final int size, final char padChar) { |
| if (str == null) { |
| return null; |
| } |
| final int pads = size - str.length(); |
| if (pads <= 0) { |
| return str; // returns original String when possible |
| } |
| if (pads > PAD_LIMIT) { |
| return leftPad(str, size, String.valueOf(padChar)); |
| } |
| return repeat(padChar, pads).concat(str); |
| } |
| |
| /** |
| * <p>Left pad a String with a specified String.</p> |
| * |
| * <p>Pad to a size of {@code size}.</p> |
| * |
| * <pre> |
| * StringUtils.leftPad(null, *, *) = null |
| * StringUtils.leftPad("", 3, "z") = "zzz" |
| * StringUtils.leftPad("bat", 3, "yz") = "bat" |
| * StringUtils.leftPad("bat", 5, "yz") = "yzbat" |
| * StringUtils.leftPad("bat", 8, "yz") = "yzyzybat" |
| * StringUtils.leftPad("bat", 1, "yz") = "bat" |
| * StringUtils.leftPad("bat", -1, "yz") = "bat" |
| * StringUtils.leftPad("bat", 5, null) = " bat" |
| * StringUtils.leftPad("bat", 5, "") = " bat" |
| * </pre> |
| * |
| * @param str the String to pad out, may be null |
| * @param size the size to pad to |
| * @param padStr the String to pad with, null or empty treated as single space |
| * @return left padded String or original String if no padding is necessary, |
| * {@code null} if null String input |
| */ |
| public static String leftPad(final String str, final int size, String padStr) { |
| if (str == null) { |
| return null; |
| } |
| if (isEmpty(padStr)) { |
| padStr = SPACE; |
| } |
| final int padLen = padStr.length(); |
| final int strLen = str.length(); |
| final int pads = size - strLen; |
| if (pads <= 0) { |
| return str; // returns original String when possible |
| } |
| if (padLen == 1 && pads <= PAD_LIMIT) { |
| return leftPad(str, size, padStr.charAt(0)); |
| } |
| |
| if (pads == padLen) { |
| return padStr.concat(str); |
| } |
| if (pads < padLen) { |
| return padStr.substring(0, pads).concat(str); |
| } |
| final char[] padding = new char[pads]; |
| final char[] padChars = padStr.toCharArray(); |
| for (int i = 0; i < pads; i++) { |
| padding[i] = padChars[i % padLen]; |
| } |
| return new String(padding).concat(str); |
| } |
| |
| /** |
| * Gets a CharSequence length or {@code 0} if the CharSequence is |
| * {@code null}. |
| * |
| * @param cs |
| * a CharSequence or {@code null} |
| * @return CharSequence length or {@code 0} if the CharSequence is |
| * {@code null}. |
| * @since 2.4 |
| * @since 3.0 Changed signature from length(String) to length(CharSequence) |
| */ |
| public static int length(final CharSequence cs) { |
| return cs == null ? 0 : cs.length(); |
| } |
| |
| /** |
| * <p>Converts a String to lower case as per {@link String#toLowerCase()}.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.lowerCase(null) = null |
| * StringUtils.lowerCase("") = "" |
| * StringUtils.lowerCase("aBc") = "abc" |
| * </pre> |
| * |
| * <p><strong>Note:</strong> As described in the documentation for {@link String#toLowerCase()}, |
| * the result of this method is affected by the current locale. |
| * For platform-independent case transformations, the method {@link #lowerCase(String, Locale)} |
| * should be used with a specific locale (e.g. {@link Locale#ENGLISH}).</p> |
| * |
| * @param str the String to lower case, may be null |
| * @return the lower cased String, {@code null} if null String input |
| */ |
| public static String lowerCase(final String str) { |
| if (str == null) { |
| return null; |
| } |
| return str.toLowerCase(); |
| } |
| |
| /** |
| * <p>Converts a String to lower case as per {@link String#toLowerCase(Locale)}.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.lowerCase(null, Locale.ENGLISH) = null |
| * StringUtils.lowerCase("", Locale.ENGLISH) = "" |
| * StringUtils.lowerCase("aBc", Locale.ENGLISH) = "abc" |
| * </pre> |
| * |
| * @param str the String to lower case, may be null |
| * @param locale the locale that defines the case transformation rules, must not be null |
| * @return the lower cased String, {@code null} if null String input |
| * @since 2.5 |
| */ |
| public static String lowerCase(final String str, final Locale locale) { |
| if (str == null) { |
| return null; |
| } |
| return str.toLowerCase(LocaleUtils.toLocale(locale)); |
| } |
| |
| private static int[] matches(final CharSequence first, final CharSequence second) { |
| final CharSequence max; |
| final CharSequence min; |
| if (first.length() > second.length()) { |
| max = first; |
| min = second; |
| } else { |
| max = second; |
| min = first; |
| } |
| final int range = Math.max(max.length() / 2 - 1, 0); |
| final int[] matchIndexes = new int[min.length()]; |
| Arrays.fill(matchIndexes, -1); |
| final boolean[] matchFlags = new boolean[max.length()]; |
| int matches = 0; |
| for (int mi = 0; mi < min.length(); mi++) { |
| final char c1 = min.charAt(mi); |
| for (int xi = Math.max(mi - range, 0), xn = Math.min(mi + range + 1, max.length()); xi < xn; xi++) { |
| if (!matchFlags[xi] && c1 == max.charAt(xi)) { |
| matchIndexes[mi] = xi; |
| matchFlags[xi] = true; |
| matches++; |
| break; |
| } |
| } |
| } |
| final char[] ms1 = new char[matches]; |
| final char[] ms2 = new char[matches]; |
| for (int i = 0, si = 0; i < min.length(); i++) { |
| if (matchIndexes[i] != -1) { |
| ms1[si] = min.charAt(i); |
| si++; |
| } |
| } |
| for (int i = 0, si = 0; i < max.length(); i++) { |
| if (matchFlags[i]) { |
| ms2[si] = max.charAt(i); |
| si++; |
| } |
| } |
| int transpositions = 0; |
| for (int mi = 0; mi < ms1.length; mi++) { |
| if (ms1[mi] != ms2[mi]) { |
| transpositions++; |
| } |
| } |
| int prefix = 0; |
| for (int mi = 0; mi < min.length(); mi++) { |
| if (first.charAt(mi) != second.charAt(mi)) { |
| break; |
| } |
| prefix++; |
| } |
| return new int[] { matches, transpositions / 2, prefix, max.length() }; |
| } |
| |
| /** |
| * <p>Gets {@code len} characters from the middle of a String.</p> |
| * |
| * <p>If {@code len} characters are not available, the remainder |
| * of the String will be returned without an exception. If the |
| * String is {@code null}, {@code null} will be returned. |
| * An empty String is returned if len is negative or exceeds the |
| * length of {@code str}.</p> |
| * |
| * <pre> |
| * StringUtils.mid(null, *, *) = null |
| * StringUtils.mid(*, *, -ve) = "" |
| * StringUtils.mid("", 0, *) = "" |
| * StringUtils.mid("abc", 0, 2) = "ab" |
| * StringUtils.mid("abc", 0, 4) = "abc" |
| * StringUtils.mid("abc", 2, 4) = "c" |
| * StringUtils.mid("abc", 4, 2) = "" |
| * StringUtils.mid("abc", -2, 2) = "ab" |
| * </pre> |
| * |
| * @param str the String to get the characters from, may be null |
| * @param pos the position to start from, negative treated as zero |
| * @param len the length of the required String |
| * @return the middle characters, {@code null} if null String input |
| */ |
| public static String mid(final String str, int pos, final int len) { |
| if (str == null) { |
| return null; |
| } |
| if (len < 0 || pos > str.length()) { |
| return EMPTY; |
| } |
| if (pos < 0) { |
| pos = 0; |
| } |
| if (str.length() <= pos + len) { |
| return str.substring(pos); |
| } |
| return str.substring(pos, pos + len); |
| } |
| |
| /** |
| * <p> |
| * Similar to <a |
| * href="http://www.w3.org/TR/xpath/#function-normalize-space">http://www.w3.org/TR/xpath/#function-normalize |
| * -space</a> |
| * </p> |
| * <p> |
| * The function returns the argument string with whitespace normalized by using |
| * {@code {@link #trim(String)}} to remove leading and trailing whitespace |
| * and then replacing sequences of whitespace characters by a single space. |
| * </p> |
| * In XML Whitespace characters are the same as those allowed by the <a |
| * href="http://www.w3.org/TR/REC-xml/#NT-S">S</a> production, which is S ::= (#x20 | #x9 | #xD | #xA)+ |
| * <p> |
| * Java's regexp pattern \s defines whitespace as [ \t\n\x0B\f\r] |
| * |
| * <p>For reference:</p> |
| * <ul> |
| * <li>\x0B = vertical tab</li> |
| * <li>\f = #xC = form feed</li> |
| * <li>#x20 = space</li> |
| * <li>#x9 = \t</li> |
| * <li>#xA = \n</li> |
| * <li>#xD = \r</li> |
| * </ul> |
| * |
| * <p> |
| * The difference is that Java's whitespace includes vertical tab and form feed, which this functional will also |
| * normalize. Additionally {@code {@link #trim(String)}} removes control characters (char <= 32) from both |
| * ends of this String. |
| * </p> |
| * |
| * @see Pattern |
| * @see #trim(String) |
| * @see <a |
| * href="http://www.w3.org/TR/xpath/#function-normalize-space">http://www.w3.org/TR/xpath/#function-normalize-space</a> |
| * @param str the source String to normalize whitespaces from, may be null |
| * @return the modified string with whitespace normalized, {@code null} if null String input |
| * |
| * @since 3.0 |
| */ |
| public static String normalizeSpace(final String str) { |
| // LANG-1020: Improved performance significantly by normalizing manually instead of using regex |
| // See https://github.com/librucha/commons-lang-normalizespaces-benchmark for performance test |
| if (isEmpty(str)) { |
| return str; |
| } |
| final int size = str.length(); |
| final char[] newChars = new char[size]; |
| int count = 0; |
| int whitespacesCount = 0; |
| boolean startWhitespaces = true; |
| for (int i = 0; i < size; i++) { |
| final char actualChar = str.charAt(i); |
| final boolean isWhitespace = Character.isWhitespace(actualChar); |
| if (isWhitespace) { |
| if (whitespacesCount == 0 && !startWhitespaces) { |
| newChars[count++] = SPACE.charAt(0); |
| } |
| whitespacesCount++; |
| } else { |
| startWhitespaces = false; |
| newChars[count++] = (actualChar == 160 ? 32 : actualChar); |
| whitespacesCount = 0; |
| } |
| } |
| if (startWhitespaces) { |
| return EMPTY; |
| } |
| return new String(newChars, 0, count - (whitespacesCount > 0 ? 1 : 0)).trim(); |
| } |
| |
| /** |
| * <p>Finds the n-th index within a CharSequence, handling {@code null}. |
| * This method uses {@link String#indexOf(String)} if possible.</p> |
| * <p><b>Note:</b> The code starts looking for a match at the start of the target, |
| * incrementing the starting index by one after each successful match |
| * (unless {@code searchStr} is an empty string in which case the position |
| * is never incremented and {@code 0} is returned immediately). |
| * This means that matches may overlap.</p> |
| * <p>A {@code null} CharSequence will return {@code -1}.</p> |
| * |
| * <pre> |
| * StringUtils.ordinalIndexOf(null, *, *) = -1 |
| * StringUtils.ordinalIndexOf(*, null, *) = -1 |
| * StringUtils.ordinalIndexOf("", "", *) = 0 |
| * StringUtils.ordinalIndexOf("aabaabaa", "a", 1) = 0 |
| * StringUtils.ordinalIndexOf("aabaabaa", "a", 2) = 1 |
| * StringUtils.ordinalIndexOf("aabaabaa", "b", 1) = 2 |
| * StringUtils.ordinalIndexOf("aabaabaa", "b", 2) = 5 |
| * StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1 |
| * StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4 |
| * StringUtils.ordinalIndexOf("aabaabaa", "", 1) = 0 |
| * StringUtils.ordinalIndexOf("aabaabaa", "", 2) = 0 |
| * </pre> |
| * |
| * <p>Matches may overlap:</p> |
| * <pre> |
| * StringUtils.ordinalIndexOf("ababab", "aba", 1) = 0 |
| * StringUtils.ordinalIndexOf("ababab", "aba", 2) = 2 |
| * StringUtils.ordinalIndexOf("ababab", "aba", 3) = -1 |
| * |
| * StringUtils.ordinalIndexOf("abababab", "abab", 1) = 0 |
| * StringUtils.ordinalIndexOf("abababab", "abab", 2) = 2 |
| * StringUtils.ordinalIndexOf("abababab", "abab", 3) = 4 |
| * StringUtils.ordinalIndexOf("abababab", "abab", 4) = -1 |
| * </pre> |
| * |
| * <p>Note that 'head(CharSequence str, int n)' may be implemented as: </p> |
| * |
| * <pre> |
| * str.substring(0, lastOrdinalIndexOf(str, "\n", n)) |
| * </pre> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @param ordinal the n-th {@code searchStr} to find |
| * @return the n-th index of the search CharSequence, |
| * {@code -1} ({@code INDEX_NOT_FOUND}) if no match or {@code null} string input |
| * @since 2.1 |
| * @since 3.0 Changed signature from ordinalIndexOf(String, String, int) to ordinalIndexOf(CharSequence, CharSequence, int) |
| */ |
| public static int ordinalIndexOf(final CharSequence str, final CharSequence searchStr, final int ordinal) { |
| return ordinalIndexOf(str, searchStr, ordinal, false); |
| } |
| |
| /** |
| * <p>Finds the n-th index within a String, handling {@code null}. |
| * This method uses {@link String#indexOf(String)} if possible.</p> |
| * <p>Note that matches may overlap<p> |
| * |
| * <p>A {@code null} CharSequence will return {@code -1}.</p> |
| * |
| * @param str the CharSequence to check, may be null |
| * @param searchStr the CharSequence to find, may be null |
| * @param ordinal the n-th {@code searchStr} to find, overlapping matches are allowed. |
| * @param lastIndex true if lastOrdinalIndexOf() otherwise false if ordinalIndexOf() |
| * @return the n-th index of the search CharSequence, |
| * {@code -1} ({@code INDEX_NOT_FOUND}) if no match or {@code null} string input |
| */ |
| // Shared code between ordinalIndexOf(String, String, int) and lastOrdinalIndexOf(String, String, int) |
| private static int ordinalIndexOf(final CharSequence str, final CharSequence searchStr, final int ordinal, final boolean lastIndex) { |
| if (str == null || searchStr == null || ordinal <= 0) { |
| return INDEX_NOT_FOUND; |
| } |
| if (searchStr.length() == 0) { |
| return lastIndex ? str.length() : 0; |
| } |
| int found = 0; |
| // set the initial index beyond the end of the string |
| // this is to allow for the initial index decrement/increment |
| int index = lastIndex ? str.length() : INDEX_NOT_FOUND; |
| do { |
| if (lastIndex) { |
| index = CharSequenceUtils.lastIndexOf(str, searchStr, index - 1); // step backwards through string |
| } else { |
| index = CharSequenceUtils.indexOf(str, searchStr, index + 1); // step forwards through string |
| } |
| if (index < 0) { |
| return index; |
| } |
| found++; |
| } while (found < ordinal); |
| return index; |
| } |
| |
| /** |
| * <p>Overlays part of a String with another String.</p> |
| * |
| * <p>A {@code null} string input returns {@code null}. |
| * A negative index is treated as zero. |
| * An index greater than the string length is treated as the string length. |
| * The start index is always the smaller of the two indices.</p> |
| * |
| * <pre> |
| * StringUtils.overlay(null, *, *, *) = null |
| * StringUtils.overlay("", "abc", 0, 0) = "abc" |
| * StringUtils.overlay("abcdef", null, 2, 4) = "abef" |
| * StringUtils.overlay("abcdef", "", 2, 4) = "abef" |
| * StringUtils.overlay("abcdef", "", 4, 2) = "abef" |
| * StringUtils.overlay("abcdef", "zzzz", 2, 4) = "abzzzzef" |
| * StringUtils.overlay("abcdef", "zzzz", 4, 2) = "abzzzzef" |
| * StringUtils.overlay("abcdef", "zzzz", -1, 4) = "zzzzef" |
| * StringUtils.overlay("abcdef", "zzzz", 2, 8) = "abzzzz" |
| * StringUtils.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef" |
| * StringUtils.overlay("abcdef", "zzzz", 8, 10) = "abcdefzzzz" |
| * </pre> |
| * |
| * @param str the String to do overlaying in, may be null |
| * @param overlay the String to overlay, may be null |
| * @param start the position to start overlaying at |
| * @param end the position to stop overlaying before |
| * @return overlayed String, {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String overlay(final String str, String overlay, int start, int end) { |
| if (str == null) { |
| return null; |
| } |
| if (overlay == null) { |
| overlay = EMPTY; |
| } |
| final int len = str.length(); |
| if (start < 0) { |
| start = 0; |
| } |
| if (start > len) { |
| start = len; |
| } |
| if (end < 0) { |
| end = 0; |
| } |
| if (end > len) { |
| end = len; |
| } |
| if (start > end) { |
| final int temp = start; |
| start = end; |
| end = temp; |
| } |
| return str.substring(0, start) + |
| overlay + |
| str.substring(end); |
| } |
| |
| /** |
| * Prepends the prefix to the start of the string if the string does not |
| * already start with any of the prefixes. |
| * |
| * @param str The string. |
| * @param prefix The prefix to prepend to the start of the string. |
| * @param ignoreCase Indicates whether the compare should ignore case. |
| * @param prefixes Additional prefixes that are valid (optional). |
| * |
| * @return A new String if prefix was prepended, the same string otherwise. |
| */ |
| private static String prependIfMissing(final String str, final CharSequence prefix, final boolean ignoreCase, final CharSequence... prefixes) { |
| if (str == null || isEmpty(prefix) || startsWith(str, prefix, ignoreCase)) { |
| return str; |
| } |
| if (ArrayUtils.isNotEmpty(prefixes)) { |
| for (final CharSequence p : prefixes) { |
| if (startsWith(str, p, ignoreCase)) { |
| return str; |
| } |
| } |
| } |
| return prefix.toString() + str; |
| } |
| |
| /** |
| * Prepends the prefix to the start of the string if the string does not |
| * already start with any of the prefixes. |
| * |
| * <pre> |
| * StringUtils.prependIfMissing(null, null) = null |
| * StringUtils.prependIfMissing("abc", null) = "abc" |
| * StringUtils.prependIfMissing("", "xyz") = "xyz" |
| * StringUtils.prependIfMissing("abc", "xyz") = "xyzabc" |
| * StringUtils.prependIfMissing("xyzabc", "xyz") = "xyzabc" |
| * StringUtils.prependIfMissing("XYZabc", "xyz") = "xyzXYZabc" |
| * </pre> |
| * <p>With additional prefixes,</p> |
| * <pre> |
| * StringUtils.prependIfMissing(null, null, null) = null |
| * StringUtils.prependIfMissing("abc", null, null) = "abc" |
| * StringUtils.prependIfMissing("", "xyz", null) = "xyz" |
| * StringUtils.prependIfMissing("abc", "xyz", new CharSequence[]{null}) = "xyzabc" |
| * StringUtils.prependIfMissing("abc", "xyz", "") = "abc" |
| * StringUtils.prependIfMissing("abc", "xyz", "mno") = "xyzabc" |
| * StringUtils.prependIfMissing("xyzabc", "xyz", "mno") = "xyzabc" |
| * StringUtils.prependIfMissing("mnoabc", "xyz", "mno") = "mnoabc" |
| * StringUtils.prependIfMissing("XYZabc", "xyz", "mno") = "xyzXYZabc" |
| * StringUtils.prependIfMissing("MNOabc", "xyz", "mno") = "xyzMNOabc" |
| * </pre> |
| * |
| * @param str The string. |
| * @param prefix The prefix to prepend to the start of the string. |
| * @param prefixes Additional prefixes that are valid. |
| * |
| * @return A new String if prefix was prepended, the same string otherwise. |
| * |
| * @since 3.2 |
| */ |
| public static String prependIfMissing(final String str, final CharSequence prefix, final CharSequence... prefixes) { |
| return prependIfMissing(str, prefix, false, prefixes); |
| } |
| |
| /** |
| * Prepends the prefix to the start of the string if the string does not |
| * already start, case-insensitive, with any of the prefixes. |
| * |
| * <pre> |
| * StringUtils.prependIfMissingIgnoreCase(null, null) = null |
| * StringUtils.prependIfMissingIgnoreCase("abc", null) = "abc" |
| * StringUtils.prependIfMissingIgnoreCase("", "xyz") = "xyz" |
| * StringUtils.prependIfMissingIgnoreCase("abc", "xyz") = "xyzabc" |
| * StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz") = "xyzabc" |
| * StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz") = "XYZabc" |
| * </pre> |
| * <p>With additional prefixes,</p> |
| * <pre> |
| * StringUtils.prependIfMissingIgnoreCase(null, null, null) = null |
| * StringUtils.prependIfMissingIgnoreCase("abc", null, null) = "abc" |
| * StringUtils.prependIfMissingIgnoreCase("", "xyz", null) = "xyz" |
| * StringUtils.prependIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}) = "xyzabc" |
| * StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "") = "abc" |
| * StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "mno") = "xyzabc" |
| * StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz", "mno") = "xyzabc" |
| * StringUtils.prependIfMissingIgnoreCase("mnoabc", "xyz", "mno") = "mnoabc" |
| * StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz", "mno") = "XYZabc" |
| * StringUtils.prependIfMissingIgnoreCase("MNOabc", "xyz", "mno") = "MNOabc" |
| * </pre> |
| * |
| * @param str The string. |
| * @param prefix The prefix to prepend to the start of the string. |
| * @param prefixes Additional prefixes that are valid (optional). |
| * |
| * @return A new String if prefix was prepended, the same string otherwise. |
| * |
| * @since 3.2 |
| */ |
| public static String prependIfMissingIgnoreCase(final String str, final CharSequence prefix, final CharSequence... prefixes) { |
| return prependIfMissing(str, prefix, true, prefixes); |
| } |
| |
| /** |
| * <p>Removes all occurrences of a character from within the source string.</p> |
| * |
| * <p>A {@code null} source string will return {@code null}. |
| * An empty ("") source string will return the empty string.</p> |
| * |
| * <pre> |
| * StringUtils.remove(null, *) = null |
| * StringUtils.remove("", *) = "" |
| * StringUtils.remove("queued", 'u') = "qeed" |
| * StringUtils.remove("queued", 'z') = "queued" |
| * </pre> |
| * |
| * @param str the source String to search, may be null |
| * @param remove the char to search for and remove, may be null |
| * @return the substring with the char removed if found, |
| * {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String remove(final String str, final char remove) { |
| if (isEmpty(str) || str.indexOf(remove) == INDEX_NOT_FOUND) { |
| return str; |
| } |
| final char[] chars = str.toCharArray(); |
| int pos = 0; |
| for (int i = 0; i < chars.length; i++) { |
| if (chars[i] != remove) { |
| chars[pos++] = chars[i]; |
| } |
| } |
| return new String(chars, 0, pos); |
| } |
| |
| /** |
| * <p>Removes all occurrences of a substring from within the source string.</p> |
| * |
| * <p>A {@code null} source string will return {@code null}. |
| * An empty ("") source string will return the empty string. |
| * A {@code null} remove string will return the source string. |
| * An empty ("") remove string will return the source string.</p> |
| * |
| * <pre> |
| * StringUtils.remove(null, *) = null |
| * StringUtils.remove("", *) = "" |
| * StringUtils.remove(*, null) = * |
| * StringUtils.remove(*, "") = * |
| * StringUtils.remove("queued", "ue") = "qd" |
| * StringUtils.remove("queued", "zz") = "queued" |
| * </pre> |
| * |
| * @param str the source String to search, may be null |
| * @param remove the String to search for and remove, may be null |
| * @return the substring with the string removed if found, |
| * {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String remove(final String str, final String remove) { |
| if (isEmpty(str) || isEmpty(remove)) { |
| return str; |
| } |
| return replace(str, remove, EMPTY, -1); |
| } |
| |
| /** |
| * <p>Removes each substring of the text String that matches the given regular expression.</p> |
| * |
| * This method is a {@code null} safe equivalent to: |
| * <ul> |
| * <li>{@code text.replaceAll(regex, StringUtils.EMPTY)}</li> |
| * <li>{@code Pattern.compile(regex).matcher(text).replaceAll(StringUtils.EMPTY)}</li> |
| * </ul> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <p>Unlike in the {@link #removePattern(String, String)} method, the {@link Pattern#DOTALL} option |
| * is NOT automatically added. |
| * To use the DOTALL option prepend {@code "(?s)"} to the regex. |
| * DOTALL is also known as single-line mode in Perl.</p> |
| * |
| * <pre> |
| * StringUtils.removeAll(null, *) = null |
| * StringUtils.removeAll("any", (String) null) = "any" |
| * StringUtils.removeAll("any", "") = "any" |
| * StringUtils.removeAll("any", ".*") = "" |
| * StringUtils.removeAll("any", ".+") = "" |
| * StringUtils.removeAll("abc", ".?") = "" |
| * StringUtils.removeAll("A<__>\n<__>B", "<.*>") = "A\nB" |
| * StringUtils.removeAll("A<__>\n<__>B", "(?s)<.*>") = "AB" |
| * StringUtils.removeAll("ABCabc123abc", "[a-z]") = "ABC123" |
| * </pre> |
| * |
| * @param text text to remove from, may be null |
| * @param regex the regular expression to which this string is to be matched |
| * @return the text with any removes processed, |
| * {@code null} if null String input |
| * |
| * @throws java.util.regex.PatternSyntaxException |
| * if the regular expression's syntax is invalid |
| * |
| * @see #replaceAll(String, String, String) |
| * @see #removePattern(String, String) |
| * @see String#replaceAll(String, String) |
| * @see java.util.regex.Pattern |
| * @see java.util.regex.Pattern#DOTALL |
| * @since 3.5 |
| * |
| * @deprecated Moved to RegExUtils. |
| */ |
| @Deprecated |
| public static String removeAll(final String text, final String regex) { |
| return RegExUtils.removeAll(text, regex); |
| } |
| |
| /** |
| * <p>Removes a substring only if it is at the end of a source string, |
| * otherwise returns the source string.</p> |
| * |
| * <p>A {@code null} source string will return {@code null}. |
| * An empty ("") source string will return the empty string. |
| * A {@code null} search string will return the source string.</p> |
| * |
| * <pre> |
| * StringUtils.removeEnd(null, *) = null |
| * StringUtils.removeEnd("", *) = "" |
| * StringUtils.removeEnd(*, null) = * |
| * StringUtils.removeEnd("www.domain.com", ".com.") = "www.domain.com" |
| * StringUtils.removeEnd("www.domain.com", ".com") = "www.domain" |
| * StringUtils.removeEnd("www.domain.com", "domain") = "www.domain.com" |
| * StringUtils.removeEnd("abc", "") = "abc" |
| * </pre> |
| * |
| * @param str the source String to search, may be null |
| * @param remove the String to search for and remove, may be null |
| * @return the substring with the string removed if found, |
| * {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String removeEnd(final String str, final String remove) { |
| if (isEmpty(str) || isEmpty(remove)) { |
| return str; |
| } |
| if (str.endsWith(remove)) { |
| return str.substring(0, str.length() - remove.length()); |
| } |
| return str; |
| } |
| |
| /** |
| * <p>Case insensitive removal of a substring if it is at the end of a source string, |
| * otherwise returns the source string.</p> |
| * |
| * <p>A {@code null} source string will return {@code null}. |
| * An empty ("") source string will return the empty string. |
| * A {@code null} search string will return the source string.</p> |
| * |
| * <pre> |
| * StringUtils.removeEndIgnoreCase(null, *) = null |
| * StringUtils.removeEndIgnoreCase("", *) = "" |
| * StringUtils.removeEndIgnoreCase(*, null) = * |
| * StringUtils.removeEndIgnoreCase("www.domain.com", ".com.") = "www.domain.com" |
| * StringUtils.removeEndIgnoreCase("www.domain.com", ".com") = "www.domain" |
| * StringUtils.removeEndIgnoreCase("www.domain.com", "domain") = "www.domain.com" |
| * StringUtils.removeEndIgnoreCase("abc", "") = "abc" |
| * StringUtils.removeEndIgnoreCase("www.domain.com", ".COM") = "www.domain") |
| * StringUtils.removeEndIgnoreCase("www.domain.COM", ".com") = "www.domain") |
| * </pre> |
| * |
| * @param str the source String to search, may be null |
| * @param remove the String to search for (case-insensitive) and remove, may be null |
| * @return the substring with the string removed if found, |
| * {@code null} if null String input |
| * @since 2.4 |
| */ |
| public static String removeEndIgnoreCase(final String str, final String remove) { |
| if (isEmpty(str) || isEmpty(remove)) { |
| return str; |
| } |
| if (endsWithIgnoreCase(str, remove)) { |
| return str.substring(0, str.length() - remove.length()); |
| } |
| return str; |
| } |
| |
| /** |
| * <p>Removes the first substring of the text string that matches the given regular expression.</p> |
| * |
| * This method is a {@code null} safe equivalent to: |
| * <ul> |
| * <li>{@code text.replaceFirst(regex, StringUtils.EMPTY)}</li> |
| * <li>{@code Pattern.compile(regex).matcher(text).replaceFirst(StringUtils.EMPTY)}</li> |
| * </ul> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <p>The {@link Pattern#DOTALL} option is NOT automatically added. |
| * To use the DOTALL option prepend {@code "(?s)"} to the regex. |
| * DOTALL is also known as single-line mode in Perl.</p> |
| * |
| * <pre> |
| * StringUtils.removeFirst(null, *) = null |
| * StringUtils.removeFirst("any", (String) null) = "any" |
| * StringUtils.removeFirst("any", "") = "any" |
| * StringUtils.removeFirst("any", ".*") = "" |
| * StringUtils.removeFirst("any", ".+") = "" |
| * StringUtils.removeFirst("abc", ".?") = "bc" |
| * StringUtils.removeFirst("A<__>\n<__>B", "<.*>") = "A\n<__>B" |
| * StringUtils.removeFirst("A<__>\n<__>B", "(?s)<.*>") = "AB" |
| * StringUtils.removeFirst("ABCabc123", "[a-z]") = "ABCbc123" |
| * StringUtils.removeFirst("ABCabc123abc", "[a-z]+") = "ABC123abc" |
| * </pre> |
| * |
| * @param text text to remove from, may be null |
| * @param regex the regular expression to which this string is to be matched |
| * @return the text with the first replacement processed, |
| * {@code null} if null String input |
| * |
| * @throws java.util.regex.PatternSyntaxException |
| * if the regular expression's syntax is invalid |
| * |
| * @see #replaceFirst(String, String, String) |
| * @see String#replaceFirst(String, String) |
| * @see java.util.regex.Pattern |
| * @see java.util.regex.Pattern#DOTALL |
| * @since 3.5 |
| * |
| * @deprecated Moved to RegExUtils. |
| */ |
| @Deprecated |
| public static String removeFirst(final String text, final String regex) { |
| return replaceFirst(text, regex, EMPTY); |
| } |
| |
| /** |
| * <p> |
| * Case insensitive removal of all occurrences of a substring from within |
| * the source string. |
| * </p> |
| * |
| * <p> |
| * A {@code null} source string will return {@code null}. An empty ("") |
| * source string will return the empty string. A {@code null} remove string |
| * will return the source string. An empty ("") remove string will return |
| * the source string. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.removeIgnoreCase(null, *) = null |
| * StringUtils.removeIgnoreCase("", *) = "" |
| * StringUtils.removeIgnoreCase(*, null) = * |
| * StringUtils.removeIgnoreCase(*, "") = * |
| * StringUtils.removeIgnoreCase("queued", "ue") = "qd" |
| * StringUtils.removeIgnoreCase("queued", "zz") = "queued" |
| * StringUtils.removeIgnoreCase("quEUed", "UE") = "qd" |
| * StringUtils.removeIgnoreCase("queued", "zZ") = "queued" |
| * </pre> |
| * |
| * @param str |
| * the source String to search, may be null |
| * @param remove |
| * the String to search for (case-insensitive) and remove, may be |
| * null |
| * @return the substring with the string removed if found, {@code null} if |
| * null String input |
| * @since 3.5 |
| */ |
| public static String removeIgnoreCase(final String str, final String remove) { |
| return replaceIgnoreCase(str, remove, EMPTY, -1); |
| } |
| |
| /** |
| * <p>Removes each substring of the source String that matches the given regular expression using the DOTALL option. |
| * </p> |
| * |
| * This call is a {@code null} safe equivalent to: |
| * <ul> |
| * <li>{@code source.replaceAll("(?s)" + regex, StringUtils.EMPTY)}</li> |
| * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(source).replaceAll(StringUtils.EMPTY)}</li> |
| * </ul> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.removePattern(null, *) = null |
| * StringUtils.removePattern("any", (String) null) = "any" |
| * StringUtils.removePattern("A<__>\n<__>B", "<.*>") = "AB" |
| * StringUtils.removePattern("ABCabc123", "[a-z]") = "ABC123" |
| * </pre> |
| * |
| * @param source |
| * the source string |
| * @param regex |
| * the regular expression to which this string is to be matched |
| * @return The resulting {@link String} |
| * @see #replacePattern(String, String, String) |
| * @see String#replaceAll(String, String) |
| * @see Pattern#DOTALL |
| * @since 3.2 |
| * @since 3.5 Changed {@code null} reference passed to this method is a no-op. |
| * |
| * @deprecated Moved to RegExUtils. |
| */ |
| @Deprecated |
| public static String removePattern(final String source, final String regex) { |
| return RegExUtils.removePattern(source, regex); |
| } |
| |
| /** |
| * Removes a char only if it is at the beginning of a source string, |
| * otherwise returns the source string. |
| * |
| * <p>A {@code null} source string will return {@code null}. |
| * An empty ("") source string will return the empty string. |
| * A {@code null} search char will return the source string.</p> |
| * |
| * <pre> |
| * StringUtils.removeStart(null, *) = null |
| * StringUtils.removeStart("", *) = "" |
| * StringUtils.removeStart(*, null) = * |
| * StringUtils.removeStart("/path", '/') = "path" |
| * StringUtils.removeStart("path", '/') = "path" |
| * StringUtils.removeStart("path", 0) = "path" |
| * </pre> |
| * |
| * @param str the source String to search, may be null. |
| * @param remove the char to search for and remove. |
| * @return the substring with the char removed if found, |
| * {@code null} if null String input. |
| * @since 3.13.0 |
| */ |
| public static String removeStart(final String str, final char remove) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| return str.charAt(0) == remove ? str.substring(1) : str; |
| } |
| |
| /** |
| * <p>Removes a substring only if it is at the beginning of a source string, |
| * otherwise returns the source string.</p> |
| * |
| * <p>A {@code null} source string will return {@code null}. |
| * An empty ("") source string will return the empty string. |
| * A {@code null} search string will return the source string.</p> |
| * |
| * <pre> |
| * StringUtils.removeStart(null, *) = null |
| * StringUtils.removeStart("", *) = "" |
| * StringUtils.removeStart(*, null) = * |
| * StringUtils.removeStart("www.domain.com", "www.") = "domain.com" |
| * StringUtils.removeStart("domain.com", "www.") = "domain.com" |
| * StringUtils.removeStart("www.domain.com", "domain") = "www.domain.com" |
| * StringUtils.removeStart("abc", "") = "abc" |
| * </pre> |
| * |
| * @param str the source String to search, may be null |
| * @param remove the String to search for and remove, may be null |
| * @return the substring with the string removed if found, |
| * {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String removeStart(final String str, final String remove) { |
| if (isEmpty(str) || isEmpty(remove)) { |
| return str; |
| } |
| if (str.startsWith(remove)) { |
| return str.substring(remove.length()); |
| } |
| return str; |
| } |
| |
| /** |
| * <p>Case insensitive removal of a substring if it is at the beginning of a source string, |
| * otherwise returns the source string.</p> |
| * |
| * <p>A {@code null} source string will return {@code null}. |
| * An empty ("") source string will return the empty string. |
| * A {@code null} search string will return the source string.</p> |
| * |
| * <pre> |
| * StringUtils.removeStartIgnoreCase(null, *) = null |
| * StringUtils.removeStartIgnoreCase("", *) = "" |
| * StringUtils.removeStartIgnoreCase(*, null) = * |
| * StringUtils.removeStartIgnoreCase("www.domain.com", "www.") = "domain.com" |
| * StringUtils.removeStartIgnoreCase("www.domain.com", "WWW.") = "domain.com" |
| * StringUtils.removeStartIgnoreCase("domain.com", "www.") = "domain.com" |
| * StringUtils.removeStartIgnoreCase("www.domain.com", "domain") = "www.domain.com" |
| * StringUtils.removeStartIgnoreCase("abc", "") = "abc" |
| * </pre> |
| * |
| * @param str the source String to search, may be null |
| * @param remove the String to search for (case-insensitive) and remove, may be null |
| * @return the substring with the string removed if found, |
| * {@code null} if null String input |
| * @since 2.4 |
| */ |
| public static String removeStartIgnoreCase(final String str, final String remove) { |
| if (str != null && startsWithIgnoreCase(str, remove)) { |
| return str.substring(length(remove)); |
| } |
| return str; |
| } |
| |
| /** |
| * <p>Returns padding using the specified delimiter repeated |
| * to a given length.</p> |
| * |
| * <pre> |
| * StringUtils.repeat('e', 0) = "" |
| * StringUtils.repeat('e', 3) = "eee" |
| * StringUtils.repeat('e', -2) = "" |
| * </pre> |
| * |
| * <p>Note: this method does not support padding with |
| * <a href="http://www.unicode.org/glossary/#supplementary_character">Unicode Supplementary Characters</a> |
| * as they require a pair of {@code char}s to be represented. |
| * If you are needing to support full I18N of your applications |
| * consider using {@link #repeat(String, int)} instead. |
| * </p> |
| * |
| * @param ch character to repeat |
| * @param repeat number of times to repeat char, negative treated as zero |
| * @return String with repeated character |
| * @see #repeat(String, int) |
| */ |
| public static String repeat(final char ch, final int repeat) { |
| if (repeat <= 0) { |
| return EMPTY; |
| } |
| final char[] buf = new char[repeat]; |
| Arrays.fill(buf, ch); |
| return new String(buf); |
| } |
| |
| /** |
| * <p>Repeat a String {@code repeat} times to form a |
| * new String.</p> |
| * |
| * <pre> |
| * StringUtils.repeat(null, 2) = null |
| * StringUtils.repeat("", 0) = "" |
| * StringUtils.repeat("", 2) = "" |
| * StringUtils.repeat("a", 3) = "aaa" |
| * StringUtils.repeat("ab", 2) = "abab" |
| * StringUtils.repeat("a", -2) = "" |
| * </pre> |
| * |
| * @param str the String to repeat, may be null |
| * @param repeat number of times to repeat str, negative treated as zero |
| * @return a new String consisting of the original String repeated, |
| * {@code null} if null String input |
| */ |
| public static String repeat(final String str, final int repeat) { |
| // Performance tuned for 2.0 (JDK1.4) |
| if (str == null) { |
| return null; |
| } |
| if (repeat <= 0) { |
| return EMPTY; |
| } |
| final int inputLength = str.length(); |
| if (repeat == 1 || inputLength == 0) { |
| return str; |
| } |
| if (inputLength == 1 && repeat <= PAD_LIMIT) { |
| return repeat(str.charAt(0), repeat); |
| } |
| |
| final int outputLength = inputLength * repeat; |
| switch (inputLength) { |
| case 1 : |
| return repeat(str.charAt(0), repeat); |
| case 2 : |
| final char ch0 = str.charAt(0); |
| final char ch1 = str.charAt(1); |
| final char[] output2 = new char[outputLength]; |
| for (int i = repeat * 2 - 2; i >= 0; i--, i--) { |
| output2[i] = ch0; |
| output2[i + 1] = ch1; |
| } |
| return new String(output2); |
| default : |
| final StringBuilder buf = new StringBuilder(outputLength); |
| for (int i = 0; i < repeat; i++) { |
| buf.append(str); |
| } |
| return buf.toString(); |
| } |
| } |
| |
| /** |
| * <p>Repeat a String {@code repeat} times to form a |
| * new String, with a String separator injected each time. </p> |
| * |
| * <pre> |
| * StringUtils.repeat(null, null, 2) = null |
| * StringUtils.repeat(null, "x", 2) = null |
| * StringUtils.repeat("", null, 0) = "" |
| * StringUtils.repeat("", "", 2) = "" |
| * StringUtils.repeat("", "x", 3) = "xx" |
| * StringUtils.repeat("?", ", ", 3) = "?, ?, ?" |
| * </pre> |
| * |
| * @param str the String to repeat, may be null |
| * @param separator the String to inject, may be null |
| * @param repeat number of times to repeat str, negative treated as zero |
| * @return a new String consisting of the original String repeated, |
| * {@code null} if null String input |
| * @since 2.5 |
| */ |
| public static String repeat(final String str, final String separator, final int repeat) { |
| if (str == null || separator == null) { |
| return repeat(str, repeat); |
| } |
| // given that repeat(String, int) is quite optimized, better to rely on it than try and splice this into it |
| final String result = repeat(str + separator, repeat); |
| return removeEnd(result, separator); |
| } |
| |
| /** |
| * <p>Replaces all occurrences of a String within another String.</p> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replace(null, *, *) = null |
| * StringUtils.replace("", *, *) = "" |
| * StringUtils.replace("any", null, *) = "any" |
| * StringUtils.replace("any", *, null) = "any" |
| * StringUtils.replace("any", "", *) = "any" |
| * StringUtils.replace("aba", "a", null) = "aba" |
| * StringUtils.replace("aba", "a", "") = "b" |
| * StringUtils.replace("aba", "a", "z") = "zbz" |
| * </pre> |
| * |
| * @see #replace(String text, String searchString, String replacement, int max) |
| * @param text text to search and replace in, may be null |
| * @param searchString the String to search for, may be null |
| * @param replacement the String to replace it with, may be null |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| */ |
| public static String replace(final String text, final String searchString, final String replacement) { |
| return replace(text, searchString, replacement, -1); |
| } |
| |
| /** |
| * <p>Replaces a String with another String inside a larger String, |
| * for the first {@code max} values of the search String.</p> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replace(null, *, *, *) = null |
| * StringUtils.replace("", *, *, *) = "" |
| * StringUtils.replace("any", null, *, *) = "any" |
| * StringUtils.replace("any", *, null, *) = "any" |
| * StringUtils.replace("any", "", *, *) = "any" |
| * StringUtils.replace("any", *, *, 0) = "any" |
| * StringUtils.replace("abaa", "a", null, -1) = "abaa" |
| * StringUtils.replace("abaa", "a", "", -1) = "b" |
| * StringUtils.replace("abaa", "a", "z", 0) = "abaa" |
| * StringUtils.replace("abaa", "a", "z", 1) = "zbaa" |
| * StringUtils.replace("abaa", "a", "z", 2) = "zbza" |
| * StringUtils.replace("abaa", "a", "z", -1) = "zbzz" |
| * </pre> |
| * |
| * @param text text to search and replace in, may be null |
| * @param searchString the String to search for, may be null |
| * @param replacement the String to replace it with, may be null |
| * @param max maximum number of values to replace, or {@code -1} if no maximum |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| */ |
| public static String replace(final String text, final String searchString, final String replacement, final int max) { |
| return replace(text, searchString, replacement, max, false); |
| } |
| |
| /** |
| * <p>Replaces a String with another String inside a larger String, |
| * for the first {@code max} values of the search String, |
| * case-sensitively/insensitively based on {@code ignoreCase} value.</p> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replace(null, *, *, *, false) = null |
| * StringUtils.replace("", *, *, *, false) = "" |
| * StringUtils.replace("any", null, *, *, false) = "any" |
| * StringUtils.replace("any", *, null, *, false) = "any" |
| * StringUtils.replace("any", "", *, *, false) = "any" |
| * StringUtils.replace("any", *, *, 0, false) = "any" |
| * StringUtils.replace("abaa", "a", null, -1, false) = "abaa" |
| * StringUtils.replace("abaa", "a", "", -1, false) = "b" |
| * StringUtils.replace("abaa", "a", "z", 0, false) = "abaa" |
| * StringUtils.replace("abaa", "A", "z", 1, false) = "abaa" |
| * StringUtils.replace("abaa", "A", "z", 1, true) = "zbaa" |
| * StringUtils.replace("abAa", "a", "z", 2, true) = "zbza" |
| * StringUtils.replace("abAa", "a", "z", -1, true) = "zbzz" |
| * </pre> |
| * |
| * @param text text to search and replace in, may be null |
| * @param searchString the String to search for (case-insensitive), may be null |
| * @param replacement the String to replace it with, may be null |
| * @param max maximum number of values to replace, or {@code -1} if no maximum |
| * @param ignoreCase if true replace is case-insensitive, otherwise case-sensitive |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| */ |
| private static String replace(final String text, String searchString, final String replacement, int max, final boolean ignoreCase) { |
| if (isEmpty(text) || isEmpty(searchString) || replacement == null || max == 0) { |
| return text; |
| } |
| if (ignoreCase) { |
| searchString = searchString.toLowerCase(); |
| } |
| int start = 0; |
| int end = ignoreCase ? indexOfIgnoreCase(text, searchString, start) : indexOf(text, searchString, start); |
| if (end == INDEX_NOT_FOUND) { |
| return text; |
| } |
| final int replLength = searchString.length(); |
| int increase = Math.max(replacement.length() - replLength, 0); |
| increase *= max < 0 ? 16 : Math.min(max, 64); |
| final StringBuilder buf = new StringBuilder(text.length() + increase); |
| while (end != INDEX_NOT_FOUND) { |
| buf.append(text, start, end).append(replacement); |
| start = end + replLength; |
| if (--max == 0) { |
| break; |
| } |
| end = ignoreCase ? indexOfIgnoreCase(text, searchString, start) : indexOf(text, searchString, start); |
| } |
| buf.append(text, start, text.length()); |
| return buf.toString(); |
| } |
| |
| /** |
| * <p>Replaces each substring of the text String that matches the given regular expression |
| * with the given replacement.</p> |
| * |
| * This method is a {@code null} safe equivalent to: |
| * <ul> |
| * <li>{@code text.replaceAll(regex, replacement)}</li> |
| * <li>{@code Pattern.compile(regex).matcher(text).replaceAll(replacement)}</li> |
| * </ul> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <p>Unlike in the {@link #replacePattern(String, String, String)} method, the {@link Pattern#DOTALL} option |
| * is NOT automatically added. |
| * To use the DOTALL option prepend {@code "(?s)"} to the regex. |
| * DOTALL is also known as single-line mode in Perl.</p> |
| * |
| * <pre> |
| * StringUtils.replaceAll(null, *, *) = null |
| * StringUtils.replaceAll("any", (String) null, *) = "any" |
| * StringUtils.replaceAll("any", *, null) = "any" |
| * StringUtils.replaceAll("", "", "zzz") = "zzz" |
| * StringUtils.replaceAll("", ".*", "zzz") = "zzz" |
| * StringUtils.replaceAll("", ".+", "zzz") = "" |
| * StringUtils.replaceAll("abc", "", "ZZ") = "ZZaZZbZZcZZ" |
| * StringUtils.replaceAll("<__>\n<__>", "<.*>", "z") = "z\nz" |
| * StringUtils.replaceAll("<__>\n<__>", "(?s)<.*>", "z") = "z" |
| * StringUtils.replaceAll("ABCabc123", "[a-z]", "_") = "ABC___123" |
| * StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_") = "ABC_123" |
| * StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "") = "ABC123" |
| * StringUtils.replaceAll("Lorem ipsum dolor sit", "( +)([a-z]+)", "_$2") = "Lorem_ipsum_dolor_sit" |
| * </pre> |
| * |
| * @param text text to search and replace in, may be null |
| * @param regex the regular expression to which this string is to be matched |
| * @param replacement the string to be substituted for each match |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| * |
| * @throws java.util.regex.PatternSyntaxException |
| * if the regular expression's syntax is invalid |
| * |
| * @see #replacePattern(String, String, String) |
| * @see String#replaceAll(String, String) |
| * @see java.util.regex.Pattern |
| * @see java.util.regex.Pattern#DOTALL |
| * @since 3.5 |
| * |
| * @deprecated Moved to RegExUtils. |
| */ |
| @Deprecated |
| public static String replaceAll(final String text, final String regex, final String replacement) { |
| return RegExUtils.replaceAll(text, regex, replacement); |
| } |
| |
| /** |
| * <p>Replaces all occurrences of a character in a String with another. |
| * This is a null-safe version of {@link String#replace(char, char)}.</p> |
| * |
| * <p>A {@code null} string input returns {@code null}. |
| * An empty ("") string input returns an empty string.</p> |
| * |
| * <pre> |
| * StringUtils.replaceChars(null, *, *) = null |
| * StringUtils.replaceChars("", *, *) = "" |
| * StringUtils.replaceChars("abcba", 'b', 'y') = "aycya" |
| * StringUtils.replaceChars("abcba", 'z', 'y') = "abcba" |
| * </pre> |
| * |
| * @param str String to replace characters in, may be null |
| * @param searchChar the character to search for, may be null |
| * @param replaceChar the character to replace, may be null |
| * @return modified String, {@code null} if null string input |
| * @since 2.0 |
| */ |
| public static String replaceChars(final String str, final char searchChar, final char replaceChar) { |
| if (str == null) { |
| return null; |
| } |
| return str.replace(searchChar, replaceChar); |
| } |
| |
| /** |
| * <p>Replaces multiple characters in a String in one go. |
| * This method can also be used to delete characters.</p> |
| * |
| * <p>For example:<br> |
| * {@code replaceChars("hello", "ho", "jy") = jelly}.</p> |
| * |
| * <p>A {@code null} string input returns {@code null}. |
| * An empty ("") string input returns an empty string. |
| * A null or empty set of search characters returns the input string.</p> |
| * |
| * <p>The length of the search characters should normally equal the length |
| * of the replace characters. |
| * If the search characters is longer, then the extra search characters |
| * are deleted. |
| * If the search characters is shorter, then the extra replace characters |
| * are ignored.</p> |
| * |
| * <pre> |
| * StringUtils.replaceChars(null, *, *) = null |
| * StringUtils.replaceChars("", *, *) = "" |
| * StringUtils.replaceChars("abc", null, *) = "abc" |
| * StringUtils.replaceChars("abc", "", *) = "abc" |
| * StringUtils.replaceChars("abc", "b", null) = "ac" |
| * StringUtils.replaceChars("abc", "b", "") = "ac" |
| * StringUtils.replaceChars("abcba", "bc", "yz") = "ayzya" |
| * StringUtils.replaceChars("abcba", "bc", "y") = "ayya" |
| * StringUtils.replaceChars("abcba", "bc", "yzx") = "ayzya" |
| * </pre> |
| * |
| * @param str String to replace characters in, may be null |
| * @param searchChars a set of characters to search for, may be null |
| * @param replaceChars a set of characters to replace, may be null |
| * @return modified String, {@code null} if null string input |
| * @since 2.0 |
| */ |
| public static String replaceChars(final String str, final String searchChars, String replaceChars) { |
| if (isEmpty(str) || isEmpty(searchChars)) { |
| return str; |
| } |
| if (replaceChars == null) { |
| replaceChars = EMPTY; |
| } |
| boolean modified = false; |
| final int replaceCharsLength = replaceChars.length(); |
| final int strLength = str.length(); |
| final StringBuilder buf = new StringBuilder(strLength); |
| for (int i = 0; i < strLength; i++) { |
| final char ch = str.charAt(i); |
| final int index = searchChars.indexOf(ch); |
| if (index >= 0) { |
| modified = true; |
| if (index < replaceCharsLength) { |
| buf.append(replaceChars.charAt(index)); |
| } |
| } else { |
| buf.append(ch); |
| } |
| } |
| if (modified) { |
| return buf.toString(); |
| } |
| return str; |
| } |
| |
| /** |
| * <p> |
| * Replaces all occurrences of Strings within another String. |
| * </p> |
| * |
| * <p> |
| * A {@code null} reference passed to this method is a no-op, or if |
| * any "search string" or "string to replace" is null, that replace will be |
| * ignored. This will not repeat. For repeating replaces, call the |
| * overloaded method. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.replaceEach(null, *, *) = null |
| * StringUtils.replaceEach("", *, *) = "" |
| * StringUtils.replaceEach("aba", null, null) = "aba" |
| * StringUtils.replaceEach("aba", new String[0], null) = "aba" |
| * StringUtils.replaceEach("aba", null, new String[0]) = "aba" |
| * StringUtils.replaceEach("aba", new String[]{"a"}, null) = "aba" |
| * StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""}) = "b" |
| * StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"}) = "aba" |
| * StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}) = "wcte" |
| * (example of how it does not repeat) |
| * StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}) = "dcte" |
| * </pre> |
| * |
| * @param text |
| * text to search and replace in, no-op if null |
| * @param searchList |
| * the Strings to search for, no-op if null |
| * @param replacementList |
| * the Strings to replace them with, no-op if null |
| * @return the text with any replacements processed, {@code null} if |
| * null String input |
| * @throws IllegalArgumentException |
| * if the lengths of the arrays are not the same (null is ok, |
| * and/or size 0) |
| * @since 2.4 |
| */ |
| public static String replaceEach(final String text, final String[] searchList, final String[] replacementList) { |
| return replaceEach(text, searchList, replacementList, false, 0); |
| } |
| |
| /** |
| * <p> |
| * Replace all occurrences of Strings within another String. |
| * This is a private recursive helper method for {@link #replaceEachRepeatedly(String, String[], String[])} and |
| * {@link #replaceEach(String, String[], String[])} |
| * </p> |
| * |
| * <p> |
| * A {@code null} reference passed to this method is a no-op, or if |
| * any "search string" or "string to replace" is null, that replace will be |
| * ignored. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.replaceEach(null, *, *, *, *) = null |
| * StringUtils.replaceEach("", *, *, *, *) = "" |
| * StringUtils.replaceEach("aba", null, null, *, *) = "aba" |
| * StringUtils.replaceEach("aba", new String[0], null, *, *) = "aba" |
| * StringUtils.replaceEach("aba", null, new String[0], *, *) = "aba" |
| * StringUtils.replaceEach("aba", new String[]{"a"}, null, *, *) = "aba" |
| * StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""}, *, >=0) = "b" |
| * StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"}, *, >=0) = "aba" |
| * StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}, *, >=0) = "wcte" |
| * (example of how it repeats) |
| * StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, false, >=0) = "dcte" |
| * StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, true, >=2) = "tcte" |
| * StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, *, *) = IllegalStateException |
| * </pre> |
| * |
| * @param text |
| * text to search and replace in, no-op if null |
| * @param searchList |
| * the Strings to search for, no-op if null |
| * @param replacementList |
| * the Strings to replace them with, no-op if null |
| * @param repeat if true, then replace repeatedly |
| * until there are no more possible replacements or timeToLive < 0 |
| * @param timeToLive |
| * if less than 0 then there is a circular reference and endless |
| * loop |
| * @return the text with any replacements processed, {@code null} if |
| * null String input |
| * @throws IllegalStateException |
| * if the search is repeating and there is an endless loop due |
| * to outputs of one being inputs to another |
| * @throws IllegalArgumentException |
| * if the lengths of the arrays are not the same (null is ok, |
| * and/or size 0) |
| * @since 2.4 |
| */ |
| private static String replaceEach( |
| final String text, final String[] searchList, final String[] replacementList, final boolean repeat, final int timeToLive) { |
| |
| // mchyzer Performance note: This creates very few new objects (one major goal) |
| // let me know if there are performance requests, we can create a harness to measure |
| |
| // if recursing, this shouldn't be less than 0 |
| if (timeToLive < 0) { |
| final Set<String> searchSet = new HashSet<>(Arrays.asList(searchList)); |
| final Set<String> replacementSet = new HashSet<>(Arrays.asList(replacementList)); |
| searchSet.retainAll(replacementSet); |
| if (!searchSet.isEmpty()) { |
| throw new IllegalStateException("Aborting to protect against StackOverflowError - " + |
| "output of one loop is the input of another"); |
| } |
| } |
| |
| if (isEmpty(text) || ArrayUtils.isEmpty(searchList) || ArrayUtils.isEmpty(replacementList) || (ArrayUtils.isNotEmpty(searchList) && timeToLive == -1)) { |
| return text; |
| } |
| |
| final int searchLength = searchList.length; |
| final int replacementLength = replacementList.length; |
| |
| // make sure lengths are ok, these need to be equal |
| if (searchLength != replacementLength) { |
| throw new IllegalArgumentException("Search and Replace array lengths don't match: " |
| + searchLength |
| + " vs " |
| + replacementLength); |
| } |
| |
| // keep track of which still have matches |
| final boolean[] noMoreMatchesForReplIndex = new boolean[searchLength]; |
| |
| // index on index that the match was found |
| int textIndex = -1; |
| int replaceIndex = -1; |
| int tempIndex; |
| |
| // index of replace array that will replace the search string found |
| // NOTE: logic duplicated below START |
| for (int i = 0; i < searchLength; i++) { |
| if (noMoreMatchesForReplIndex[i] || isEmpty(searchList[i]) || replacementList[i] == null) { |
| continue; |
| } |
| tempIndex = text.indexOf(searchList[i]); |
| |
| // see if we need to keep searching for this |
| if (tempIndex == -1) { |
| noMoreMatchesForReplIndex[i] = true; |
| } else if (textIndex == -1 || tempIndex < textIndex) { |
| textIndex = tempIndex; |
| replaceIndex = i; |
| } |
| } |
| // NOTE: logic mostly below END |
| |
| // no search strings found, we are done |
| if (textIndex == -1) { |
| return text; |
| } |
| |
| int start = 0; |
| |
| // get a good guess on the size of the result buffer so it doesn't have to double if it goes over a bit |
| int increase = 0; |
| |
| // count the replacement text elements that are larger than their corresponding text being replaced |
| for (int i = 0; i < searchList.length; i++) { |
| if (searchList[i] == null || replacementList[i] == null) { |
| continue; |
| } |
| final int greater = replacementList[i].length() - searchList[i].length(); |
| if (greater > 0) { |
| increase += 3 * greater; // assume 3 matches |
| } |
| } |
| // have upper-bound at 20% increase, then let Java take over |
| increase = Math.min(increase, text.length() / 5); |
| |
| final StringBuilder buf = new StringBuilder(text.length() + increase); |
| |
| while (textIndex != -1) { |
| |
| for (int i = start; i < textIndex; i++) { |
| buf.append(text.charAt(i)); |
| } |
| buf.append(replacementList[replaceIndex]); |
| |
| start = textIndex + searchList[replaceIndex].length(); |
| |
| textIndex = -1; |
| replaceIndex = -1; |
| // find the next earliest match |
| // NOTE: logic mostly duplicated above START |
| for (int i = 0; i < searchLength; i++) { |
| if (noMoreMatchesForReplIndex[i] || searchList[i] == null || |
| searchList[i].isEmpty() || replacementList[i] == null) { |
| continue; |
| } |
| tempIndex = text.indexOf(searchList[i], start); |
| |
| // see if we need to keep searching for this |
| if (tempIndex == -1) { |
| noMoreMatchesForReplIndex[i] = true; |
| } else if (textIndex == -1 || tempIndex < textIndex) { |
| textIndex = tempIndex; |
| replaceIndex = i; |
| } |
| } |
| // NOTE: logic duplicated above END |
| |
| } |
| final int textLength = text.length(); |
| for (int i = start; i < textLength; i++) { |
| buf.append(text.charAt(i)); |
| } |
| final String result = buf.toString(); |
| if (!repeat) { |
| return result; |
| } |
| |
| return replaceEach(result, searchList, replacementList, repeat, timeToLive - 1); |
| } |
| |
| /** |
| * <p> |
| * Replaces all occurrences of Strings within another String. |
| * </p> |
| * |
| * <p> |
| * A {@code null} reference passed to this method is a no-op, or if |
| * any "search string" or "string to replace" is null, that replace will be |
| * ignored. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.replaceEachRepeatedly(null, *, *) = null |
| * StringUtils.replaceEachRepeatedly("", *, *) = "" |
| * StringUtils.replaceEachRepeatedly("aba", null, null) = "aba" |
| * StringUtils.replaceEachRepeatedly("aba", new String[0], null) = "aba" |
| * StringUtils.replaceEachRepeatedly("aba", null, new String[0]) = "aba" |
| * StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, null) = "aba" |
| * StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, new String[]{""}) = "b" |
| * StringUtils.replaceEachRepeatedly("aba", new String[]{null}, new String[]{"a"}) = "aba" |
| * StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}) = "wcte" |
| * (example of how it repeats) |
| * StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}) = "tcte" |
| * StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}) = IllegalStateException |
| * </pre> |
| * |
| * @param text |
| * text to search and replace in, no-op if null |
| * @param searchList |
| * the Strings to search for, no-op if null |
| * @param replacementList |
| * the Strings to replace them with, no-op if null |
| * @return the text with any replacements processed, {@code null} if |
| * null String input |
| * @throws IllegalStateException |
| * if the search is repeating and there is an endless loop due |
| * to outputs of one being inputs to another |
| * @throws IllegalArgumentException |
| * if the lengths of the arrays are not the same (null is ok, |
| * and/or size 0) |
| * @since 2.4 |
| */ |
| public static String replaceEachRepeatedly(final String text, final String[] searchList, final String[] replacementList) { |
| return replaceEach(text, searchList, replacementList, true, ArrayUtils.getLength(searchList)); |
| } |
| |
| /** |
| * <p>Replaces the first substring of the text string that matches the given regular expression |
| * with the given replacement.</p> |
| * |
| * This method is a {@code null} safe equivalent to: |
| * <ul> |
| * <li>{@code text.replaceFirst(regex, replacement)}</li> |
| * <li>{@code Pattern.compile(regex).matcher(text).replaceFirst(replacement)}</li> |
| * </ul> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <p>The {@link Pattern#DOTALL} option is NOT automatically added. |
| * To use the DOTALL option prepend {@code "(?s)"} to the regex. |
| * DOTALL is also known as single-line mode in Perl.</p> |
| * |
| * <pre> |
| * StringUtils.replaceFirst(null, *, *) = null |
| * StringUtils.replaceFirst("any", (String) null, *) = "any" |
| * StringUtils.replaceFirst("any", *, null) = "any" |
| * StringUtils.replaceFirst("", "", "zzz") = "zzz" |
| * StringUtils.replaceFirst("", ".*", "zzz") = "zzz" |
| * StringUtils.replaceFirst("", ".+", "zzz") = "" |
| * StringUtils.replaceFirst("abc", "", "ZZ") = "ZZabc" |
| * StringUtils.replaceFirst("<__>\n<__>", "<.*>", "z") = "z\n<__>" |
| * StringUtils.replaceFirst("<__>\n<__>", "(?s)<.*>", "z") = "z" |
| * StringUtils.replaceFirst("ABCabc123", "[a-z]", "_") = "ABC_bc123" |
| * StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_") = "ABC_123abc" |
| * StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "") = "ABC123abc" |
| * StringUtils.replaceFirst("Lorem ipsum dolor sit", "( +)([a-z]+)", "_$2") = "Lorem_ipsum dolor sit" |
| * </pre> |
| * |
| * @param text text to search and replace in, may be null |
| * @param regex the regular expression to which this string is to be matched |
| * @param replacement the string to be substituted for the first match |
| * @return the text with the first replacement processed, |
| * {@code null} if null String input |
| * |
| * @throws java.util.regex.PatternSyntaxException |
| * if the regular expression's syntax is invalid |
| * |
| * @see String#replaceFirst(String, String) |
| * @see java.util.regex.Pattern |
| * @see java.util.regex.Pattern#DOTALL |
| * @since 3.5 |
| * |
| * @deprecated Moved to RegExUtils. |
| */ |
| @Deprecated |
| public static String replaceFirst(final String text, final String regex, final String replacement) { |
| return RegExUtils.replaceFirst(text, regex, replacement); |
| } |
| |
| /** |
| * <p>Case insensitively replaces all occurrences of a String within another String.</p> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replaceIgnoreCase(null, *, *) = null |
| * StringUtils.replaceIgnoreCase("", *, *) = "" |
| * StringUtils.replaceIgnoreCase("any", null, *) = "any" |
| * StringUtils.replaceIgnoreCase("any", *, null) = "any" |
| * StringUtils.replaceIgnoreCase("any", "", *) = "any" |
| * StringUtils.replaceIgnoreCase("aba", "a", null) = "aba" |
| * StringUtils.replaceIgnoreCase("abA", "A", "") = "b" |
| * StringUtils.replaceIgnoreCase("aba", "A", "z") = "zbz" |
| * </pre> |
| * |
| * @see #replaceIgnoreCase(String text, String searchString, String replacement, int max) |
| * @param text text to search and replace in, may be null |
| * @param searchString the String to search for (case-insensitive), may be null |
| * @param replacement the String to replace it with, may be null |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| * @since 3.5 |
| */ |
| public static String replaceIgnoreCase(final String text, final String searchString, final String replacement) { |
| return replaceIgnoreCase(text, searchString, replacement, -1); |
| } |
| |
| /** |
| * <p>Case insensitively replaces a String with another String inside a larger String, |
| * for the first {@code max} values of the search String.</p> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replaceIgnoreCase(null, *, *, *) = null |
| * StringUtils.replaceIgnoreCase("", *, *, *) = "" |
| * StringUtils.replaceIgnoreCase("any", null, *, *) = "any" |
| * StringUtils.replaceIgnoreCase("any", *, null, *) = "any" |
| * StringUtils.replaceIgnoreCase("any", "", *, *) = "any" |
| * StringUtils.replaceIgnoreCase("any", *, *, 0) = "any" |
| * StringUtils.replaceIgnoreCase("abaa", "a", null, -1) = "abaa" |
| * StringUtils.replaceIgnoreCase("abaa", "a", "", -1) = "b" |
| * StringUtils.replaceIgnoreCase("abaa", "a", "z", 0) = "abaa" |
| * StringUtils.replaceIgnoreCase("abaa", "A", "z", 1) = "zbaa" |
| * StringUtils.replaceIgnoreCase("abAa", "a", "z", 2) = "zbza" |
| * StringUtils.replaceIgnoreCase("abAa", "a", "z", -1) = "zbzz" |
| * </pre> |
| * |
| * @param text text to search and replace in, may be null |
| * @param searchString the String to search for (case-insensitive), may be null |
| * @param replacement the String to replace it with, may be null |
| * @param max maximum number of values to replace, or {@code -1} if no maximum |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| * @since 3.5 |
| */ |
| public static String replaceIgnoreCase(final String text, final String searchString, final String replacement, final int max) { |
| return replace(text, searchString, replacement, max, true); |
| } |
| |
| /** |
| * <p>Replaces a String with another String inside a larger String, once.</p> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replaceOnce(null, *, *) = null |
| * StringUtils.replaceOnce("", *, *) = "" |
| * StringUtils.replaceOnce("any", null, *) = "any" |
| * StringUtils.replaceOnce("any", *, null) = "any" |
| * StringUtils.replaceOnce("any", "", *) = "any" |
| * StringUtils.replaceOnce("aba", "a", null) = "aba" |
| * StringUtils.replaceOnce("aba", "a", "") = "ba" |
| * StringUtils.replaceOnce("aba", "a", "z") = "zba" |
| * </pre> |
| * |
| * @see #replace(String text, String searchString, String replacement, int max) |
| * @param text text to search and replace in, may be null |
| * @param searchString the String to search for, may be null |
| * @param replacement the String to replace with, may be null |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| */ |
| public static String replaceOnce(final String text, final String searchString, final String replacement) { |
| return replace(text, searchString, replacement, 1); |
| } |
| |
| /** |
| * <p>Case insensitively replaces a String with another String inside a larger String, once.</p> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replaceOnceIgnoreCase(null, *, *) = null |
| * StringUtils.replaceOnceIgnoreCase("", *, *) = "" |
| * StringUtils.replaceOnceIgnoreCase("any", null, *) = "any" |
| * StringUtils.replaceOnceIgnoreCase("any", *, null) = "any" |
| * StringUtils.replaceOnceIgnoreCase("any", "", *) = "any" |
| * StringUtils.replaceOnceIgnoreCase("aba", "a", null) = "aba" |
| * StringUtils.replaceOnceIgnoreCase("aba", "a", "") = "ba" |
| * StringUtils.replaceOnceIgnoreCase("aba", "a", "z") = "zba" |
| * StringUtils.replaceOnceIgnoreCase("FoOFoofoo", "foo", "") = "Foofoo" |
| * </pre> |
| * |
| * @see #replaceIgnoreCase(String text, String searchString, String replacement, int max) |
| * @param text text to search and replace in, may be null |
| * @param searchString the String to search for (case-insensitive), may be null |
| * @param replacement the String to replace with, may be null |
| * @return the text with any replacements processed, |
| * {@code null} if null String input |
| * @since 3.5 |
| */ |
| public static String replaceOnceIgnoreCase(final String text, final String searchString, final String replacement) { |
| return replaceIgnoreCase(text, searchString, replacement, 1); |
| } |
| |
| /** |
| * <p>Replaces each substring of the source String that matches the given regular expression with the given |
| * replacement using the {@link Pattern#DOTALL} option. DOTALL is also known as single-line mode in Perl.</p> |
| * |
| * This call is a {@code null} safe equivalent to: |
| * <ul> |
| * <li>{@code source.replaceAll("(?s)" + regex, replacement)}</li> |
| * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(source).replaceAll(replacement)}</li> |
| * </ul> |
| * |
| * <p>A {@code null} reference passed to this method is a no-op.</p> |
| * |
| * <pre> |
| * StringUtils.replacePattern(null, *, *) = null |
| * StringUtils.replacePattern("any", (String) null, *) = "any" |
| * StringUtils.replacePattern("any", *, null) = "any" |
| * StringUtils.replacePattern("", "", "zzz") = "zzz" |
| * StringUtils.replacePattern("", ".*", "zzz") = "zzz" |
| * StringUtils.replacePattern("", ".+", "zzz") = "" |
| * StringUtils.replacePattern("<__>\n<__>", "<.*>", "z") = "z" |
| * StringUtils.replacePattern("ABCabc123", "[a-z]", "_") = "ABC___123" |
| * StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_") = "ABC_123" |
| * StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "") = "ABC123" |
| * StringUtils.replacePattern("Lorem ipsum dolor sit", "( +)([a-z]+)", "_$2") = "Lorem_ipsum_dolor_sit" |
| * </pre> |
| * |
| * @param source |
| * the source string |
| * @param regex |
| * the regular expression to which this string is to be matched |
| * @param replacement |
| * the string to be substituted for each match |
| * @return The resulting {@link String} |
| * @see #replaceAll(String, String, String) |
| * @see String#replaceAll(String, String) |
| * @see Pattern#DOTALL |
| * @since 3.2 |
| * @since 3.5 Changed {@code null} reference passed to this method is a no-op. |
| * |
| * @deprecated Moved to RegExUtils. |
| */ |
| @Deprecated |
| public static String replacePattern(final String source, final String regex, final String replacement) { |
| return RegExUtils.replacePattern(source, regex, replacement); |
| } |
| |
| /** |
| * <p>Reverses a String as per {@link StringBuilder#reverse()}.</p> |
| * |
| * <p>A {@code null} String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.reverse(null) = null |
| * StringUtils.reverse("") = "" |
| * StringUtils.reverse("bat") = "tab" |
| * </pre> |
| * |
| * @param str the String to reverse, may be null |
| * @return the reversed String, {@code null} if null String input |
| */ |
| public static String reverse(final String str) { |
| if (str == null) { |
| return null; |
| } |
| return new StringBuilder(str).reverse().toString(); |
| } |
| |
| /** |
| * <p>Reverses a String that is delimited by a specific character.</p> |
| * |
| * <p>The Strings between the delimiters are not reversed. |
| * Thus java.lang.String becomes String.lang.java (if the delimiter |
| * is {@code '.'}).</p> |
| * |
| * <pre> |
| * StringUtils.reverseDelimited(null, *) = null |
| * StringUtils.reverseDelimited("", *) = "" |
| * StringUtils.reverseDelimited("a.b.c", 'x') = "a.b.c" |
| * StringUtils.reverseDelimited("a.b.c", ".") = "c.b.a" |
| * </pre> |
| * |
| * @param str the String to reverse, may be null |
| * @param separatorChar the separator character to use |
| * @return the reversed String, {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String reverseDelimited(final String str, final char separatorChar) { |
| if (str == null) { |
| return null; |
| } |
| // could implement manually, but simple way is to reuse other, |
| // probably slower, methods. |
| final String[] strs = split(str, separatorChar); |
| ArrayUtils.reverse(strs); |
| return join(strs, separatorChar); |
| } |
| |
| /** |
| * <p>Gets the rightmost {@code len} characters of a String.</p> |
| * |
| * <p>If {@code len} characters are not available, or the String |
| * is {@code null}, the String will be returned without an |
| * an exception. An empty String is returned if len is negative.</p> |
| * |
| * <pre> |
| * StringUtils.right(null, *) = null |
| * StringUtils.right(*, -ve) = "" |
| * StringUtils.right("", *) = "" |
| * StringUtils.right("abc", 0) = "" |
| * StringUtils.right("abc", 2) = "bc" |
| * StringUtils.right("abc", 4) = "abc" |
| * </pre> |
| * |
| * @param str the String to get the rightmost characters from, may be null |
| * @param len the length of the required String |
| * @return the rightmost characters, {@code null} if null String input |
| */ |
| public static String right(final String str, final int len) { |
| if (str == null) { |
| return null; |
| } |
| if (len < 0) { |
| return EMPTY; |
| } |
| if (str.length() <= len) { |
| return str; |
| } |
| return str.substring(str.length() - len); |
| } |
| |
| /** |
| * <p>Right pad a String with spaces (' ').</p> |
| * |
| * <p>The String is padded to the size of {@code size}.</p> |
| * |
| * <pre> |
| * StringUtils.rightPad(null, *) = null |
| * StringUtils.rightPad("", 3) = " " |
| * StringUtils.rightPad("bat", 3) = "bat" |
| * StringUtils.rightPad("bat", 5) = "bat " |
| * StringUtils.rightPad("bat", 1) = "bat" |
| * StringUtils.rightPad("bat", -1) = "bat" |
| * </pre> |
| * |
| * @param str the String to pad out, may be null |
| * @param size the size to pad to |
| * @return right padded String or original String if no padding is necessary, |
| * {@code null} if null String input |
| */ |
| public static String rightPad(final String str, final int size) { |
| return rightPad(str, size, ' '); |
| } |
| |
| /** |
| * <p>Right pad a String with a specified character.</p> |
| * |
| * <p>The String is padded to the size of {@code size}.</p> |
| * |
| * <pre> |
| * StringUtils.rightPad(null, *, *) = null |
| * StringUtils.rightPad("", 3, 'z') = "zzz" |
| * StringUtils.rightPad("bat", 3, 'z') = "bat" |
| * StringUtils.rightPad("bat", 5, 'z') = "batzz" |
| * StringUtils.rightPad("bat", 1, 'z') = "bat" |
| * StringUtils.rightPad("bat", -1, 'z') = "bat" |
| * </pre> |
| * |
| * @param str the String to pad out, may be null |
| * @param size the size to pad to |
| * @param padChar the character to pad with |
| * @return right padded String or original String if no padding is necessary, |
| * {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String rightPad(final String str, final int size, final char padChar) { |
| if (str == null) { |
| return null; |
| } |
| final int pads = size - str.length(); |
| if (pads <= 0) { |
| return str; // returns original String when possible |
| } |
| if (pads > PAD_LIMIT) { |
| return rightPad(str, size, String.valueOf(padChar)); |
| } |
| return str.concat(repeat(padChar, pads)); |
| } |
| |
| /** |
| * <p>Right pad a String with a specified String.</p> |
| * |
| * <p>The String is padded to the size of {@code size}.</p> |
| * |
| * <pre> |
| * StringUtils.rightPad(null, *, *) = null |
| * StringUtils.rightPad("", 3, "z") = "zzz" |
| * StringUtils.rightPad("bat", 3, "yz") = "bat" |
| * StringUtils.rightPad("bat", 5, "yz") = "batyz" |
| * StringUtils.rightPad("bat", 8, "yz") = "batyzyzy" |
| * StringUtils.rightPad("bat", 1, "yz") = "bat" |
| * StringUtils.rightPad("bat", -1, "yz") = "bat" |
| * StringUtils.rightPad("bat", 5, null) = "bat " |
| * StringUtils.rightPad("bat", 5, "") = "bat " |
| * </pre> |
| * |
| * @param str the String to pad out, may be null |
| * @param size the size to pad to |
| * @param padStr the String to pad with, null or empty treated as single space |
| * @return right padded String or original String if no padding is necessary, |
| * {@code null} if null String input |
| */ |
| public static String rightPad(final String str, final int size, String padStr) { |
| if (str == null) { |
| return null; |
| } |
| if (isEmpty(padStr)) { |
| padStr = SPACE; |
| } |
| final int padLen = padStr.length(); |
| final int strLen = str.length(); |
| final int pads = size - strLen; |
| if (pads <= 0) { |
| return str; // returns original String when possible |
| } |
| if (padLen == 1 && pads <= PAD_LIMIT) { |
| return rightPad(str, size, padStr.charAt(0)); |
| } |
| |
| if (pads == padLen) { |
| return str.concat(padStr); |
| } |
| if (pads < padLen) { |
| return str.concat(padStr.substring(0, pads)); |
| } |
| final char[] padding = new char[pads]; |
| final char[] padChars = padStr.toCharArray(); |
| for (int i = 0; i < pads; i++) { |
| padding[i] = padChars[i % padLen]; |
| } |
| return str.concat(new String(padding)); |
| } |
| |
| /** |
| * <p>Rotate (circular shift) a String of {@code shift} characters.</p> |
| * <ul> |
| * <li>If {@code shift > 0}, right circular shift (ex : ABCDEF => FABCDE)</li> |
| * <li>If {@code shift < 0}, left circular shift (ex : ABCDEF => BCDEFA)</li> |
| * </ul> |
| * |
| * <pre> |
| * StringUtils.rotate(null, *) = null |
| * StringUtils.rotate("", *) = "" |
| * StringUtils.rotate("abcdefg", 0) = "abcdefg" |
| * StringUtils.rotate("abcdefg", 2) = "fgabcde" |
| * StringUtils.rotate("abcdefg", -2) = "cdefgab" |
| * StringUtils.rotate("abcdefg", 7) = "abcdefg" |
| * StringUtils.rotate("abcdefg", -7) = "abcdefg" |
| * StringUtils.rotate("abcdefg", 9) = "fgabcde" |
| * StringUtils.rotate("abcdefg", -9) = "cdefgab" |
| * </pre> |
| * |
| * @param str the String to rotate, may be null |
| * @param shift number of time to shift (positive : right shift, negative : left shift) |
| * @return the rotated String, |
| * or the original String if {@code shift == 0}, |
| * or {@code null} if null String input |
| * @since 3.5 |
| */ |
| public static String rotate(final String str, final int shift) { |
| if (str == null) { |
| return null; |
| } |
| |
| final int strLen = str.length(); |
| if (shift == 0 || strLen == 0 || shift % strLen == 0) { |
| return str; |
| } |
| |
| final StringBuilder builder = new StringBuilder(strLen); |
| final int offset = - (shift % strLen); |
| builder.append(substring(str, offset)); |
| builder.append(substring(str, 0, offset)); |
| return builder.toString(); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, using whitespace as the |
| * separator. |
| * Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as one separator. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.split(null) = null |
| * StringUtils.split("") = [] |
| * StringUtils.split("abc def") = ["abc", "def"] |
| * StringUtils.split("abc def") = ["abc", "def"] |
| * StringUtils.split(" abc ") = ["abc"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @return an array of parsed Strings, {@code null} if null String input |
| */ |
| public static String[] split(final String str) { |
| return split(str, null, -1); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separator specified. |
| * This is an alternative to using StringTokenizer.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as one separator. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.split(null, *) = null |
| * StringUtils.split("", *) = [] |
| * StringUtils.split("a.b.c", '.') = ["a", "b", "c"] |
| * StringUtils.split("a..b.c", '.') = ["a", "b", "c"] |
| * StringUtils.split("a:b:c", '.') = ["a:b:c"] |
| * StringUtils.split("a b c", ' ') = ["a", "b", "c"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @param separatorChar the character used as the delimiter |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String[] split(final String str, final char separatorChar) { |
| return splitWorker(str, separatorChar, false); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separators specified. |
| * This is an alternative to using StringTokenizer.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as one separator. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separatorChars splits on whitespace.</p> |
| * |
| * <pre> |
| * StringUtils.split(null, *) = null |
| * StringUtils.split("", *) = [] |
| * StringUtils.split("abc def", null) = ["abc", "def"] |
| * StringUtils.split("abc def", " ") = ["abc", "def"] |
| * StringUtils.split("abc def", " ") = ["abc", "def"] |
| * StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @param separatorChars the characters used as the delimiters, |
| * {@code null} splits on whitespace |
| * @return an array of parsed Strings, {@code null} if null String input |
| */ |
| public static String[] split(final String str, final String separatorChars) { |
| return splitWorker(str, separatorChars, -1, false); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array with a maximum length, |
| * separators specified.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as one separator.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separatorChars splits on whitespace.</p> |
| * |
| * <p>If more than {@code max} delimited substrings are found, the last |
| * returned string includes all characters after the first {@code max - 1} |
| * returned strings (including separator characters).</p> |
| * |
| * <pre> |
| * StringUtils.split(null, *, *) = null |
| * StringUtils.split("", *, *) = [] |
| * StringUtils.split("ab cd ef", null, 0) = ["ab", "cd", "ef"] |
| * StringUtils.split("ab cd ef", null, 0) = ["ab", "cd", "ef"] |
| * StringUtils.split("ab:cd:ef", ":", 0) = ["ab", "cd", "ef"] |
| * StringUtils.split("ab:cd:ef", ":", 2) = ["ab", "cd:ef"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @param separatorChars the characters used as the delimiters, |
| * {@code null} splits on whitespace |
| * @param max the maximum number of elements to include in the |
| * array. A zero or negative value implies no limit |
| * @return an array of parsed Strings, {@code null} if null String input |
| */ |
| public static String[] split(final String str, final String separatorChars, final int max) { |
| return splitWorker(str, separatorChars, max, false); |
| } |
| |
| /** |
| * <p>Splits a String by Character type as returned by |
| * {@code java.lang.Character.getType(char)}. Groups of contiguous |
| * characters of the same type are returned as complete tokens. |
| * <pre> |
| * StringUtils.splitByCharacterType(null) = null |
| * StringUtils.splitByCharacterType("") = [] |
| * StringUtils.splitByCharacterType("ab de fg") = ["ab", " ", "de", " ", "fg"] |
| * StringUtils.splitByCharacterType("ab de fg") = ["ab", " ", "de", " ", "fg"] |
| * StringUtils.splitByCharacterType("ab:cd:ef") = ["ab", ":", "cd", ":", "ef"] |
| * StringUtils.splitByCharacterType("number5") = ["number", "5"] |
| * StringUtils.splitByCharacterType("fooBar") = ["foo", "B", "ar"] |
| * StringUtils.splitByCharacterType("foo200Bar") = ["foo", "200", "B", "ar"] |
| * StringUtils.splitByCharacterType("ASFRules") = ["ASFR", "ules"] |
| * </pre> |
| * @param str the String to split, may be {@code null} |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.4 |
| */ |
| public static String[] splitByCharacterType(final String str) { |
| return splitByCharacterType(str, false); |
| } |
| |
| /** |
| * <p>Splits a String by Character type as returned by |
| * {@code java.lang.Character.getType(char)}. Groups of contiguous |
| * characters of the same type are returned as complete tokens, with the |
| * following exception: if {@code camelCase} is {@code true}, |
| * the character of type {@code Character.UPPERCASE_LETTER}, if any, |
| * immediately preceding a token of type {@code Character.LOWERCASE_LETTER} |
| * will belong to the following token rather than to the preceding, if any, |
| * {@code Character.UPPERCASE_LETTER} token. |
| * @param str the String to split, may be {@code null} |
| * @param camelCase whether to use so-called "camel-case" for letter types |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.4 |
| */ |
| private static String[] splitByCharacterType(final String str, final boolean camelCase) { |
| if (str == null) { |
| return null; |
| } |
| if (str.isEmpty()) { |
| return ArrayUtils.EMPTY_STRING_ARRAY; |
| } |
| final char[] c = str.toCharArray(); |
| final List<String> list = new ArrayList<>(); |
| int tokenStart = 0; |
| int currentType = Character.getType(c[tokenStart]); |
| for (int pos = tokenStart + 1; pos < c.length; pos++) { |
| final int type = Character.getType(c[pos]); |
| if (type == currentType) { |
| continue; |
| } |
| if (camelCase && type == Character.LOWERCASE_LETTER && currentType == Character.UPPERCASE_LETTER) { |
| final int newTokenStart = pos - 1; |
| if (newTokenStart != tokenStart) { |
| list.add(new String(c, tokenStart, newTokenStart - tokenStart)); |
| tokenStart = newTokenStart; |
| } |
| } else { |
| list.add(new String(c, tokenStart, pos - tokenStart)); |
| tokenStart = pos; |
| } |
| currentType = type; |
| } |
| list.add(new String(c, tokenStart, c.length - tokenStart)); |
| return list.toArray(ArrayUtils.EMPTY_STRING_ARRAY); |
| } |
| |
| /** |
| * <p>Splits a String by Character type as returned by |
| * {@code java.lang.Character.getType(char)}. Groups of contiguous |
| * characters of the same type are returned as complete tokens, with the |
| * following exception: the character of type |
| * {@code Character.UPPERCASE_LETTER}, if any, immediately |
| * preceding a token of type {@code Character.LOWERCASE_LETTER} |
| * will belong to the following token rather than to the preceding, if any, |
| * {@code Character.UPPERCASE_LETTER} token. |
| * <pre> |
| * StringUtils.splitByCharacterTypeCamelCase(null) = null |
| * StringUtils.splitByCharacterTypeCamelCase("") = [] |
| * StringUtils.splitByCharacterTypeCamelCase("ab de fg") = ["ab", " ", "de", " ", "fg"] |
| * StringUtils.splitByCharacterTypeCamelCase("ab de fg") = ["ab", " ", "de", " ", "fg"] |
| * StringUtils.splitByCharacterTypeCamelCase("ab:cd:ef") = ["ab", ":", "cd", ":", "ef"] |
| * StringUtils.splitByCharacterTypeCamelCase("number5") = ["number", "5"] |
| * StringUtils.splitByCharacterTypeCamelCase("fooBar") = ["foo", "Bar"] |
| * StringUtils.splitByCharacterTypeCamelCase("foo200Bar") = ["foo", "200", "Bar"] |
| * StringUtils.splitByCharacterTypeCamelCase("ASFRules") = ["ASF", "Rules"] |
| * </pre> |
| * @param str the String to split, may be {@code null} |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.4 |
| */ |
| public static String[] splitByCharacterTypeCamelCase(final String str) { |
| return splitByCharacterType(str, true); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separator string specified.</p> |
| * |
| * <p>The separator(s) will not be included in the returned String array. |
| * Adjacent separators are treated as one separator.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separator splits on whitespace.</p> |
| * |
| * <pre> |
| * StringUtils.splitByWholeSeparator(null, *) = null |
| * StringUtils.splitByWholeSeparator("", *) = [] |
| * StringUtils.splitByWholeSeparator("ab de fg", null) = ["ab", "de", "fg"] |
| * StringUtils.splitByWholeSeparator("ab de fg", null) = ["ab", "de", "fg"] |
| * StringUtils.splitByWholeSeparator("ab:cd:ef", ":") = ["ab", "cd", "ef"] |
| * StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @param separator String containing the String to be used as a delimiter, |
| * {@code null} splits on whitespace |
| * @return an array of parsed Strings, {@code null} if null String was input |
| */ |
| public static String[] splitByWholeSeparator(final String str, final String separator) { |
| return splitByWholeSeparatorWorker(str, separator, -1, false); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separator string specified. |
| * Returns a maximum of {@code max} substrings.</p> |
| * |
| * <p>The separator(s) will not be included in the returned String array. |
| * Adjacent separators are treated as one separator.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separator splits on whitespace.</p> |
| * |
| * <pre> |
| * StringUtils.splitByWholeSeparator(null, *, *) = null |
| * StringUtils.splitByWholeSeparator("", *, *) = [] |
| * StringUtils.splitByWholeSeparator("ab de fg", null, 0) = ["ab", "de", "fg"] |
| * StringUtils.splitByWholeSeparator("ab de fg", null, 0) = ["ab", "de", "fg"] |
| * StringUtils.splitByWholeSeparator("ab:cd:ef", ":", 2) = ["ab", "cd:ef"] |
| * StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"] |
| * StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @param separator String containing the String to be used as a delimiter, |
| * {@code null} splits on whitespace |
| * @param max the maximum number of elements to include in the returned |
| * array. A zero or negative value implies no limit. |
| * @return an array of parsed Strings, {@code null} if null String was input |
| */ |
| public static String[] splitByWholeSeparator( final String str, final String separator, final int max) { |
| return splitByWholeSeparatorWorker(str, separator, max, false); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separator string specified. </p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as separators for empty tokens. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separator splits on whitespace.</p> |
| * |
| * <pre> |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens(null, *) = null |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("", *) = [] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null) = ["ab", "de", "fg"] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null) = ["ab", "", "", "de", "fg"] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":") = ["ab", "cd", "ef"] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @param separator String containing the String to be used as a delimiter, |
| * {@code null} splits on whitespace |
| * @return an array of parsed Strings, {@code null} if null String was input |
| * @since 2.4 |
| */ |
| public static String[] splitByWholeSeparatorPreserveAllTokens(final String str, final String separator) { |
| return splitByWholeSeparatorWorker(str, separator, -1, true); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separator string specified. |
| * Returns a maximum of {@code max} substrings.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as separators for empty tokens. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separator splits on whitespace.</p> |
| * |
| * <pre> |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens(null, *, *) = null |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("", *, *) = [] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null, 0) = ["ab", "de", "fg"] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null, 0) = ["ab", "", "", "de", "fg"] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":", 2) = ["ab", "cd:ef"] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"] |
| * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"] |
| * </pre> |
| * |
| * @param str the String to parse, may be null |
| * @param separator String containing the String to be used as a delimiter, |
| * {@code null} splits on whitespace |
| * @param max the maximum number of elements to include in the returned |
| * array. A zero or negative value implies no limit. |
| * @return an array of parsed Strings, {@code null} if null String was input |
| * @since 2.4 |
| */ |
| public static String[] splitByWholeSeparatorPreserveAllTokens(final String str, final String separator, final int max) { |
| return splitByWholeSeparatorWorker(str, separator, max, true); |
| } |
| |
| /** |
| * Performs the logic for the {@code splitByWholeSeparatorPreserveAllTokens} methods. |
| * |
| * @param str the String to parse, may be {@code null} |
| * @param separator String containing the String to be used as a delimiter, |
| * {@code null} splits on whitespace |
| * @param max the maximum number of elements to include in the returned |
| * array. A zero or negative value implies no limit. |
| * @param preserveAllTokens if {@code true}, adjacent separators are |
| * treated as empty token separators; if {@code false}, adjacent |
| * separators are treated as one separator. |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.4 |
| */ |
| private static String[] splitByWholeSeparatorWorker( |
| final String str, final String separator, final int max, final boolean preserveAllTokens) { |
| if (str == null) { |
| return null; |
| } |
| |
| final int len = str.length(); |
| |
| if (len == 0) { |
| return ArrayUtils.EMPTY_STRING_ARRAY; |
| } |
| |
| if (separator == null || EMPTY.equals(separator)) { |
| // Split on whitespace. |
| return splitWorker(str, null, max, preserveAllTokens); |
| } |
| |
| final int separatorLength = separator.length(); |
| |
| final ArrayList<String> substrings = new ArrayList<>(); |
| int numberOfSubstrings = 0; |
| int beg = 0; |
| int end = 0; |
| while (end < len) { |
| end = str.indexOf(separator, beg); |
| |
| if (end > -1) { |
| if (end > beg) { |
| numberOfSubstrings += 1; |
| |
| if (numberOfSubstrings == max) { |
| end = len; |
| substrings.add(str.substring(beg)); |
| } else { |
| // The following is OK, because String.substring( beg, end ) excludes |
| // the character at the position 'end'. |
| substrings.add(str.substring(beg, end)); |
| |
| // Set the starting point for the next search. |
| // The following is equivalent to beg = end + (separatorLength - 1) + 1, |
| // which is the right calculation: |
| beg = end + separatorLength; |
| } |
| } else { |
| // We found a consecutive occurrence of the separator, so skip it. |
| if (preserveAllTokens) { |
| numberOfSubstrings += 1; |
| if (numberOfSubstrings == max) { |
| end = len; |
| substrings.add(str.substring(beg)); |
| } else { |
| substrings.add(EMPTY); |
| } |
| } |
| beg = end + separatorLength; |
| } |
| } else { |
| // String.substring( beg ) goes from 'beg' to the end of the String. |
| substrings.add(str.substring(beg)); |
| end = len; |
| } |
| } |
| |
| return substrings.toArray(ArrayUtils.EMPTY_STRING_ARRAY); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, using whitespace as the |
| * separator, preserving all tokens, including empty tokens created by |
| * adjacent separators. This is an alternative to using StringTokenizer. |
| * Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as separators for empty tokens. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.splitPreserveAllTokens(null) = null |
| * StringUtils.splitPreserveAllTokens("") = [] |
| * StringUtils.splitPreserveAllTokens("abc def") = ["abc", "def"] |
| * StringUtils.splitPreserveAllTokens("abc def") = ["abc", "", "def"] |
| * StringUtils.splitPreserveAllTokens(" abc ") = ["", "abc", ""] |
| * </pre> |
| * |
| * @param str the String to parse, may be {@code null} |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String[] splitPreserveAllTokens(final String str) { |
| return splitWorker(str, null, -1, true); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separator specified, |
| * preserving all tokens, including empty tokens created by adjacent |
| * separators. This is an alternative to using StringTokenizer.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as separators for empty tokens. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.splitPreserveAllTokens(null, *) = null |
| * StringUtils.splitPreserveAllTokens("", *) = [] |
| * StringUtils.splitPreserveAllTokens("a.b.c", '.') = ["a", "b", "c"] |
| * StringUtils.splitPreserveAllTokens("a..b.c", '.') = ["a", "", "b", "c"] |
| * StringUtils.splitPreserveAllTokens("a:b:c", '.') = ["a:b:c"] |
| * StringUtils.splitPreserveAllTokens("a\tb\nc", null) = ["a", "b", "c"] |
| * StringUtils.splitPreserveAllTokens("a b c", ' ') = ["a", "b", "c"] |
| * StringUtils.splitPreserveAllTokens("a b c ", ' ') = ["a", "b", "c", ""] |
| * StringUtils.splitPreserveAllTokens("a b c ", ' ') = ["a", "b", "c", "", ""] |
| * StringUtils.splitPreserveAllTokens(" a b c", ' ') = ["", a", "b", "c"] |
| * StringUtils.splitPreserveAllTokens(" a b c", ' ') = ["", "", a", "b", "c"] |
| * StringUtils.splitPreserveAllTokens(" a b c ", ' ') = ["", a", "b", "c", ""] |
| * </pre> |
| * |
| * @param str the String to parse, may be {@code null} |
| * @param separatorChar the character used as the delimiter, |
| * {@code null} splits on whitespace |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String[] splitPreserveAllTokens(final String str, final char separatorChar) { |
| return splitWorker(str, separatorChar, true); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array, separators specified, |
| * preserving all tokens, including empty tokens created by adjacent |
| * separators. This is an alternative to using StringTokenizer.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as separators for empty tokens. |
| * For more control over the split use the StrTokenizer class.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separatorChars splits on whitespace.</p> |
| * |
| * <pre> |
| * StringUtils.splitPreserveAllTokens(null, *) = null |
| * StringUtils.splitPreserveAllTokens("", *) = [] |
| * StringUtils.splitPreserveAllTokens("abc def", null) = ["abc", "def"] |
| * StringUtils.splitPreserveAllTokens("abc def", " ") = ["abc", "def"] |
| * StringUtils.splitPreserveAllTokens("abc def", " ") = ["abc", "", def"] |
| * StringUtils.splitPreserveAllTokens("ab:cd:ef", ":") = ["ab", "cd", "ef"] |
| * StringUtils.splitPreserveAllTokens("ab:cd:ef:", ":") = ["ab", "cd", "ef", ""] |
| * StringUtils.splitPreserveAllTokens("ab:cd:ef::", ":") = ["ab", "cd", "ef", "", ""] |
| * StringUtils.splitPreserveAllTokens("ab::cd:ef", ":") = ["ab", "", cd", "ef"] |
| * StringUtils.splitPreserveAllTokens(":cd:ef", ":") = ["", cd", "ef"] |
| * StringUtils.splitPreserveAllTokens("::cd:ef", ":") = ["", "", cd", "ef"] |
| * StringUtils.splitPreserveAllTokens(":cd:ef:", ":") = ["", cd", "ef", ""] |
| * </pre> |
| * |
| * @param str the String to parse, may be {@code null} |
| * @param separatorChars the characters used as the delimiters, |
| * {@code null} splits on whitespace |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String[] splitPreserveAllTokens(final String str, final String separatorChars) { |
| return splitWorker(str, separatorChars, -1, true); |
| } |
| |
| /** |
| * <p>Splits the provided text into an array with a maximum length, |
| * separators specified, preserving all tokens, including empty tokens |
| * created by adjacent separators.</p> |
| * |
| * <p>The separator is not included in the returned String array. |
| * Adjacent separators are treated as separators for empty tokens. |
| * Adjacent separators are treated as one separator.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} separatorChars splits on whitespace.</p> |
| * |
| * <p>If more than {@code max} delimited substrings are found, the last |
| * returned string includes all characters after the first {@code max - 1} |
| * returned strings (including separator characters).</p> |
| * |
| * <pre> |
| * StringUtils.splitPreserveAllTokens(null, *, *) = null |
| * StringUtils.splitPreserveAllTokens("", *, *) = [] |
| * StringUtils.splitPreserveAllTokens("ab de fg", null, 0) = ["ab", "de", "fg"] |
| * StringUtils.splitPreserveAllTokens("ab de fg", null, 0) = ["ab", "", "", "de", "fg"] |
| * StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 0) = ["ab", "cd", "ef"] |
| * StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2) = ["ab", "cd:ef"] |
| * StringUtils.splitPreserveAllTokens("ab de fg", null, 2) = ["ab", " de fg"] |
| * StringUtils.splitPreserveAllTokens("ab de fg", null, 3) = ["ab", "", " de fg"] |
| * StringUtils.splitPreserveAllTokens("ab de fg", null, 4) = ["ab", "", "", "de fg"] |
| * </pre> |
| * |
| * @param str the String to parse, may be {@code null} |
| * @param separatorChars the characters used as the delimiters, |
| * {@code null} splits on whitespace |
| * @param max the maximum number of elements to include in the |
| * array. A zero or negative value implies no limit |
| * @return an array of parsed Strings, {@code null} if null String input |
| * @since 2.1 |
| */ |
| public static String[] splitPreserveAllTokens(final String str, final String separatorChars, final int max) { |
| return splitWorker(str, separatorChars, max, true); |
| } |
| |
| /** |
| * Performs the logic for the {@code split} and |
| * {@code splitPreserveAllTokens} methods that do not return a |
| * maximum array length. |
| * |
| * @param str the String to parse, may be {@code null} |
| * @param separatorChar the separate character |
| * @param preserveAllTokens if {@code true}, adjacent separators are |
| * treated as empty token separators; if {@code false}, adjacent |
| * separators are treated as one separator. |
| * @return an array of parsed Strings, {@code null} if null String input |
| */ |
| private static String[] splitWorker(final String str, final char separatorChar, final boolean preserveAllTokens) { |
| // Performance tuned for 2.0 (JDK1.4) |
| |
| if (str == null) { |
| return null; |
| } |
| final int len = str.length(); |
| if (len == 0) { |
| return ArrayUtils.EMPTY_STRING_ARRAY; |
| } |
| final List<String> list = new ArrayList<>(); |
| int i = 0; |
| int 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 list.toArray(ArrayUtils.EMPTY_STRING_ARRAY); |
| } |
| |
| /** |
| * Performs the logic for the {@code split} and |
| * {@code splitPreserveAllTokens} methods that return a maximum array |
| * length. |
| * |
| * @param str the String to parse, may be {@code null} |
| * @param separatorChars the separate character |
| * @param max the maximum number of elements to include in the |
| * array. A zero or negative value implies no limit. |
| * @param preserveAllTokens if {@code true}, adjacent separators are |
| * treated as empty token separators; if {@code false}, adjacent |
| * separators are treated as one separator. |
| * @return an array of parsed Strings, {@code null} if null String input |
| */ |
| private static String[] splitWorker(final String str, final String separatorChars, final int max, final boolean preserveAllTokens) { |
| // Performance tuned for 2.0 (JDK1.4) |
| // Direct code is quicker than StringTokenizer. |
| // Also, StringTokenizer uses isSpace() not isWhitespace() |
| |
| if (str == null) { |
| return null; |
| } |
| final int len = str.length(); |
| if (len == 0) { |
| return ArrayUtils.EMPTY_STRING_ARRAY; |
| } |
| final List<String> list = new ArrayList<>(); |
| int sizePlus1 = 1; |
| int i = 0; |
| int start = 0; |
| boolean match = false; |
| boolean lastMatch = false; |
| if (separatorChars == null) { |
| // Null separator means use whitespace |
| 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) { |
| // Optimise 1 character case |
| final 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 { |
| // standard case |
| 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 list.toArray(ArrayUtils.EMPTY_STRING_ARRAY); |
| } |
| |
| /** |
| * <p>Check if a CharSequence starts with a specified prefix.</p> |
| * |
| * <p>{@code null}s are handled without exceptions. Two {@code null} |
| * references are considered to be equal. The comparison is case-sensitive.</p> |
| * |
| * <pre> |
| * StringUtils.startsWith(null, null) = true |
| * StringUtils.startsWith(null, "abc") = false |
| * StringUtils.startsWith("abcdef", null) = false |
| * StringUtils.startsWith("abcdef", "abc") = true |
| * StringUtils.startsWith("ABCDEF", "abc") = false |
| * </pre> |
| * |
| * @see java.lang.String#startsWith(String) |
| * @param str the CharSequence to check, may be null |
| * @param prefix the prefix to find, may be null |
| * @return {@code true} if the CharSequence starts with the prefix, case-sensitive, or |
| * both {@code null} |
| * @since 2.4 |
| * @since 3.0 Changed signature from startsWith(String, String) to startsWith(CharSequence, CharSequence) |
| */ |
| public static boolean startsWith(final CharSequence str, final CharSequence prefix) { |
| return startsWith(str, prefix, false); |
| } |
| |
| /** |
| * <p>Check if a CharSequence starts with a specified prefix (optionally case insensitive).</p> |
| * |
| * @see java.lang.String#startsWith(String) |
| * @param str the CharSequence to check, may be null |
| * @param prefix the prefix to find, may be null |
| * @param ignoreCase indicates whether the compare should ignore case |
| * (case-insensitive) or not. |
| * @return {@code true} if the CharSequence starts with the prefix or |
| * both {@code null} |
| */ |
| private static boolean startsWith(final CharSequence str, final CharSequence prefix, final boolean ignoreCase) { |
| if (str == null || prefix == null) { |
| return str == prefix; |
| } |
| // Get length once instead of twice in the unlikely case that it changes. |
| final int preLen = prefix.length(); |
| if (preLen > str.length()) { |
| return false; |
| } |
| return CharSequenceUtils.regionMatches(str, ignoreCase, 0, prefix, 0, preLen); |
| } |
| |
| /** |
| * <p>Check if a CharSequence starts with any of the provided case-sensitive prefixes.</p> |
| * |
| * <pre> |
| * StringUtils.startsWithAny(null, null) = false |
| * StringUtils.startsWithAny(null, new String[] {"abc"}) = false |
| * StringUtils.startsWithAny("abcxyz", null) = false |
| * StringUtils.startsWithAny("abcxyz", new String[] {""}) = true |
| * StringUtils.startsWithAny("abcxyz", new String[] {"abc"}) = true |
| * StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true |
| * StringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX") = false |
| * StringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc") = false |
| * </pre> |
| * |
| * @param sequence the CharSequence to check, may be null |
| * @param searchStrings the case-sensitive CharSequence prefixes, may be empty or contain {@code null} |
| * @see StringUtils#startsWith(CharSequence, CharSequence) |
| * @return {@code true} if the input {@code sequence} is {@code null} AND no {@code searchStrings} are provided, or |
| * the input {@code sequence} begins with any of the provided case-sensitive {@code searchStrings}. |
| * @since 2.5 |
| * @since 3.0 Changed signature from startsWithAny(String, String[]) to startsWithAny(CharSequence, CharSequence...) |
| */ |
| public static boolean startsWithAny(final CharSequence sequence, final CharSequence... searchStrings) { |
| if (isEmpty(sequence) || ArrayUtils.isEmpty(searchStrings)) { |
| return false; |
| } |
| for (final CharSequence searchString : searchStrings) { |
| if (startsWith(sequence, searchString)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * <p>Case insensitive check if a CharSequence starts with a specified prefix.</p> |
| * |
| * <p>{@code null}s are handled without exceptions. Two {@code null} |
| * references are considered to be equal. The comparison is case insensitive.</p> |
| * |
| * <pre> |
| * StringUtils.startsWithIgnoreCase(null, null) = true |
| * StringUtils.startsWithIgnoreCase(null, "abc") = false |
| * StringUtils.startsWithIgnoreCase("abcdef", null) = false |
| * StringUtils.startsWithIgnoreCase("abcdef", "abc") = true |
| * StringUtils.startsWithIgnoreCase("ABCDEF", "abc") = true |
| * </pre> |
| * |
| * @see java.lang.String#startsWith(String) |
| * @param str the CharSequence to check, may be null |
| * @param prefix the prefix to find, may be null |
| * @return {@code true} if the CharSequence starts with the prefix, case-insensitive, or |
| * both {@code null} |
| * @since 2.4 |
| * @since 3.0 Changed signature from startsWithIgnoreCase(String, String) to startsWithIgnoreCase(CharSequence, CharSequence) |
| */ |
| public static boolean startsWithIgnoreCase(final CharSequence str, final CharSequence prefix) { |
| return startsWith(str, prefix, true); |
| } |
| |
| /** |
| * <p>Strips whitespace from the start and end of a String.</p> |
| * |
| * <p>This is similar to {@link #trim(String)} but removes whitespace. |
| * Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.strip(null) = null |
| * StringUtils.strip("") = "" |
| * StringUtils.strip(" ") = "" |
| * StringUtils.strip("abc") = "abc" |
| * StringUtils.strip(" abc") = "abc" |
| * StringUtils.strip("abc ") = "abc" |
| * StringUtils.strip(" abc ") = "abc" |
| * StringUtils.strip(" ab c ") = "ab c" |
| * </pre> |
| * |
| * @param str the String to remove whitespace from, may be null |
| * @return the stripped String, {@code null} if null String input |
| */ |
| public static String strip(final String str) { |
| return strip(str, null); |
| } |
| |
| /** |
| * <p>Strips any of a set of characters from the start and end of a String. |
| * This is similar to {@link String#trim()} but allows the characters |
| * to be stripped to be controlled.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * An empty string ("") input returns the empty string.</p> |
| * |
| * <p>If the stripChars String is {@code null}, whitespace is |
| * stripped as defined by {@link Character#isWhitespace(char)}. |
| * Alternatively use {@link #strip(String)}.</p> |
| * |
| * <pre> |
| * StringUtils.strip(null, *) = null |
| * StringUtils.strip("", *) = "" |
| * StringUtils.strip("abc", null) = "abc" |
| * StringUtils.strip(" abc", null) = "abc" |
| * StringUtils.strip("abc ", null) = "abc" |
| * StringUtils.strip(" abc ", null) = "abc" |
| * StringUtils.strip(" abcyx", "xyz") = " abc" |
| * </pre> |
| * |
| * @param str the String to remove characters from, may be null |
| * @param stripChars the characters to remove, null treated as whitespace |
| * @return the stripped String, {@code null} if null String input |
| */ |
| public static String strip(String str, final String stripChars) { |
| str = stripStart(str, stripChars); |
| return stripEnd(str, stripChars); |
| } |
| |
| /** |
| * <p>Removes diacritics (~= accents) from a string. The case will not be altered.</p> |
| * <p>For instance, 'à' will be replaced by 'a'.</p> |
| * <p>Note that ligatures will be left as is.</p> |
| * |
| * <pre> |
| * StringUtils.stripAccents(null) = null |
| * StringUtils.stripAccents("") = "" |
| * StringUtils.stripAccents("control") = "control" |
| * StringUtils.stripAccents("éclair") = "eclair" |
| * </pre> |
| * |
| * @param input String to be stripped |
| * @return input text with diacritics removed |
| * |
| * @since 3.0 |
| */ |
| // See also Lucene's ASCIIFoldingFilter (Lucene 2.9) that replaces accented characters by their unaccented equivalent (and uncommitted bug fix: https://issues.apache.org/jira/browse/LUCENE-1343?focusedCommentId=12858907&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_12858907). |
| public static String stripAccents(final String input) { |
| if (input == null) { |
| return null; |
| } |
| final StringBuilder decomposed = new StringBuilder(Normalizer.normalize(input, Normalizer.Form.NFD)); |
| convertRemainingAccentCharacters(decomposed); |
| // Note that this doesn't correctly remove ligatures... |
| return STRIP_ACCENTS_PATTERN.matcher(decomposed).replaceAll(EMPTY); |
| } |
| |
| /** |
| * <p>Strips whitespace from the start and end of every String in an array. |
| * Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>A new array is returned each time, except for length zero. |
| * A {@code null} array will return {@code null}. |
| * An empty array will return itself. |
| * A {@code null} array entry will be ignored.</p> |
| * |
| * <pre> |
| * StringUtils.stripAll(null) = null |
| * StringUtils.stripAll([]) = [] |
| * StringUtils.stripAll(["abc", " abc"]) = ["abc", "abc"] |
| * StringUtils.stripAll(["abc ", null]) = ["abc", null] |
| * </pre> |
| * |
| * @param strs the array to remove whitespace from, may be null |
| * @return the stripped Strings, {@code null} if null array input |
| */ |
| public static String[] stripAll(final String... strs) { |
| return stripAll(strs, null); |
| } |
| |
| /** |
| * <p>Strips any of a set of characters from the start and end of every |
| * String in an array.</p> |
| * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <p>A new array is returned each time, except for length zero. |
| * A {@code null} array will return {@code null}. |
| * An empty array will return itself. |
| * A {@code null} array entry will be ignored. |
| * A {@code null} stripChars will strip whitespace as defined by |
| * {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.stripAll(null, *) = null |
| * StringUtils.stripAll([], *) = [] |
| * StringUtils.stripAll(["abc", " abc"], null) = ["abc", "abc"] |
| * StringUtils.stripAll(["abc ", null], null) = ["abc", null] |
| * StringUtils.stripAll(["abc ", null], "yz") = ["abc ", null] |
| * StringUtils.stripAll(["yabcz", null], "yz") = ["abc", null] |
| * </pre> |
| * |
| * @param strs the array to remove characters from, may be null |
| * @param stripChars the characters to remove, null treated as whitespace |
| * @return the stripped Strings, {@code null} if null array input |
| */ |
| public static String[] stripAll(final String[] strs, final String stripChars) { |
| final int strsLen = ArrayUtils.getLength(strs); |
| if (strsLen == 0) { |
| return strs; |
| } |
| final String[] newArr = new String[strsLen]; |
| for (int i = 0; i < strsLen; i++) { |
| newArr[i] = strip(strs[i], stripChars); |
| } |
| return newArr; |
| } |
| |
| /** |
| * <p>Strips any of a set of characters from the end of a String.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * An empty string ("") input returns the empty string.</p> |
| * |
| * <p>If the stripChars String is {@code null}, whitespace is |
| * stripped as defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.stripEnd(null, *) = null |
| * StringUtils.stripEnd("", *) = "" |
| * StringUtils.stripEnd("abc", "") = "abc" |
| * StringUtils.stripEnd("abc", null) = "abc" |
| * StringUtils.stripEnd(" abc", null) = " abc" |
| * StringUtils.stripEnd("abc ", null) = "abc" |
| * StringUtils.stripEnd(" abc ", null) = " abc" |
| * StringUtils.stripEnd(" abcyx", "xyz") = " abc" |
| * StringUtils.stripEnd("120.00", ".0") = "12" |
| * </pre> |
| * |
| * @param str the String to remove characters from, may be null |
| * @param stripChars the set of characters to remove, null treated as whitespace |
| * @return the stripped String, {@code null} if null String input |
| */ |
| public static String stripEnd(final String str, final String stripChars) { |
| int end = length(str); |
| if (end == 0) { |
| return str; |
| } |
| |
| if (stripChars == null) { |
| while (end != 0 && Character.isWhitespace(str.charAt(end - 1))) { |
| end--; |
| } |
| } else if (stripChars.isEmpty()) { |
| return str; |
| } else { |
| while (end != 0 && stripChars.indexOf(str.charAt(end - 1)) != INDEX_NOT_FOUND) { |
| end--; |
| } |
| } |
| return str.substring(0, end); |
| } |
| |
| /** |
| * <p>Strips any of a set of characters from the start of a String.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * An empty string ("") input returns the empty string.</p> |
| * |
| * <p>If the stripChars String is {@code null}, whitespace is |
| * stripped as defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.stripStart(null, *) = null |
| * StringUtils.stripStart("", *) = "" |
| * StringUtils.stripStart("abc", "") = "abc" |
| * StringUtils.stripStart("abc", null) = "abc" |
| * StringUtils.stripStart(" abc", null) = "abc" |
| * StringUtils.stripStart("abc ", null) = "abc " |
| * StringUtils.stripStart(" abc ", null) = "abc " |
| * StringUtils.stripStart("yxabc ", "xyz") = "abc " |
| * </pre> |
| * |
| * @param str the String to remove characters from, may be null |
| * @param stripChars the characters to remove, null treated as whitespace |
| * @return the stripped String, {@code null} if null String input |
| */ |
| public static String stripStart(final String str, final String stripChars) { |
| final int strLen = length(str); |
| if (strLen == 0) { |
| return str; |
| } |
| int start = 0; |
| if (stripChars == null) { |
| while (start != strLen && Character.isWhitespace(str.charAt(start))) { |
| start++; |
| } |
| } else if (stripChars.isEmpty()) { |
| return str; |
| } else { |
| while (start != strLen && stripChars.indexOf(str.charAt(start)) != INDEX_NOT_FOUND) { |
| start++; |
| } |
| } |
| return str.substring(start); |
| } |
| |
| /** |
| * <p>Strips whitespace from the start and end of a String returning |
| * an empty String if {@code null} input.</p> |
| * |
| * <p>This is similar to {@link #trimToEmpty(String)} but removes whitespace. |
| * Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.stripToEmpty(null) = "" |
| * StringUtils.stripToEmpty("") = "" |
| * StringUtils.stripToEmpty(" ") = "" |
| * StringUtils.stripToEmpty("abc") = "abc" |
| * StringUtils.stripToEmpty(" abc") = "abc" |
| * StringUtils.stripToEmpty("abc ") = "abc" |
| * StringUtils.stripToEmpty(" abc ") = "abc" |
| * StringUtils.stripToEmpty(" ab c ") = "ab c" |
| * </pre> |
| * |
| * @param str the String to be stripped, may be null |
| * @return the trimmed String, or an empty String if {@code null} input |
| * @since 2.0 |
| */ |
| public static String stripToEmpty(final String str) { |
| return str == null ? EMPTY : strip(str, null); |
| } |
| |
| /** |
| * <p>Strips whitespace from the start and end of a String returning |
| * {@code null} if the String is empty ("") after the strip.</p> |
| * |
| * <p>This is similar to {@link #trimToNull(String)} but removes whitespace. |
| * Whitespace is defined by {@link Character#isWhitespace(char)}.</p> |
| * |
| * <pre> |
| * StringUtils.stripToNull(null) = null |
| * StringUtils.stripToNull("") = null |
| * StringUtils.stripToNull(" ") = null |
| * StringUtils.stripToNull("abc") = "abc" |
| * StringUtils.stripToNull(" abc") = "abc" |
| * StringUtils.stripToNull("abc ") = "abc" |
| * StringUtils.stripToNull(" abc ") = "abc" |
| * StringUtils.stripToNull(" ab c ") = "ab c" |
| * </pre> |
| * |
| * @param str the String to be stripped, may be null |
| * @return the stripped String, |
| * {@code null} if whitespace, empty or null String input |
| * @since 2.0 |
| */ |
| public static String stripToNull(String str) { |
| if (str == null) { |
| return null; |
| } |
| str = strip(str, null); |
| return str.isEmpty() ? null : str; // NOSONARLINT str cannot be null here |
| } |
| |
| /** |
| * <p>Gets a substring from the specified String avoiding exceptions.</p> |
| * |
| * <p>A negative start position can be used to start {@code n} |
| * characters from the end of the String.</p> |
| * |
| * <p>A {@code null} String will return {@code null}. |
| * An empty ("") String will return "".</p> |
| * |
| * <pre> |
| * StringUtils.substring(null, *) = null |
| * StringUtils.substring("", *) = "" |
| * StringUtils.substring("abc", 0) = "abc" |
| * StringUtils.substring("abc", 2) = "c" |
| * StringUtils.substring("abc", 4) = "" |
| * StringUtils.substring("abc", -2) = "bc" |
| * StringUtils.substring("abc", -4) = "abc" |
| * </pre> |
| * |
| * @param str the String to get the substring from, may be null |
| * @param start the position to start from, negative means |
| * count back from the end of the String by this many characters |
| * @return substring from start position, {@code null} if null String input |
| */ |
| public static String substring(final String str, int start) { |
| if (str == null) { |
| return null; |
| } |
| |
| // handle negatives, which means last n characters |
| if (start < 0) { |
| start = str.length() + start; // remember start is negative |
| } |
| |
| if (start < 0) { |
| start = 0; |
| } |
| if (start > str.length()) { |
| return EMPTY; |
| } |
| |
| return str.substring(start); |
| } |
| |
| /** |
| * <p>Gets a substring from the specified String avoiding exceptions.</p> |
| * |
| * <p>A negative start position can be used to start/end {@code n} |
| * characters from the end of the String.</p> |
| * |
| * <p>The returned substring starts with the character in the {@code start} |
| * position and ends before the {@code end} position. All position counting is |
| * zero-based -- i.e., to start at the beginning of the string use |
| * {@code start = 0}. Negative start and end positions can be used to |
| * specify offsets relative to the end of the String.</p> |
| * |
| * <p>If {@code start} is not strictly to the left of {@code end}, "" |
| * is returned.</p> |
| * |
| * <pre> |
| * StringUtils.substring(null, *, *) = null |
| * StringUtils.substring("", * , *) = ""; |
| * StringUtils.substring("abc", 0, 2) = "ab" |
| * StringUtils.substring("abc", 2, 0) = "" |
| * StringUtils.substring("abc", 2, 4) = "c" |
| * StringUtils.substring("abc", 4, 6) = "" |
| * StringUtils.substring("abc", 2, 2) = "" |
| * StringUtils.substring("abc", -2, -1) = "b" |
| * StringUtils.substring("abc", -4, 2) = "ab" |
| * </pre> |
| * |
| * @param str the String to get the substring from, may be null |
| * @param start the position to start from, negative means |
| * count back from the end of the String by this many characters |
| * @param end the position to end at (exclusive), negative means |
| * count back from the end of the String by this many characters |
| * @return substring from start position to end position, |
| * {@code null} if null String input |
| */ |
| public static String substring(final String str, int start, int end) { |
| if (str == null) { |
| return null; |
| } |
| |
| // handle negatives |
| if (end < 0) { |
| end = str.length() + end; // remember end is negative |
| } |
| if (start < 0) { |
| start = str.length() + start; // remember start is negative |
| } |
| |
| // check length next |
| if (end > str.length()) { |
| end = str.length(); |
| } |
| |
| // if start is greater than end, return "" |
| if (start > end) { |
| return EMPTY; |
| } |
| |
| if (start < 0) { |
| start = 0; |
| } |
| if (end < 0) { |
| end = 0; |
| } |
| |
| return str.substring(start, end); |
| } |
| |
| /** |
| * <p>Gets the substring after the first occurrence of a separator. |
| * The separator is not returned.</p> |
| * |
| * <p>A {@code null} string input will return {@code null}. |
| * An empty ("") string input will return the empty string. |
| * |
| * <p>If nothing is found, the empty string is returned.</p> |
| * |
| * <pre> |
| * StringUtils.substringAfter(null, *) = null |
| * StringUtils.substringAfter("", *) = "" |
| * StringUtils.substringAfter("abc", 'a') = "bc" |
| * StringUtils.substringAfter("abcba", 'b') = "cba" |
| * StringUtils.substringAfter("abc", 'c') = "" |
| * StringUtils.substringAfter("abc", 'd') = "" |
| * StringUtils.substringAfter(" abc", 32) = "abc" |
| * </pre> |
| * |
| * @param str the String to get a substring from, may be null |
| * @param separator the character (Unicode code point) to search. |
| * @return the substring after the first occurrence of the separator, |
| * {@code null} if null String input |
| * @since 3.11 |
| */ |
| public static String substringAfter(final String str, final int separator) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| final int pos = str.indexOf(separator); |
| if (pos == INDEX_NOT_FOUND) { |
| return EMPTY; |
| } |
| return str.substring(pos + 1); |
| } |
| |
| /** |
| * <p>Gets the substring after the first occurrence of a separator. |
| * The separator is not returned.</p> |
| * |
| * <p>A {@code null} string input will return {@code null}. |
| * An empty ("") string input will return the empty string. |
| * A {@code null} separator will return the empty string if the |
| * input string is not {@code null}.</p> |
| * |
| * <p>If nothing is found, the empty string is returned.</p> |
| * |
| * <pre> |
| * StringUtils.substringAfter(null, *) = null |
| * StringUtils.substringAfter("", *) = "" |
| * StringUtils.substringAfter(*, null) = "" |
| * StringUtils.substringAfter("abc", "a") = "bc" |
| * StringUtils.substringAfter("abcba", "b") = "cba" |
| * StringUtils.substringAfter("abc", "c") = "" |
| * StringUtils.substringAfter("abc", "d") = "" |
| * StringUtils.substringAfter("abc", "") = "abc" |
| * </pre> |
| * |
| * @param str the String to get a substring from, may be null |
| * @param separator the String to search for, may be null |
| * @return the substring after the first occurrence of the separator, |
| * {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String substringAfter(final String str, final String separator) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| if (separator == null) { |
| return EMPTY; |
| } |
| final int pos = str.indexOf(separator); |
| if (pos == INDEX_NOT_FOUND) { |
| return EMPTY; |
| } |
| return str.substring(pos + separator.length()); |
| } |
| |
| /** |
| * <p>Gets the substring after the last occurrence of a separator. |
| * The separator is not returned.</p> |
| * |
| * <p>A {@code null} string input will return {@code null}. |
| * An empty ("") string input will return the empty string. |
| * |
| * <p>If nothing is found, the empty string is returned.</p> |
| * |
| * <pre> |
| * StringUtils.substringAfterLast(null, *) = null |
| * StringUtils.substringAfterLast("", *) = "" |
| * StringUtils.substringAfterLast("abc", 'a') = "bc" |
| * StringUtils.substringAfterLast(" bc", 32) = "bc" |
| * StringUtils.substringAfterLast("abcba", 'b') = "a" |
| * StringUtils.substringAfterLast("abc", 'c') = "" |
| * StringUtils.substringAfterLast("a", 'a') = "" |
| * StringUtils.substringAfterLast("a", 'z') = "" |
| * </pre> |
| * |
| * @param str the String to get a substring from, may be null |
| * @param separator the character (Unicode code point) to search. |
| * @return the substring after the last occurrence of the separator, |
| * {@code null} if null String input |
| * @since 3.11 |
| */ |
| public static String substringAfterLast(final String str, final int separator) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| final int pos = str.lastIndexOf(separator); |
| if (pos == INDEX_NOT_FOUND || pos == str.length() - 1) { |
| return EMPTY; |
| } |
| return str.substring(pos + 1); |
| } |
| |
| /** |
| * <p>Gets the substring after the last occurrence of a separator. |
| * The separator is not returned.</p> |
| * |
| * <p>A {@code null} string input will return {@code null}. |
| * An empty ("") string input will return the empty string. |
| * An empty or {@code null} separator will return the empty string if |
| * the input string is not {@code null}.</p> |
| * |
| * <p>If nothing is found, the empty string is returned.</p> |
| * |
| * <pre> |
| * StringUtils.substringAfterLast(null, *) = null |
| * StringUtils.substringAfterLast("", *) = "" |
| * StringUtils.substringAfterLast(*, "") = "" |
| * StringUtils.substringAfterLast(*, null) = "" |
| * StringUtils.substringAfterLast("abc", "a") = "bc" |
| * StringUtils.substringAfterLast("abcba", "b") = "a" |
| * StringUtils.substringAfterLast("abc", "c") = "" |
| * StringUtils.substringAfterLast("a", "a") = "" |
| * StringUtils.substringAfterLast("a", "z") = "" |
| * </pre> |
| * |
| * @param str the String to get a substring from, may be null |
| * @param separator the String to search for, may be null |
| * @return the substring after the last occurrence of the separator, |
| * {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String substringAfterLast(final String str, final String separator) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| if (isEmpty(separator)) { |
| return EMPTY; |
| } |
| final int pos = str.lastIndexOf(separator); |
| if (pos == INDEX_NOT_FOUND || pos == str.length() - separator.length()) { |
| return EMPTY; |
| } |
| return str.substring(pos + separator.length()); |
| } |
| |
| /** |
| * <p> |
| * Gets the substring before the first occurrence of a separator. The separator is not returned. |
| * </p> |
| * |
| * <p> |
| * A {@code null} string input will return {@code null}. An empty ("") string input will return the empty string. |
| * </p> |
| * |
| * <p> |
| * If nothing is found, the string input is returned. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.substringBefore(null, *) = null |
| * StringUtils.substringBefore("", *) = "" |
| * StringUtils.substringBefore("abc", 'a') = "" |
| * StringUtils.substringBefore("abcba", 'b') = "a" |
| * StringUtils.substringBefore("abc", 'c') = "ab" |
| * StringUtils.substringBefore("abc", 'd') = "abc" |
| * </pre> |
| * |
| * @param str the String to get a substring from, may be null |
| * @param separator the character (Unicode code point) to search. |
| * @return the substring before the first occurrence of the separator, {@code null} if null String input |
| * @since 3.12.0 |
| */ |
| public static String substringBefore(final String str, final int separator) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| final int pos = str.indexOf(separator); |
| if (pos == INDEX_NOT_FOUND) { |
| return str; |
| } |
| return str.substring(0, pos); |
| } |
| |
| /** |
| * <p>Gets the substring before the first occurrence of a separator. |
| * The separator is not returned.</p> |
| * |
| * <p>A {@code null} string input will return {@code null}. |
| * An empty ("") string input will return the empty string. |
| * A {@code null} separator will return the input string.</p> |
| * |
| * <p>If nothing is found, the string input is returned.</p> |
| * |
| * <pre> |
| * StringUtils.substringBefore(null, *) = null |
| * StringUtils.substringBefore("", *) = "" |
| * StringUtils.substringBefore("abc", "a") = "" |
| * StringUtils.substringBefore("abcba", "b") = "a" |
| * StringUtils.substringBefore("abc", "c") = "ab" |
| * StringUtils.substringBefore("abc", "d") = "abc" |
| * StringUtils.substringBefore("abc", "") = "" |
| * StringUtils.substringBefore("abc", null) = "abc" |
| * </pre> |
| * |
| * @param str the String to get a substring from, may be null |
| * @param separator the String to search for, may be null |
| * @return the substring before the first occurrence of the separator, |
| * {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String substringBefore(final String str, final String separator) { |
| if (isEmpty(str) || separator == null) { |
| return str; |
| } |
| if (separator.isEmpty()) { |
| return EMPTY; |
| } |
| final int pos = str.indexOf(separator); |
| if (pos == INDEX_NOT_FOUND) { |
| return str; |
| } |
| return str.substring(0, pos); |
| } |
| |
| /** |
| * <p>Gets the substring before the last occurrence of a separator. |
| * The separator is not returned.</p> |
| * |
| * <p>A {@code null} string input will return {@code null}. |
| * An empty ("") string input will return the empty string. |
| * An empty or {@code null} separator will return the input string.</p> |
| * |
| * <p>If nothing is found, the string input is returned.</p> |
| * |
| * <pre> |
| * StringUtils.substringBeforeLast(null, *) = null |
| * StringUtils.substringBeforeLast("", *) = "" |
| * StringUtils.substringBeforeLast("abcba", "b") = "abc" |
| * StringUtils.substringBeforeLast("abc", "c") = "ab" |
| * StringUtils.substringBeforeLast("a", "a") = "" |
| * StringUtils.substringBeforeLast("a", "z") = "a" |
| * StringUtils.substringBeforeLast("a", null) = "a" |
| * StringUtils.substringBeforeLast("a", "") = "a" |
| * </pre> |
| * |
| * @param str the String to get a substring from, may be null |
| * @param separator the String to search for, may be null |
| * @return the substring before the last occurrence of the separator, |
| * {@code null} if null String input |
| * @since 2.0 |
| */ |
| public static String substringBeforeLast(final String str, final String separator) { |
| if (isEmpty(str) || isEmpty(separator)) { |
| return str; |
| } |
| final int pos = str.lastIndexOf(separator); |
| if (pos == INDEX_NOT_FOUND) { |
| return str; |
| } |
| return str.substring(0, pos); |
| } |
| |
| /** |
| * <p>Gets the String that is nested in between two instances of the |
| * same String.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} tag returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.substringBetween(null, *) = null |
| * StringUtils.substringBetween("", "") = "" |
| * StringUtils.substringBetween("", "tag") = null |
| * StringUtils.substringBetween("tagabctag", null) = null |
| * StringUtils.substringBetween("tagabctag", "") = "" |
| * StringUtils.substringBetween("tagabctag", "tag") = "abc" |
| * </pre> |
| * |
| * @param str the String containing the substring, may be null |
| * @param tag the String before and after the substring, may be null |
| * @return the substring, {@code null} if no match |
| * @since 2.0 |
| */ |
| public static String substringBetween(final String str, final String tag) { |
| return substringBetween(str, tag, tag); |
| } |
| |
| /** |
| * <p>Gets the String that is nested in between two Strings. |
| * Only the first match is returned.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} open/close returns {@code null} (no match). |
| * An empty ("") open and close returns an empty string.</p> |
| * |
| * <pre> |
| * StringUtils.substringBetween("wx[b]yz", "[", "]") = "b" |
| * StringUtils.substringBetween(null, *, *) = null |
| * StringUtils.substringBetween(*, null, *) = null |
| * StringUtils.substringBetween(*, *, null) = null |
| * StringUtils.substringBetween("", "", "") = "" |
| * StringUtils.substringBetween("", "", "]") = null |
| * StringUtils.substringBetween("", "[", "]") = null |
| * StringUtils.substringBetween("yabcz", "", "") = "" |
| * StringUtils.substringBetween("yabcz", "y", "z") = "abc" |
| * StringUtils.substringBetween("yabczyabcz", "y", "z") = "abc" |
| * </pre> |
| * |
| * @param str the String containing the substring, may be null |
| * @param open the String before the substring, may be null |
| * @param close the String after the substring, may be null |
| * @return the substring, {@code null} if no match |
| * @since 2.0 |
| */ |
| public static String substringBetween(final String str, final String open, final String close) { |
| if (!ObjectUtils.allNotNull(str, open, close)) { |
| return null; |
| } |
| final int start = str.indexOf(open); |
| if (start != INDEX_NOT_FOUND) { |
| final int end = str.indexOf(close, start + open.length()); |
| if (end != INDEX_NOT_FOUND) { |
| return str.substring(start + open.length(), end); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * <p>Searches a String for substrings delimited by a start and end tag, |
| * returning all matching substrings in an array.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}. |
| * A {@code null} open/close returns {@code null} (no match). |
| * An empty ("") open/close returns {@code null} (no match).</p> |
| * |
| * <pre> |
| * StringUtils.substringsBetween("[a][b][c]", "[", "]") = ["a","b","c"] |
| * StringUtils.substringsBetween(null, *, *) = null |
| * StringUtils.substringsBetween(*, null, *) = null |
| * StringUtils.substringsBetween(*, *, null) = null |
| * StringUtils.substringsBetween("", "[", "]") = [] |
| * </pre> |
| * |
| * @param str the String containing the substrings, null returns null, empty returns empty |
| * @param open the String identifying the start of the substring, empty returns null |
| * @param close the String identifying the end of the substring, empty returns null |
| * @return a String Array of substrings, or {@code null} if no match |
| * @since 2.3 |
| */ |
| public static String[] substringsBetween(final String str, final String open, final String close) { |
| if (str == null || isEmpty(open) || isEmpty(close)) { |
| return null; |
| } |
| final int strLen = str.length(); |
| if (strLen == 0) { |
| return ArrayUtils.EMPTY_STRING_ARRAY; |
| } |
| final int closeLen = close.length(); |
| final int openLen = open.length(); |
| final List<String> list = new ArrayList<>(); |
| int pos = 0; |
| while (pos < strLen - closeLen) { |
| int start = str.indexOf(open, pos); |
| if (start < 0) { |
| break; |
| } |
| start += openLen; |
| final int end = str.indexOf(close, start); |
| if (end < 0) { |
| break; |
| } |
| list.add(str.substring(start, end)); |
| pos = end + closeLen; |
| } |
| if (list.isEmpty()) { |
| return null; |
| } |
| return list.toArray(ArrayUtils.EMPTY_STRING_ARRAY); |
| } |
| |
| /** |
| * <p>Swaps the case of a String changing upper and title case to |
| * lower case, and lower case to upper case.</p> |
| * |
| * <ul> |
| * <li>Upper case character converts to Lower case</li> |
| * <li>Title case character converts to Lower case</li> |
| * <li>Lower case character converts to Upper case</li> |
| * </ul> |
| * |
| * <p>For a word based algorithm, see {@link org.apache.commons.text.WordUtils#swapCase(String)}. |
| * A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.swapCase(null) = null |
| * StringUtils.swapCase("") = "" |
| * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone" |
| * </pre> |
| * |
| * <p>NOTE: This method changed in Lang version 2.0. |
| * It no longer performs a word based algorithm. |
| * If you only use ASCII, you will notice no change. |
| * That functionality is available in org.apache.commons.lang3.text.WordUtils.</p> |
| * |
| * @param str the String to swap case, may be null |
| * @return the changed String, {@code null} if null String input |
| */ |
| public static String swapCase(final String str) { |
| if (isEmpty(str)) { |
| return str; |
| } |
| |
| final int strLen = str.length(); |
| final int[] newCodePoints = new int[strLen]; // cannot be longer than the char array |
| int outOffset = 0; |
| for (int i = 0; i < strLen; ) { |
| final int oldCodepoint = str.codePointAt(i); |
| final int newCodePoint; |
| if (Character.isUpperCase(oldCodepoint) || Character.isTitleCase(oldCodepoint)) { |
| newCodePoint = Character.toLowerCase(oldCodepoint); |
| } else if (Character.isLowerCase(oldCodepoint)) { |
| newCodePoint = Character.toUpperCase(oldCodepoint); |
| } else { |
| newCodePoint = oldCodepoint; |
| } |
| newCodePoints[outOffset++] = newCodePoint; |
| i += Character.charCount(newCodePoint); |
| } |
| return new String(newCodePoints, 0, outOffset); |
| } |
| |
| /** |
| * <p>Converts a {@link CharSequence} into an array of code points.</p> |
| * |
| * <p>Valid pairs of surrogate code units will be converted into a single supplementary |
| * code point. Isolated surrogate code units (i.e. a high surrogate not followed by a low surrogate or |
| * a low surrogate not preceded by a high surrogate) will be returned as-is.</p> |
| * |
| * <pre> |
| * StringUtils.toCodePoints(null) = null |
| * StringUtils.toCodePoints("") = [] // empty array |
| * </pre> |
| * |
| * @param cs the character sequence to convert |
| * @return an array of code points |
| * @since 3.6 |
| */ |
| public static int[] toCodePoints(final CharSequence cs) { |
| if (cs == null) { |
| return null; |
| } |
| if (cs.length() == 0) { |
| return ArrayUtils.EMPTY_INT_ARRAY; |
| } |
| |
| final String s = cs.toString(); |
| final int[] result = new int[s.codePointCount(0, s.length())]; |
| int index = 0; |
| for (int i = 0; i < result.length; i++) { |
| result[i] = s.codePointAt(index); |
| index += Character.charCount(result[i]); |
| } |
| return result; |
| } |
| |
| /** |
| * Converts a {@code byte[]} to a String using the specified character encoding. |
| * |
| * @param bytes |
| * the byte array to read from |
| * @param charset |
| * the encoding to use, if null then use the platform default |
| * @return a new String |
| * @throws NullPointerException |
| * if {@code bytes} is null |
| * @since 3.2 |
| * @since 3.3 No longer throws {@link UnsupportedEncodingException}. |
| */ |
| public static String toEncodedString(final byte[] bytes, final Charset charset) { |
| return new String(bytes, Charsets.toCharset(charset)); |
| } |
| |
| /** |
| * Converts the given source String as a lower-case using the {@link Locale#ROOT} locale in a null-safe manner. |
| * |
| * @param source A source String or null. |
| * @return the given source String as a lower-case using the {@link Locale#ROOT} locale or null. |
| * @since 3.10 |
| */ |
| public static String toRootLowerCase(final String source) { |
| return source == null ? null : source.toLowerCase(Locale.ROOT); |
| } |
| |
| /** |
| * Converts the given source String as a upper-case using the {@link Locale#ROOT} locale in a null-safe manner. |
| * |
| * @param source A source String or null. |
| * @return the given source String as a upper-case using the {@link Locale#ROOT} locale or null. |
| * @since 3.10 |
| */ |
| public static String toRootUpperCase(final String source) { |
| return source == null ? null : source.toUpperCase(Locale.ROOT); |
| } |
| |
| /** |
| * Converts a {@code byte[]} to a String using the specified character encoding. |
| * |
| * @param bytes |
| * the byte array to read from |
| * @param charsetName |
| * the encoding to use, if null then use the platform default |
| * @return a new String |
| * @throws UnsupportedEncodingException |
| * If the named charset is not supported |
| * @throws NullPointerException |
| * if the input is null |
| * @deprecated use {@link StringUtils#toEncodedString(byte[], Charset)} instead of String constants in your code |
| * @since 3.1 |
| */ |
| @Deprecated |
| public static String toString(final byte[] bytes, final String charsetName) throws UnsupportedEncodingException { |
| return new String(bytes, Charsets.toCharset(charsetName)); |
| } |
| |
| private static String toStringOrEmpty(final Object obj) { |
| return Objects.toString(obj, EMPTY); |
| } |
| |
| /** |
| * <p>Removes control characters (char <= 32) from both |
| * ends of this String, handling {@code null} by returning |
| * {@code null}.</p> |
| * |
| * <p>The String is trimmed using {@link String#trim()}. |
| * Trim removes start and end characters <= 32. |
| * To strip whitespace use {@link #strip(String)}.</p> |
| * |
| * <p>To trim your choice of characters, use the |
| * {@link #strip(String, String)} methods.</p> |
| * |
| * <pre> |
| * StringUtils.trim(null) = null |
| * StringUtils.trim("") = "" |
| * StringUtils.trim(" ") = "" |
| * StringUtils.trim("abc") = "abc" |
| * StringUtils.trim(" abc ") = "abc" |
| * </pre> |
| * |
| * @param str the String to be trimmed, may be null |
| * @return the trimmed string, {@code null} if null String input |
| */ |
| public static String trim(final String str) { |
| return str == null ? null : str.trim(); |
| } |
| |
| /** |
| * <p>Removes control characters (char <= 32) from both |
| * ends of this String returning an empty String ("") if the String |
| * is empty ("") after the trim or if it is {@code null}. |
| * |
| * <p>The String is trimmed using {@link String#trim()}. |
| * Trim removes start and end characters <= 32. |
| * To strip whitespace use {@link #stripToEmpty(String)}.</p> |
| * |
| * <pre> |
| * StringUtils.trimToEmpty(null) = "" |
| * StringUtils.trimToEmpty("") = "" |
| * StringUtils.trimToEmpty(" ") = "" |
| * StringUtils.trimToEmpty("abc") = "abc" |
| * StringUtils.trimToEmpty(" abc ") = "abc" |
| * </pre> |
| * |
| * @param str the String to be trimmed, may be null |
| * @return the trimmed String, or an empty String if {@code null} input |
| * @since 2.0 |
| */ |
| public static String trimToEmpty(final String str) { |
| return str == null ? EMPTY : str.trim(); |
| } |
| |
| /** |
| * <p>Removes control characters (char <= 32) from both |
| * ends of this String returning {@code null} if the String is |
| * empty ("") after the trim or if it is {@code null}. |
| * |
| * <p>The String is trimmed using {@link String#trim()}. |
| * Trim removes start and end characters <= 32. |
| * To strip whitespace use {@link #stripToNull(String)}.</p> |
| * |
| * <pre> |
| * StringUtils.trimToNull(null) = null |
| * StringUtils.trimToNull("") = null |
| * StringUtils.trimToNull(" ") = null |
| * StringUtils.trimToNull("abc") = "abc" |
| * StringUtils.trimToNull(" abc ") = "abc" |
| * </pre> |
| * |
| * @param str the String to be trimmed, may be null |
| * @return the trimmed String, |
| * {@code null} if only chars <= 32, empty or null String input |
| * @since 2.0 |
| */ |
| public static String trimToNull(final String str) { |
| final String ts = trim(str); |
| return isEmpty(ts) ? null : ts; |
| } |
| |
| /** |
| * <p>Truncates a String. This will turn |
| * "Now is the time for all good men" into "Now is the time for".</p> |
| * |
| * <p>Specifically:</p> |
| * <ul> |
| * <li>If {@code str} is less than {@code maxWidth} characters |
| * long, return it.</li> |
| * <li>Else truncate it to {@code substring(str, 0, maxWidth)}.</li> |
| * <li>If {@code maxWidth} is less than {@code 0}, throw an |
| * {@link IllegalArgumentException}.</li> |
| * <li>In no case will it return a String of length greater than |
| * {@code maxWidth}.</li> |
| * </ul> |
| * |
| * <pre> |
| * StringUtils.truncate(null, 0) = null |
| * StringUtils.truncate(null, 2) = null |
| * StringUtils.truncate("", 4) = "" |
| * StringUtils.truncate("abcdefg", 4) = "abcd" |
| * StringUtils.truncate("abcdefg", 6) = "abcdef" |
| * StringUtils.truncate("abcdefg", 7) = "abcdefg" |
| * StringUtils.truncate("abcdefg", 8) = "abcdefg" |
| * StringUtils.truncate("abcdefg", -1) = throws an IllegalArgumentException |
| * </pre> |
| * |
| * @param str the String to truncate, may be null |
| * @param maxWidth maximum length of result String, must be positive |
| * @return truncated String, {@code null} if null String input |
| * @throws IllegalArgumentException If {@code maxWidth} is less than {@code 0} |
| * @since 3.5 |
| */ |
| public static String truncate(final String str, final int maxWidth) { |
| return truncate(str, 0, maxWidth); |
| } |
| |
| /** |
| * <p>Truncates a String. This will turn |
| * "Now is the time for all good men" into "is the time for all".</p> |
| * |
| * <p>Works like {@code truncate(String, int)}, but allows you to specify |
| * a "left edge" offset. |
| * |
| * <p>Specifically:</p> |
| * <ul> |
| * <li>If {@code str} is less than {@code maxWidth} characters |
| * long, return it.</li> |
| * <li>Else truncate it to {@code substring(str, offset, maxWidth)}.</li> |
| * <li>If {@code maxWidth} is less than {@code 0}, throw an |
| * {@link IllegalArgumentException}.</li> |
| * <li>If {@code offset} is less than {@code 0}, throw an |
| * {@link IllegalArgumentException}.</li> |
| * <li>In no case will it return a String of length greater than |
| * {@code maxWidth}.</li> |
| * </ul> |
| * |
| * <pre> |
| * StringUtils.truncate(null, 0, 0) = null |
| * StringUtils.truncate(null, 2, 4) = null |
| * StringUtils.truncate("", 0, 10) = "" |
| * StringUtils.truncate("", 2, 10) = "" |
| * StringUtils.truncate("abcdefghij", 0, 3) = "abc" |
| * StringUtils.truncate("abcdefghij", 5, 6) = "fghij" |
| * StringUtils.truncate("raspberry peach", 10, 15) = "peach" |
| * StringUtils.truncate("abcdefghijklmno", 0, 10) = "abcdefghij" |
| * StringUtils.truncate("abcdefghijklmno", -1, 10) = throws an IllegalArgumentException |
| * StringUtils.truncate("abcdefghijklmno", Integer.MIN_VALUE, 10) = throws an IllegalArgumentException |
| * StringUtils.truncate("abcdefghijklmno", Integer.MIN_VALUE, Integer.MAX_VALUE) = throws an IllegalArgumentException |
| * StringUtils.truncate("abcdefghijklmno", 0, Integer.MAX_VALUE) = "abcdefghijklmno" |
| * StringUtils.truncate("abcdefghijklmno", 1, 10) = "bcdefghijk" |
| * StringUtils.truncate("abcdefghijklmno", 2, 10) = "cdefghijkl" |
| * StringUtils.truncate("abcdefghijklmno", 3, 10) = "defghijklm" |
| * StringUtils.truncate("abcdefghijklmno", 4, 10) = "efghijklmn" |
| * StringUtils.truncate("abcdefghijklmno", 5, 10) = "fghijklmno" |
| * StringUtils.truncate("abcdefghijklmno", 5, 5) = "fghij" |
| * StringUtils.truncate("abcdefghijklmno", 5, 3) = "fgh" |
| * StringUtils.truncate("abcdefghijklmno", 10, 3) = "klm" |
| * StringUtils.truncate("abcdefghijklmno", 10, Integer.MAX_VALUE) = "klmno" |
| * StringUtils.truncate("abcdefghijklmno", 13, 1) = "n" |
| * StringUtils.truncate("abcdefghijklmno", 13, Integer.MAX_VALUE) = "no" |
| * StringUtils.truncate("abcdefghijklmno", 14, 1) = "o" |
| * StringUtils.truncate("abcdefghijklmno", 14, Integer.MAX_VALUE) = "o" |
| * StringUtils.truncate("abcdefghijklmno", 15, 1) = "" |
| * StringUtils.truncate("abcdefghijklmno", 15, Integer.MAX_VALUE) = "" |
| * StringUtils.truncate("abcdefghijklmno", Integer.MAX_VALUE, Integer.MAX_VALUE) = "" |
| * StringUtils.truncate("abcdefghij", 3, -1) = throws an IllegalArgumentException |
| * StringUtils.truncate("abcdefghij", -2, 4) = throws an IllegalArgumentException |
| * </pre> |
| * |
| * @param str the String to truncate, may be null |
| * @param offset left edge of source String |
| * @param maxWidth maximum length of result String, must be positive |
| * @return truncated String, {@code null} if null String input |
| * @throws IllegalArgumentException If {@code offset} or {@code maxWidth} is less than {@code 0} |
| * @since 3.5 |
| */ |
| public static String truncate(final String str, final int offset, final int maxWidth) { |
| if (offset < 0) { |
| throw new IllegalArgumentException("offset cannot be negative"); |
| } |
| if (maxWidth < 0) { |
| throw new IllegalArgumentException("maxWith cannot be negative"); |
| } |
| if (str == null) { |
| return null; |
| } |
| if (offset > str.length()) { |
| return EMPTY; |
| } |
| if (str.length() > maxWidth) { |
| final int ix = Math.min(offset + maxWidth, str.length()); |
| return str.substring(offset, ix); |
| } |
| return str.substring(offset); |
| } |
| |
| /** |
| * <p>Uncapitalizes a String, changing the first character to lower case as |
| * per {@link Character#toLowerCase(int)}. No other characters are changed.</p> |
| * |
| * <p>For a word based algorithm, see {@link org.apache.commons.text.WordUtils#uncapitalize(String)}. |
| * A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.uncapitalize(null) = null |
| * StringUtils.uncapitalize("") = "" |
| * StringUtils.uncapitalize("cat") = "cat" |
| * StringUtils.uncapitalize("Cat") = "cat" |
| * StringUtils.uncapitalize("CAT") = "cAT" |
| * </pre> |
| * |
| * @param str the String to uncapitalize, may be null |
| * @return the uncapitalized String, {@code null} if null String input |
| * @see org.apache.commons.text.WordUtils#uncapitalize(String) |
| * @see #capitalize(String) |
| * @since 2.0 |
| */ |
| public static String uncapitalize(final String str) { |
| final int strLen = length(str); |
| if (strLen == 0) { |
| return str; |
| } |
| |
| final int firstCodePoint = str.codePointAt(0); |
| final int newCodePoint = Character.toLowerCase(firstCodePoint); |
| if (firstCodePoint == newCodePoint) { |
| // already capitalized |
| return str; |
| } |
| |
| final int[] newCodePoints = new int[strLen]; // cannot be longer than the char array |
| int outOffset = 0; |
| newCodePoints[outOffset++] = newCodePoint; // copy the first code point |
| for (int inOffset = Character.charCount(firstCodePoint); inOffset < strLen; ) { |
| final int codePoint = str.codePointAt(inOffset); |
| newCodePoints[outOffset++] = codePoint; // copy the remaining ones |
| inOffset += Character.charCount(codePoint); |
| } |
| return new String(newCodePoints, 0, outOffset); |
| } |
| |
| /** |
| * <p> |
| * Unwraps a given string from a character. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.unwrap(null, null) = null |
| * StringUtils.unwrap(null, '\0') = null |
| * StringUtils.unwrap(null, '1') = null |
| * StringUtils.unwrap("a", 'a') = "a" |
| * StringUtils.unwrap("aa", 'a') = "" |
| * StringUtils.unwrap("\'abc\'", '\'') = "abc" |
| * StringUtils.unwrap("AABabcBAA", 'A') = "ABabcBA" |
| * StringUtils.unwrap("A", '#') = "A" |
| * StringUtils.unwrap("#A", '#') = "#A" |
| * StringUtils.unwrap("A#", '#') = "A#" |
| * </pre> |
| * |
| * @param str |
| * the String to be unwrapped, can be null |
| * @param wrapChar |
| * the character used to unwrap |
| * @return unwrapped String or the original string |
| * if it is not quoted properly with the wrapChar |
| * @since 3.6 |
| */ |
| public static String unwrap(final String str, final char wrapChar) { |
| if (isEmpty(str) || wrapChar == CharUtils.NUL || str.length() == 1) { |
| return str; |
| } |
| |
| if (str.charAt(0) == wrapChar && str.charAt(str.length() - 1) == wrapChar) { |
| final int startIndex = 0; |
| final int endIndex = str.length() - 1; |
| |
| return str.substring(startIndex + 1, endIndex); |
| } |
| |
| return str; |
| } |
| |
| /** |
| * <p> |
| * Unwraps a given string from anther string. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.unwrap(null, null) = null |
| * StringUtils.unwrap(null, "") = null |
| * StringUtils.unwrap(null, "1") = null |
| * StringUtils.unwrap("a", "a") = "a" |
| * StringUtils.unwrap("aa", "a") = "" |
| * StringUtils.unwrap("\'abc\'", "\'") = "abc" |
| * StringUtils.unwrap("\"abc\"", "\"") = "abc" |
| * StringUtils.unwrap("AABabcBAA", "AA") = "BabcB" |
| * StringUtils.unwrap("A", "#") = "A" |
| * StringUtils.unwrap("#A", "#") = "#A" |
| * StringUtils.unwrap("A#", "#") = "A#" |
| * </pre> |
| * |
| * @param str |
| * the String to be unwrapped, can be null |
| * @param wrapToken |
| * the String used to unwrap |
| * @return unwrapped String or the original string |
| * if it is not quoted properly with the wrapToken |
| * @since 3.6 |
| */ |
| public static String unwrap(final String str, final String wrapToken) { |
| if (isEmpty(str) || isEmpty(wrapToken) || str.length() < 2 * wrapToken.length()) { |
| return str; |
| } |
| |
| if (startsWith(str, wrapToken) && endsWith(str, wrapToken)) { |
| return str.substring(wrapToken.length(), str.lastIndexOf(wrapToken)); |
| } |
| |
| return str; |
| } |
| |
| /** |
| * <p>Converts a String to upper case as per {@link String#toUpperCase()}.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.upperCase(null) = null |
| * StringUtils.upperCase("") = "" |
| * StringUtils.upperCase("aBc") = "ABC" |
| * </pre> |
| * |
| * <p><strong>Note:</strong> As described in the documentation for {@link String#toUpperCase()}, |
| * the result of this method is affected by the current locale. |
| * For platform-independent case transformations, the method {@link #upperCase(String, Locale)} |
| * should be used with a specific locale (e.g. {@link Locale#ENGLISH}).</p> |
| * |
| * @param str the String to upper case, may be null |
| * @return the upper-cased String, {@code null} if null String input |
| */ |
| public static String upperCase(final String str) { |
| if (str == null) { |
| return null; |
| } |
| return str.toUpperCase(); |
| } |
| |
| /** |
| * <p>Converts a String to upper case as per {@link String#toUpperCase(Locale)}.</p> |
| * |
| * <p>A {@code null} input String returns {@code null}.</p> |
| * |
| * <pre> |
| * StringUtils.upperCase(null, Locale.ENGLISH) = null |
| * StringUtils.upperCase("", Locale.ENGLISH) = "" |
| * StringUtils.upperCase("aBc", Locale.ENGLISH) = "ABC" |
| * </pre> |
| * |
| * @param str the String to upper case, may be null |
| * @param locale the locale that defines the case transformation rules, must not be null |
| * @return the upper-cased String, {@code null} if null String input |
| * @since 2.5 |
| */ |
| public static String upperCase(final String str, final Locale locale) { |
| if (str == null) { |
| return null; |
| } |
| return str.toUpperCase(LocaleUtils.toLocale(locale)); |
| } |
| |
| /** |
| * Returns the string representation of the {@code char} array or null. |
| * |
| * @param value the character array. |
| * @return a String or null |
| * @see String#valueOf(char[]) |
| * @since 3.9 |
| */ |
| public static String valueOf(final char[] value) { |
| return value == null ? null : String.valueOf(value); |
| } |
| |
| /** |
| * <p> |
| * Wraps a string with a char. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.wrap(null, *) = null |
| * StringUtils.wrap("", *) = "" |
| * StringUtils.wrap("ab", '\0') = "ab" |
| * StringUtils.wrap("ab", 'x') = "xabx" |
| * StringUtils.wrap("ab", '\'') = "'ab'" |
| * StringUtils.wrap("\"ab\"", '\"') = "\"\"ab\"\"" |
| * </pre> |
| * |
| * @param str |
| * the string to be wrapped, may be {@code null} |
| * @param wrapWith |
| * the char that will wrap {@code str} |
| * @return the wrapped string, or {@code null} if {@code str==null} |
| * @since 3.4 |
| */ |
| public static String wrap(final String str, final char wrapWith) { |
| |
| if (isEmpty(str) || wrapWith == CharUtils.NUL) { |
| return str; |
| } |
| |
| return wrapWith + str + wrapWith; |
| } |
| |
| /** |
| * <p> |
| * Wraps a String with another String. |
| * </p> |
| * |
| * <p> |
| * A {@code null} input String returns {@code null}. |
| * </p> |
| * |
| * <pre> |
| * StringUtils.wrap(null, *) = null |
| * StringUtils.wrap("", *) = "" |
| * StringUtils.wrap("ab", null) = "ab" |
| * StringUtils.wrap("ab", "x") = "xabx" |
| * StringUtils.wrap("ab", "\"") = "\"ab\"" |
| * StringUtils.wrap("\"ab\"", "\"") = "\"\"ab\"\"" |
| * StringUtils.wrap("ab", "'") = "'ab'" |
| * StringUtils.wrap("'abcd'", "'") = "''abcd''" |
| * StringUtils.wrap("\"abcd\"", "'") = "'\"abcd\"'" |
| * StringUtils.wrap("'abcd'", "\"") = "\"'abcd'\"" |
| * </pre> |
| * |
| * @param str |
| * the String to be wrapper, may be null |
| * @param wrapWith |
| * the String that will wrap str |
| * @return wrapped String, {@code null} if null String input |
| * @since 3.4 |
| */ |
| public static String wrap(final String str, final String wrapWith) { |
| |
| if (isEmpty(str) || isEmpty(wrapWith)) { |
| return str; |
| } |
| |
| return wrapWith.concat(str).concat(wrapWith); |
| } |
| |
| /** |
| * <p> |
| * Wraps a string with a char if that char is missing from the start or end of the given string. |
| * </p> |
| * |
| * <p>A new {@link String} will not be created if {@code str} is already wrapped.</p> |
| * |
| * <pre> |
| * StringUtils.wrapIfMissing(null, *) = null |
| * StringUtils.wrapIfMissing("", *) = "" |
| * StringUtils.wrapIfMissing("ab", '\0') = "ab" |
| * StringUtils.wrapIfMissing("ab", 'x') = "xabx" |
| * StringUtils.wrapIfMissing("ab", '\'') = "'ab'" |
| * StringUtils.wrapIfMissing("\"ab\"", '\"') = "\"ab\"" |
| * StringUtils.wrapIfMissing("/", '/') = "/" |
| * StringUtils.wrapIfMissing("a/b/c", '/') = "/a/b/c/" |
| * StringUtils.wrapIfMissing("/a/b/c", '/') = "/a/b/c/" |
| * StringUtils.wrapIfMissing("a/b/c/", '/') = "/a/b/c/" |
| * </pre> |
| * |
| * @param str |
| * the string to be wrapped, may be {@code null} |
| * @param wrapWith |
| * the char that will wrap {@code str} |
| * @return the wrapped string, or {@code null} if {@code str==null} |
| * @since 3.5 |
| */ |
| public static String wrapIfMissing(final String str, final char wrapWith) { |
| if (isEmpty(str) || wrapWith == CharUtils.NUL) { |
| return str; |
| } |
| final boolean wrapStart = str.charAt(0) != wrapWith; |
| final boolean wrapEnd = str.charAt(str.length() - 1) != wrapWith; |
| if (!wrapStart && !wrapEnd) { |
| return str; |
| } |
| |
| final StringBuilder builder = new StringBuilder(str.length() + 2); |
| if (wrapStart) { |
| builder.append(wrapWith); |
| } |
| builder.append(str); |
| if (wrapEnd) { |
| builder.append(wrapWith); |
| } |
| return builder.toString(); |
| } |
| |
| /** |
| * <p> |
| * Wraps a string with a string if that string is missing from the start or end of the given string. |
| * </p> |
| * |
| * <p>A new {@link String} will not be created if {@code str} is already wrapped.</p> |
| * |
| * <pre> |
| * StringUtils.wrapIfMissing(null, *) = null |
| * StringUtils.wrapIfMissing("", *) = "" |
| * StringUtils.wrapIfMissing("ab", null) = "ab" |
| * StringUtils.wrapIfMissing("ab", "x") = "xabx" |
| * StringUtils.wrapIfMissing("ab", "\"") = "\"ab\"" |
| * StringUtils.wrapIfMissing("\"ab\"", "\"") = "\"ab\"" |
| * StringUtils.wrapIfMissing("ab", "'") = "'ab'" |
| * StringUtils.wrapIfMissing("'abcd'", "'") = "'abcd'" |
| * StringUtils.wrapIfMissing("\"abcd\"", "'") = "'\"abcd\"'" |
| * StringUtils.wrapIfMissing("'abcd'", "\"") = "\"'abcd'\"" |
| * StringUtils.wrapIfMissing("/", "/") = "/" |
| * StringUtils.wrapIfMissing("a/b/c", "/") = "/a/b/c/" |
| * StringUtils.wrapIfMissing("/a/b/c", "/") = "/a/b/c/" |
| * StringUtils.wrapIfMissing("a/b/c/", "/") = "/a/b/c/" |
| * </pre> |
| * |
| * @param str |
| * the string to be wrapped, may be {@code null} |
| * @param wrapWith |
| * the string that will wrap {@code str} |
| * @return the wrapped string, or {@code null} if {@code str==null} |
| * @since 3.5 |
| */ |
| public static String wrapIfMissing(final String str, final String wrapWith) { |
| if (isEmpty(str) || isEmpty(wrapWith)) { |
| return str; |
| } |
| |
| final boolean wrapStart = !str.startsWith(wrapWith); |
| final boolean wrapEnd = !str.endsWith(wrapWith); |
| if (!wrapStart && !wrapEnd) { |
| return str; |
| } |
| |
| final StringBuilder builder = new StringBuilder(str.length() + wrapWith.length() + wrapWith.length()); |
| if (wrapStart) { |
| builder.append(wrapWith); |
| } |
| builder.append(str); |
| if (wrapEnd) { |
| builder.append(wrapWith); |
| } |
| return builder.toString(); |
| } |
| |
| /** |
| * <p>{@link StringUtils} instances should NOT be constructed in |
| * standard programming. Instead, the class should be used as |
| * {@code StringUtils.trim(" foo ");}.</p> |
| * |
| * <p>This constructor is public to permit tools that require a JavaBean |
| * instance to operate.</p> |
| */ |
| public StringUtils() { |
| } |
| |
| } |