You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@commons.apache.org by "Loic Guibert (JIRA)" <ji...@apache.org> on 2015/10/05 15:08:26 UTC
[jira] [Updated] (LANG-1171) Add compare methods in StringUtils
[ https://issues.apache.org/jira/browse/LANG-1171?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Loic Guibert updated LANG-1171:
-------------------------------
Description:
Add null safe methods in {{StringUtils}} to compare 2 Strings :
{code:java}
public static int compare(final String str1, final String str2);
public static int compare(final String str1, final String str2, final boolean nullIsLess);
public static int compareIgnoreCase(final String str1, final String str2);
public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess);
{code}
Those methods are null safe equivalent to :
{code:java}
String.compareTo(String);
String.compareToIgnoreCase(String);
{code}
More details :
{code:java}
/**
* <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 ou greater than {@code str2}
*/
public static int compare(final String str1, final String str2);
/**
* <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}
*/
public static int compare(final String str1, final String str2, final boolean nullIsLess);
/**
* <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.
*/
public static int compareIgnoreCase(final String str1, final String 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} 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.
*/
public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess);
{code}
See PR#110 : https://github.com/apache/commons-lang/pull/110
was:
Add null safe methods in {{StringUtils}} to compare 2 Strings :
{code:java}
public static int compare(final String str1, final String str2);
public static int compare(final String str1, final String str2, final boolean nullIsLess);
public static int compareIgnoreCase(final String str1, final String str2);
public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess);
{code}
Those methods are null safe equivalent to :
{code:java}
String.compareTo(String);
String.compareToIgnoreCase(String);
{code}
More details :
{code:java}
/**
* <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 ou greater than {@code str2}
*/
public static int compare(final String str1, final String str2);
/**
* <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}
*/
public static int compare(final String str1, final String str2, final boolean nullIsLess);
/**
* <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.
*/
public static int compareIgnoreCase(final String str1, final String 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} 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.
*/
public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess);
{code}
I'm working on it and will send a pull request soon.
> Add compare methods in StringUtils
> ----------------------------------
>
> Key: LANG-1171
> URL: https://issues.apache.org/jira/browse/LANG-1171
> Project: Commons Lang
> Issue Type: New Feature
> Components: lang.*
> Reporter: Loic Guibert
>
> Add null safe methods in {{StringUtils}} to compare 2 Strings :
> {code:java}
> public static int compare(final String str1, final String str2);
> public static int compare(final String str1, final String str2, final boolean nullIsLess);
> public static int compareIgnoreCase(final String str1, final String str2);
> public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess);
> {code}
> Those methods are null safe equivalent to :
> {code:java}
> String.compareTo(String);
> String.compareToIgnoreCase(String);
> {code}
> More details :
> {code:java}
> /**
> * <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 ou greater than {@code str2}
> */
> public static int compare(final String str1, final String str2);
> /**
> * <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}
> */
> public static int compare(final String str1, final String str2, final boolean nullIsLess);
> /**
> * <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.
> */
> public static int compareIgnoreCase(final String str1, final String 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} 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.
> */
> public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess);
> {code}
> See PR#110 : https://github.com/apache/commons-lang/pull/110
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)