mirrors/public-transport-enabler
1
0
Fork 0
mirror of https://gitlab.com/oeffi/public-transport-enabler.git synced 2025-07-14 16:40:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Format WordUtils.

Browse source
This commit is contained in:
Andreas Schildbach 2015-01-21 12:35:44 +01:00
parent 55d41dfd69
commit 0eb20e5838
1 changed files with 480 additions and 384 deletions
Download patch file Download diff file Expand all files Collapse all files

360
enabler/src/de/schildbach/pte/util/WordUtils.java
View file

@ -14,36 +14,45 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package de.schildbach.pte.util; package de.schildbach.pte.util;
/** /**
* <p>Operations on Strings that contain words.</p> * <p>
* Operations on Strings that contain words.
* </p>
* *
* <p>This class tries to handle <code>null</code> input gracefully. * <p>
* An exception will not be thrown for a <code>null</code> input. * This class tries to handle <code>null</code> input gracefully. An exception will not be thrown for a
* Each method documents its behaviour in more detail.</p> * <code>null</code> input. Each method documents its behaviour in more detail.
* </p>
* *
* @since 2.0 * @since 2.0
* @version $Id$ * @version $Id$
*/ */
public class WordUtils { public class WordUtils
{
/** /**
* <p><code>WordUtils</code> instances should NOT be constructed in * <p>
* standard programming. Instead, the class should be used as * <code>WordUtils</code> instances should NOT be constructed in standard programming. Instead, the class should be
* <code>WordUtils.wrap("foo bar", 20);</code>.</p> * used as <code>WordUtils.wrap("foo bar", 20);</code>.
* </p>
* *
* <p>This constructor is public to permit tools that require a JavaBean * <p>
* instance to operate.</p> * This constructor is public to permit tools that require a JavaBean instance to operate.
* </p>
*/ */
public WordUtils() { public WordUtils()
{
super(); super();
} }
// Empty checks, taken from StringUtils // Empty checks, taken from StringUtils
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
/** /**
* <p>Checks if a CharSequence is empty ("") or null.</p> * <p>
* Checks if a CharSequence is empty ("") or null.
* </p>
* *
* <pre> * <pre>
* StringUtils.isEmpty(null) = true * StringUtils.isEmpty(null) = true
@ -53,15 +62,18 @@ public class WordUtils {
* StringUtils.isEmpty(" bob ") = false * StringUtils.isEmpty(" bob ") = false
* </pre> * </pre>
* *
* <p>NOTE: This method changed in Lang version 2.0. * <p>
* It no longer trims the CharSequence. * NOTE: This method changed in Lang version 2.0. It no longer trims the CharSequence. That functionality is
* That functionality is available in isBlank().</p> * available in isBlank().
* </p>
* *
* @param cs the CharSequence to check, may be null * @param cs
* the CharSequence to check, may be null
* @return {@code true} if the CharSequence is empty or null * @return {@code true} if the CharSequence is empty or null
* @since 3.0 Changed signature from isEmpty(String) to isEmpty(CharSequence) * @since 3.0 Changed signature from isEmpty(String) to isEmpty(CharSequence)
*/ */
public static boolean isEmpty(final CharSequence cs) { public static boolean isEmpty(final CharSequence cs)
{
return cs == null || cs.length() == 0; return cs == null || cs.length() == 0;
} }
@ -72,15 +84,15 @@ public class WordUtils {
// Capitalizing // Capitalizing
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
/** /**
* <p>Capitalizes all the whitespace separated words in a String. * <p>
* Only the first letter of each word is changed. To convert the * Capitalizes all the whitespace separated words in a String. Only the first letter of each word is changed. To
* rest of each word to lowercase at the same time, * convert the rest of each word to lowercase at the same time, use {@link #capitalizeFully(String)}.
* use {@link #capitalizeFully(String)}.</p> * </p>
* *
* <p>Whitespace is defined by {@link Character#isWhitespace(char)}. * <p>
* A <code>null</code> input String returns <code>null</code>. * Whitespace is defined by {@link Character#isWhitespace(char)}. A <code>null</code> input String returns
* Capitalization uses the Unicode title case, normally equivalent to * <code>null</code>. Capitalization uses the Unicode title case, normally equivalent to upper case.
* upper case.</p> * </p>
* *
* <pre> * <pre>
* WordUtils.capitalize(null) = null * WordUtils.capitalize(null) = null
@ -88,28 +100,32 @@ public class WordUtils {
* WordUtils.capitalize("i am FINE") = "I Am FINE" * WordUtils.capitalize("i am FINE") = "I Am FINE"
* </pre> * </pre>
* *
* @param str the String to capitalize, may be null * @param str
* the String to capitalize, may be null
* @return capitalized String, <code>null</code> if null String input * @return capitalized String, <code>null</code> if null String input
* @see #uncapitalize(String) * @see #uncapitalize(String)
* @see #capitalizeFully(String) * @see #capitalizeFully(String)
*/ */
public static String capitalize(final String str) { public static String capitalize(final String str)
{
return capitalize(str, null); return capitalize(str, null);
} }
/** /**
* <p>Capitalizes all the delimiter separated words in a String. * <p>
* Only the first letter of each word is changed. To convert the * Capitalizes all the delimiter separated words in a String. Only the first letter of each word is changed. To
* rest of each word to lowercase at the same time, * convert the rest of each word to lowercase at the same time, use {@link #capitalizeFully(String, char[])}.
* use {@link #capitalizeFully(String, char[])}.</p> * </p>
* *
* <p>The delimiters represent a set of characters understood to separate words. * <p>
* The first string character and the first non-delimiter character after a * The delimiters represent a set of characters understood to separate words. The first string character and the
* delimiter will be capitalized. </p> * first non-delimiter character after a delimiter will be capitalized.
* </p>
* *
* <p>A <code>null</code> input String returns <code>null</code>. * <p>
* Capitalization uses the Unicode title case, normally equivalent to * A <code>null</code> input String returns <code>null</code>. Capitalization uses the Unicode title case, normally
* upper case.</p> * equivalent to upper case.
* </p>
* *
* <pre> * <pre>
* WordUtils.capitalize(null, *) = null * WordUtils.capitalize(null, *) = null
@ -119,25 +135,33 @@ public class WordUtils {
* WordUtils.capitalize("i aM.fine", {'.'}) = "I aM.Fine" * WordUtils.capitalize("i aM.fine", {'.'}) = "I aM.Fine"
* </pre> * </pre>
* *
* @param str the String to capitalize, may be null * @param str
* @param delimiters set of characters to determine capitalization, null means whitespace * the String to capitalize, may be null
* @param delimiters
* set of characters to determine capitalization, null means whitespace
* @return capitalized String, <code>null</code> if null String input * @return capitalized String, <code>null</code> if null String input
* @see #uncapitalize(String) * @see #uncapitalize(String)
* @see #capitalizeFully(String) * @see #capitalizeFully(String)
* @since 2.1 * @since 2.1
*/ */
public static String capitalize(final String str, final char... delimiters) { public static String capitalize(final String str, final char... delimiters)
{
final int delimLen = delimiters == null ? -1 : delimiters.length; final int delimLen = delimiters == null ? -1 : delimiters.length;
if (isEmpty(str) || delimLen == 0) { if (isEmpty(str) || delimLen == 0)
{
return str; return str;
} }
final char[] buffer = str.toCharArray(); final char[] buffer = str.toCharArray();
boolean capitalizeNext = true; boolean capitalizeNext = true;
for (int i = 0; i < buffer.length; i++) { for (int i = 0; i < buffer.length; i++)
{
final char ch = buffer[i]; final char ch = buffer[i];
if (isDelimiter(ch, delimiters)) { if (isDelimiter(ch, delimiters))
{
capitalizeNext = true; capitalizeNext = true;
} else if (capitalizeNext) { }
else if (capitalizeNext)
{
buffer[i] = Character.toTitleCase(ch); buffer[i] = Character.toTitleCase(ch);
capitalizeNext = false; capitalizeNext = false;
} }
@ -147,14 +171,15 @@ public class WordUtils {
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
/** /**
* <p>Converts all the whitespace separated words in a String into capitalized words, * <p>
* that is each word is made up of a titlecase character and then a series of * Converts all the whitespace separated words in a String into capitalized words, that is each word is made up of a
* lowercase characters. </p> * titlecase character and then a series of lowercase characters.
* </p>
* *
* <p>Whitespace is defined by {@link Character#isWhitespace(char)}. * <p>
* A <code>null</code> input String returns <code>null</code>. * Whitespace is defined by {@link Character#isWhitespace(char)}. A <code>null</code> input String returns
* Capitalization uses the Unicode title case, normally equivalent to * <code>null</code>. Capitalization uses the Unicode title case, normally equivalent to upper case.
* upper case.</p> * </p>
* *
* <pre> * <pre>
* WordUtils.capitalizeFully(null) = null * WordUtils.capitalizeFully(null) = null
@ -162,25 +187,30 @@ public class WordUtils {
* WordUtils.capitalizeFully("i am FINE") = "I Am Fine" * WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
* </pre> * </pre>
* *
* @param str the String to capitalize, may be null * @param str
* the String to capitalize, may be null
* @return capitalized String, <code>null</code> if null String input * @return capitalized String, <code>null</code> if null String input
*/ */
public static String capitalizeFully(final String str) { public static String capitalizeFully(final String str)
{
return capitalizeFully(str, null); return capitalizeFully(str, null);
} }
/** /**
* <p>Converts all the delimiter separated words in a String into capitalized words, * <p>
* that is each word is made up of a titlecase character and then a series of * Converts all the delimiter separated words in a String into capitalized words, that is each word is made up of a
* lowercase characters. </p> * titlecase character and then a series of lowercase characters.
* </p>
* *
* <p>The delimiters represent a set of characters understood to separate words. * <p>
* The first string character and the first non-delimiter character after a * The delimiters represent a set of characters understood to separate words. The first string character and the
* delimiter will be capitalized. </p> * first non-delimiter character after a delimiter will be capitalized.
* </p>
* *
* <p>A <code>null</code> input String returns <code>null</code>. * <p>
* Capitalization uses the Unicode title case, normally equivalent to * A <code>null</code> input String returns <code>null</code>. Capitalization uses the Unicode title case, normally
* upper case.</p> * equivalent to upper case.
* </p>
* *
* <pre> * <pre>
* WordUtils.capitalizeFully(null, *) = null * WordUtils.capitalizeFully(null, *) = null
@ -190,14 +220,18 @@ public class WordUtils {
* WordUtils.capitalizeFully("i aM.fine", {'.'}) = "I am.Fine" * WordUtils.capitalizeFully("i aM.fine", {'.'}) = "I am.Fine"
* </pre> * </pre>
* *
* @param str the String to capitalize, may be null * @param str
* @param delimiters set of characters to determine capitalization, null means whitespace * the String to capitalize, may be null
* @param delimiters
* set of characters to determine capitalization, null means whitespace
* @return capitalized String, <code>null</code> if null String input * @return capitalized String, <code>null</code> if null String input
* @since 2.1 * @since 2.1
*/ */
public static String capitalizeFully(String str, final char... delimiters) { public static String capitalizeFully(String str, final char... delimiters)
{
final int delimLen = delimiters == null ? -1 : delimiters.length; final int delimLen = delimiters == null ? -1 : delimiters.length;
if (isEmpty(str) || delimLen == 0) { if (isEmpty(str) || delimLen == 0)
{
return str; return str;
} }
str = str.toLowerCase(); str = str.toLowerCase();
@ -206,11 +240,14 @@ public class WordUtils {
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
/** /**
* <p>Uncapitalizes all the whitespace separated words in a String. * <p>
* Only the first letter of each word is changed.</p> * Uncapitalizes all the whitespace separated words in a String. Only the first letter of each word is changed.
* </p>
* *
* <p>Whitespace is defined by {@link Character#isWhitespace(char)}. * <p>
* A <code>null</code> input String returns <code>null</code>.</p> * Whitespace is defined by {@link Character#isWhitespace(char)}. A <code>null</code> input String returns
* <code>null</code>.
* </p>
* *
* <pre> * <pre>
* WordUtils.uncapitalize(null) = null * WordUtils.uncapitalize(null) = null
@ -218,24 +255,30 @@ public class WordUtils {
* WordUtils.uncapitalize("I Am FINE") = "i am fINE" * WordUtils.uncapitalize("I Am FINE") = "i am fINE"
* </pre> * </pre>
* *
* @param str the String to uncapitalize, may be null * @param str
* the String to uncapitalize, may be null
* @return uncapitalized String, <code>null</code> if null String input * @return uncapitalized String, <code>null</code> if null String input
* @see #capitalize(String) * @see #capitalize(String)
*/ */
public static String uncapitalize(final String str) { public static String uncapitalize(final String str)
{
return uncapitalize(str, null); return uncapitalize(str, null);
} }
/** /**
* <p>Uncapitalizes all the whitespace separated words in a String. * <p>
* Only the first letter of each word is changed.</p> * Uncapitalizes all the whitespace separated words in a String. Only the first letter of each word is changed.
* </p>
* *
* <p>The delimiters represent a set of characters understood to separate words. * <p>
* The first string character and the first non-delimiter character after a * The delimiters represent a set of characters understood to separate words. The first string character and the
* delimiter will be uncapitalized. </p> * first non-delimiter character after a delimiter will be uncapitalized.
* </p>
* *
* <p>Whitespace is defined by {@link Character#isWhitespace(char)}. * <p>
* A <code>null</code> input String returns <code>null</code>.</p> * Whitespace is defined by {@link Character#isWhitespace(char)}. A <code>null</code> input String returns
* <code>null</code>.
* </p>
* *
* <pre> * <pre>
* WordUtils.uncapitalize(null, *) = null * WordUtils.uncapitalize(null, *) = null
@ -245,24 +288,32 @@ public class WordUtils {
* WordUtils.uncapitalize("I AM.FINE", {'.'}) = "i AM.fINE" * WordUtils.uncapitalize("I AM.FINE", {'.'}) = "i AM.fINE"
* </pre> * </pre>
* *
* @param str the String to uncapitalize, may be null * @param str
* @param delimiters set of characters to determine uncapitalization, null means whitespace * the String to uncapitalize, may be null
* @param delimiters
* set of characters to determine uncapitalization, null means whitespace
* @return uncapitalized String, <code>null</code> if null String input * @return uncapitalized String, <code>null</code> if null String input
* @see #capitalize(String) * @see #capitalize(String)
* @since 2.1 * @since 2.1
*/ */
public static String uncapitalize(final String str, final char... delimiters) { public static String uncapitalize(final String str, final char... delimiters)
{
final int delimLen = delimiters == null ? -1 : delimiters.length; final int delimLen = delimiters == null ? -1 : delimiters.length;
if (isEmpty(str) || delimLen == 0) { if (isEmpty(str) || delimLen == 0)
{
return str; return str;
} }
final char[] buffer = str.toCharArray(); final char[] buffer = str.toCharArray();
boolean uncapitalizeNext = true; boolean uncapitalizeNext = true;
for (int i = 0; i < buffer.length; i++) { for (int i = 0; i < buffer.length; i++)
{
final char ch = buffer[i]; final char ch = buffer[i];
if (isDelimiter(ch, delimiters)) { if (isDelimiter(ch, delimiters))
{
uncapitalizeNext = true; uncapitalizeNext = true;
} else if (uncapitalizeNext) { }
else if (uncapitalizeNext)
{
buffer[i] = Character.toLowerCase(ch); buffer[i] = Character.toLowerCase(ch);
uncapitalizeNext = false; uncapitalizeNext = false;
} }
@ -272,7 +323,9 @@ public class WordUtils {
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
/** /**
* <p>Swaps the case of a String using a word based algorithm.</p> * <p>
* Swaps the case of a String using a word based algorithm.
* </p>
* *
* <ul> * <ul>
* <li>Upper case character converts to Lower case</li> * <li>Upper case character converts to Lower case</li>
@ -281,8 +334,10 @@ public class WordUtils {
* <li>Other Lower case character converts to Upper case</li> * <li>Other Lower case character converts to Upper case</li>
* </ul> * </ul>
* *
* <p>Whitespace is defined by {@link Character#isWhitespace(char)}. * <p>
* A <code>null</code> input String returns <code>null</code>.</p> * Whitespace is defined by {@link Character#isWhitespace(char)}. A <code>null</code> input String returns
* <code>null</code>.
* </p>
* *
* <pre> * <pre>
* StringUtils.swapCase(null) = null * StringUtils.swapCase(null) = null
@ -290,33 +345,47 @@ public class WordUtils {
* StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone" * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
* </pre> * </pre>
* *
* @param str the String to swap case, may be null * @param str
* the String to swap case, may be null
* @return the changed String, <code>null</code> if null String input * @return the changed String, <code>null</code> if null String input
*/ */
public static String swapCase(final String str) { public static String swapCase(final String str)
if (isEmpty(str)) { {
if (isEmpty(str))
{
return str; return str;
} }
final char[] buffer = str.toCharArray(); final char[] buffer = str.toCharArray();
boolean whitespace = true; boolean whitespace = true;
for (int i = 0; i < buffer.length; i++) { for (int i = 0; i < buffer.length; i++)
{
final char ch = buffer[i]; final char ch = buffer[i];
if (Character.isUpperCase(ch)) { if (Character.isUpperCase(ch))
{
buffer[i] = Character.toLowerCase(ch); buffer[i] = Character.toLowerCase(ch);
whitespace = false; whitespace = false;
} else if (Character.isTitleCase(ch)) { }
else if (Character.isTitleCase(ch))
{
buffer[i] = Character.toLowerCase(ch); buffer[i] = Character.toLowerCase(ch);
whitespace = false; whitespace = false;
} else if (Character.isLowerCase(ch)) { }
if (whitespace) { else if (Character.isLowerCase(ch))
{
if (whitespace)
{
buffer[i] = Character.toTitleCase(ch); buffer[i] = Character.toTitleCase(ch);
whitespace = false; whitespace = false;
} else { }
else
{
buffer[i] = Character.toUpperCase(ch); buffer[i] = Character.toUpperCase(ch);
} }
} else { }
else
{
whitespace = Character.isWhitespace(ch); whitespace = Character.isWhitespace(ch);
} }
} }
@ -325,14 +394,19 @@ public class WordUtils {
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
/** /**
* <p>Extracts the initial letters from each word in the String.</p> * <p>
* Extracts the initial letters from each word in the String.
* </p>
* *
* <p>The first letter of the string and all first letters after * <p>
* whitespace are returned as a new string. * The first letter of the string and all first letters after whitespace are returned as a new string. Their case is
* Their case is not changed.</p> * not changed.
* </p>
* *
* <p>Whitespace is defined by {@link Character#isWhitespace(char)}. * <p>
* A <code>null</code> input String returns <code>null</code>.</p> * Whitespace is defined by {@link Character#isWhitespace(char)}. A <code>null</code> input String returns
* <code>null</code>.
* </p>
* *
* <pre> * <pre>
* WordUtils.initials(null) = null * WordUtils.initials(null) = null
@ -341,26 +415,32 @@ public class WordUtils {
* WordUtils.initials("Ben J.Lee") = "BJ" * WordUtils.initials("Ben J.Lee") = "BJ"
* </pre> * </pre>
* *
* @param str the String to get initials from, may be null * @param str
* the String to get initials from, may be null
* @return String of initial letters, <code>null</code> if null String input * @return String of initial letters, <code>null</code> if null String input
* @see #initials(String,char[]) * @see #initials(String,char[])
* @since 2.2 * @since 2.2
*/ */
public static String initials(final String str) { public static String initials(final String str)
{
return initials(str, null); return initials(str, null);
} }
/** /**
* <p>Extracts the initial letters from each word in the String.</p> * <p>
* Extracts the initial letters from each word in the String.
* </p>
* *
* <p>The first letter of the string and all first letters after the * <p>
* defined delimiters are returned as a new string. * The first letter of the string and all first letters after the defined delimiters are returned as a new string.
* Their case is not changed.</p> * Their case is not changed.
* </p>
* *
* <p>If the delimiters array is null, then Whitespace is used. * <p>
* Whitespace is defined by {@link Character#isWhitespace(char)}. * If the delimiters array is null, then Whitespace is used. Whitespace is defined by
* A <code>null</code> input String returns <code>null</code>. * {@link Character#isWhitespace(char)}. A <code>null</code> input String returns <code>null</code>. An empty
* An empty delimiter array returns an empty String.</p> * delimiter array returns an empty String.
* </p>
* *
* <pre> * <pre>
* WordUtils.initials(null, *) = null * WordUtils.initials(null, *) = null
@ -371,32 +451,43 @@ public class WordUtils {
* WordUtils.initials(*, new char[0]) = "" * WordUtils.initials(*, new char[0]) = ""
* </pre> * </pre>
* *
* @param str the String to get initials from, may be null * @param str
* @param delimiters set of characters to determine words, null means whitespace * the String to get initials from, may be null
* @param delimiters
* set of characters to determine words, null means whitespace
* @return String of initial letters, <code>null</code> if null String input * @return String of initial letters, <code>null</code> if null String input
* @see #initials(String) * @see #initials(String)
* @since 2.2 * @since 2.2
*/ */
public static String initials(final String str, final char... delimiters) { public static String initials(final String str, final char... delimiters)
if (isEmpty(str)) { {
if (isEmpty(str))
{
return str; return str;
} }
if (delimiters != null && delimiters.length == 0) { if (delimiters != null && delimiters.length == 0)
{
return ""; return "";
} }
final int strLen = str.length(); final int strLen = str.length();
final char[] buf = new char[strLen / 2 + 1]; final char[] buf = new char[strLen / 2 + 1];
int count = 0; int count = 0;
boolean lastWasGap = true; boolean lastWasGap = true;
for (int i = 0; i < strLen; i++) { for (int i = 0; i < strLen; i++)
{
final char ch = str.charAt(i); final char ch = str.charAt(i);
if (isDelimiter(ch, delimiters)) { if (isDelimiter(ch, delimiters))
{
lastWasGap = true; lastWasGap = true;
} else if (lastWasGap) { }
else if (lastWasGap)
{
buf[count++] = ch; buf[count++] = ch;
lastWasGap = false; lastWasGap = false;
} else { }
else
{
continue; // ignore ch continue; // ignore ch
} }
} }
@ -407,20 +498,25 @@ public class WordUtils {
/** /**
* Is the character a delimiter. * Is the character a delimiter.
* *
* @param ch the character to check * @param ch
* @param delimiters the delimiters * the character to check
* @param delimiters
* the delimiters
* @return true if it is a delimiter * @return true if it is a delimiter
*/ */
private static boolean isDelimiter(final char ch, final char[] delimiters) { private static boolean isDelimiter(final char ch, final char[] delimiters)
if (delimiters == null) { {
if (delimiters == null)
{
return Character.isWhitespace(ch); return Character.isWhitespace(ch);
} }
for (final char delimiter : delimiters) { for (final char delimiter : delimiters)
if (ch == delimiter) { {
if (ch == delimiter)
{
return true; return true;
} }
} }
return false; return false;
} }
} }