[ 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)