Strings (JGoodies Common 1.8 API)
Date: 2015-01-03

com.jgoodies.common.base

## Class Strings

- java.lang.Object
- - com.jgoodies.common.base.Strings

-     public class Strings
      extends Object

  Provides frequently used static null-safe String testing methods .
  Author:
    Karsten Lentzsch

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `ELLIPSIS_STRING` The correct ellipsis string.
    `static String` | `NO_ELLIPSIS_STRING` A string with three dots that should is often meant to be the ellipsis string "?" or character '?'.

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `Strings()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static String` | `abbreviateCenter(String str, int maxLength)` Abbreviates the given string if it exceeds the given maximum length by replacing its center part with an ellipsis ('…').
    `static String` | `get(String str, Object... args)` If no arguments are provided, the plain String is returned.
    `static boolean` | `isBlank(String str)` Checks if the given string is whitespace, empty ("") or `null`.
    `static boolean` | `isEmpty(String str)` Checks if the given string is empty ("") or `null`.
    `static boolean` | `isNotBlank(String str)` Checks if the given string is not empty (""), not `null` and not whitespace only.
    `static boolean` | `isNotEmpty(String str)` Checks if the given string is not empty ("") and not `null`.
    `static boolean` | `isTrimmed(String str)` Checks if the given string is `null`, empty (""), or the first and last characters are not whitespace.
    `static boolean` | `startsWithIgnoreCase(String str, String prefix)` Checks if `str` starts with the given prefix ignoring cases.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### NO_ELLIPSIS_STRING

          public static final String NO_ELLIPSIS_STRING

      A string with three dots that should is often meant to be the ellipsis string "?" or character '?'.
      Since:
        1.7
      See Also:
        `ELLIPSIS_STRING`, Constant Field Values

    - #### ELLIPSIS_STRING

          public static final String ELLIPSIS_STRING

      The correct ellipsis string.
      See Also:
        `NO_ELLIPSIS_STRING`, Constant Field Values

  - ### Constructor Detail

    - #### Strings

          protected Strings()

  - ### Method Detail

    - #### isBlank

          public static boolean isBlank(String str)

      Checks if the given string is whitespace, empty ("") or `null`.

           Strings.isBlank(null)    == true
           Strings.isBlank("")      == true
           Strings.isBlank(" ")     == true
           Strings.isBlank(" abc")  == false
           Strings.isBlank("abc ")  == false
           Strings.isBlank(" abc ") == false

      Parameters:
        `str` - the string to check, may be `null`
      Returns:
        `true` if the string is whitespace, empty or `null`
      See Also:
        `isEmpty(String)`

    - #### isNotBlank

          public static boolean isNotBlank(String str)

      Checks if the given string is not empty (""), not `null` and not whitespace only.

           Strings.isNotBlank(null)    == false
           Strings.isNotBlank("")      == false
           Strings.isNotBlank(" ")     == false
           Strings.isNotBlank(" abc")  == true
           Strings.isNotBlank("abc ")  == true
           Strings.isNotBlank(" abc ") == true

      Parameters:
        `str` - the string to check, may be `null`
      Returns:
        `true` if the string is not empty and not `null` and not whitespace only
      See Also:
        `isEmpty(String)`

    - #### isEmpty

          public static boolean isEmpty(String str)

      Checks if the given string is empty ("") or `null`.

           Strings.isEmpty(null)  == true
           Strings.isEmpty("")    == true
           Strings.isEmpty(" ")   == false
           Strings.isEmpty("Hi ") == false

      Parameters:
        `str` - the string to check, may be `null`
      Returns:
        `true` if the string is empty or `null`
      See Also:
        `isBlank(String)`

    - #### isNotEmpty

          public static boolean isNotEmpty(String str)

      Checks if the given string is not empty ("") and not `null`.

           Strings.isNotEmpty(null)  == false
           Strings.isNotEmpty("")    == false
           Strings.isNotEmpty(" ")   == true
           Strings.isNotEmpty("Hi")  == true
           Strings.isNotEmpty("Hi ") == true

      Parameters:
        `str` - the string to check, may be `null`
      Returns:
        `true` if the string is not empty and not `null`
      See Also:
        `isBlank(String)`

    - #### isTrimmed

          public static boolean isTrimmed(String str)

      Checks if the given string is `null`, empty (""), or the first and last characters are not whitespace.

           Strings.isTrimmed(null)  == true
           Strings.isTrimmed("")    == true
           Strings.isTrimmed(" ")   == false
           Strings.isTrimmed("Hi")  == true
           Strings.isTrimmed("Hi ") == false
           Strings.isTrimmed(" Hi") == false

      Parameters:
        `str` - the string to check, may be `null`
      Returns:
        `true` if the string is `null`, empty, or the first and last characters are not whitespace.
      Since:
        1.3

    - #### startsWithIgnoreCase

          public static boolean startsWithIgnoreCase(String str,
                                     String prefix)

      Checks if `str` starts with the given prefix ignoring cases. `null` is handled safely; if both arguments are null, true is returned, false otherwise.

           Strings.startsWithIgnoreCase(null, null)      == true
           Strings.startsWithIgnoreCase("a", null)       == false
           Strings.startsWithIgnoreCase(null, "a")       == false
           Strings.startsWithIgnoreCase("",  "")         == true
           Strings.startsWithIgnoreCase(" ", "")         == true
           Strings.startsWithIgnoreCase("John", "J")     == true
           Strings.startsWithIgnoreCase("John", "Jo")    == true
           Strings.startsWithIgnoreCase("John", "Joh")   == true
           Strings.startsWithIgnoreCase("John", "joh")   == true
           Strings.startsWithIgnoreCase("john", "Joh")   == true
           Strings.startsWithIgnoreCase("john", "joh")   == true
           Strings.startsWithIgnoreCase("John", "John")  == true
           Strings.startsWithIgnoreCase("John", "john")  == true
           Strings.startsWithIgnoreCase("John", "Jonny") == false

      Parameters:
        `str` - the test string to check, may be null
        `prefix` - the prefix to check for, may be null
      Returns:
        `true`, if the string starts with the prefix, ignoring cases, `false` otherwise
      See Also:
        `String.startsWith(java.lang.String)`

    - #### abbreviateCenter

          public static String abbreviateCenter(String str,
                                int maxLength)

      Abbreviates the given string if it exceeds the given maximum length by replacing its center part with an ellipsis ('…'). If the string is `null` or shorter than the limit, it is returned as is.

           Strings.abbreviateCenter(null,      3) == null
           Strings.abbreviateCenter("",        3) == ""
           Strings.abbreviateCenter(" ",       3) == " "
           Strings.abbreviateCenter("a",       3) == "a"
           Strings.abbreviateCenter("ab",      3) == "ab"
           Strings.abbreviateCenter("abc",     3) == "abc"
           Strings.abbreviateCenter("abcd",    3) == "a…d"
           Strings.abbreviateCenter("abcde",   3) == "a…e"
           Strings.abbreviateCenter("abcde",   4) == "ab…e"
           Strings.abbreviateCenter("abcdef",  4) == "ab…f"
           Strings.abbreviateCenter("abcdefg", 5) == "ab…fg"

      Parameters:
        `str` - the source string
        `maxLength` - the maximum length of the result string
      Returns:
        `str` if its length is less than or equal to `maxLength`, an abbreviated string with length `maxLength` where the center is replaced by an ellipsis

    - #### get

          public static String get(String str,
                   Object... args)

      If no arguments are provided, the plain String is returned. Otherwise the string will be formatted using `String.format` with the given arguments.

           Strings.get(null)    == null
           Strings.get("")      == ""
           Strings.get(" ")     == " "
           Strings.get("hello") == "hello"
           Strings.get("a %s c", "b")  == "a b c"
           Strings.get("%1$s %2$s %3$s", "a", "b", "c") == "a b c"

      Parameters:
        `args` - optional format arguments forwarded to `String#format`
      Returns:
        the String formatted with the optional arguments - if any
      Since:
        1.8
      See Also:
        `String.format(String, Object...)`

Copyright © 2009-2014 JGoodies Software GmbH. All Rights Reserved.