commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bay...@apache.org
Subject svn commit: r1089695 - /commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java
Date Thu, 07 Apr 2011 00:24:50 GMT
Author: bayard
Date: Thu Apr  7 00:24:50 2011
New Revision: 1089695

URL: http://svn.apache.org/viewvc?rev=1089695&view=rev
Log:
Moving equalsIgnoreCase, indexOfIgnoreCase, lastIndexOfIgnoreCase and containsIgnoreCase to
the CharSequence API. LANG-687

Modified:
    commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java

Modified: commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java?rev=1089695&r1=1089694&r2=1089695&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java (original)
+++ commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java Thu
Apr  7 00:24:50 2011
@@ -754,7 +754,7 @@ public class StringUtils {
     }
 
     /**
-     * <p>Compares two Strings, returning {@code true} if they are equal ignoring
+     * <p>Compares two CharSequences, returning {@code true} if they are equal ignoring
      * the case.</p>
      *
      * <p>{@code null}s are handled without exceptions. Two {@code null}
@@ -768,14 +768,17 @@ public class StringUtils {
      * StringUtils.equalsIgnoreCase("abc", "ABC") = true
      * </pre>
      *
-     * @see java.lang.String#equalsIgnoreCase(String)
-     * @param str1  the first String, may be null
-     * @param str2  the second String, may be null
-     * @return {@code true} if the Strings are equal, case insensitive, or
+     * @param str1  the first CharSequence, may be null
+     * @param str2  the second CharSequence, may be null
+     * @return {@code true} if the CharSequence are equal, case insensitive, or
      *  both {@code null}
      */
-    public static boolean equalsIgnoreCase(String str1, String str2) {
-        return str1 == null ? str2 == null : str1.equalsIgnoreCase(str2);
+    public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2) {
+        if (str1 == null || str2 == null) {
+            return str1 == str2;
+        } else {
+            return regionMatchesSequence(str1, true, 0, str2, 0, Math.max(str1.length(),
str2.length()));
+        }
     }
 
     // IndexOf
@@ -982,13 +985,13 @@ public class StringUtils {
     }
 
     /**
-     * <p>Case in-sensitive find of the first index within a String.</p>
+     * <p>Case in-sensitive find of the first index within a CharSequence.</p>
      *
-     * <p>A {@code null} String will return {@code -1}.
+     * <p>A {@code null} CharSequence will return {@code -1}.
      * A negative start position is treated as zero.
-     * An empty ("") search String always matches.
+     * An empty ("") search CharSequence always matches.
      * A start position greater than the string length only matches
-     * an empty search String.</p>
+     * an empty search CharSequence.</p>
      *
      * <pre>
      * StringUtils.indexOfIgnoreCase(null, *)          = -1
@@ -999,25 +1002,25 @@ public class StringUtils {
      * StringUtils.indexOfIgnoreCase("aabaabaa", "ab") = 1
      * </pre>
      *
-     * @param str  the String to check, may be null
-     * @param searchStr  the String to find, may be null
-     * @return the first index of the search String,
+     * @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
      */
-    public static int indexOfIgnoreCase(String str, String searchStr) {
+    public static int indexOfIgnoreCase(CharSequence str, CharSequence searchStr) {
         return indexOfIgnoreCase(str, searchStr, 0);
     }
 
     /**
-     * <p>Case in-sensitive find of the first index within a String
+     * <p>Case in-sensitive find of the first index within a CharSequence
      * from the specified position.</p>
      *
-     * <p>A {@code null} String will return {@code -1}.
+     * <p>A {@code null} CharSequence will return {@code -1}.
      * A negative start position is treated as zero.
-     * An empty ("") search String always matches.
+     * An empty ("") search CharSequence always matches.
      * A start position greater than the string length only matches
-     * an empty search String.</p>
+     * an empty search CharSequence.</p>
      *
      * <pre>
      * StringUtils.indexOfIgnoreCase(null, *, *)          = -1
@@ -1033,14 +1036,14 @@ public class StringUtils {
      * StringUtils.indexOfIgnoreCase("abc", "", 9)        = 3
      * </pre>
      *
-     * @param str  the String to check, may be null
-     * @param searchStr  the String to find, may be null
+     * @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 String,
+     * @return the first index of the search CharSequence,
      *  -1 if no match or {@code null} string input
      * @since 2.5
      */
-    public static int indexOfIgnoreCase(String str, String searchStr, int startPos) {
+    public static int indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)
{
         if (str == null || searchStr == null) {
             return INDEX_NOT_FOUND;
         }
@@ -1055,7 +1058,7 @@ public class StringUtils {
             return startPos;
         }
         for (int i = startPos; i < endLimit; i++) {
-            if (str.regionMatches(true, i, searchStr, 0, searchStr.length())) {
+            if (regionMatchesSequence(str, true, i, searchStr, 0, searchStr.length())) {
                 return i;
             }
         }
@@ -1226,11 +1229,11 @@ public class StringUtils {
     }
 
     /**
-     * <p>Case in-sensitive find of the last index within a String.</p>
+     * <p>Case in-sensitive find of the last index within a CharSequence.</p>
      *
-     * <p>A {@code null} String will return {@code -1}.
+     * <p>A {@code null} CharSequence will return {@code -1}.
      * A negative start position returns {@code -1}.
-     * An empty ("") search String always matches unless the start position is negative.
+     * 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>
@@ -1241,13 +1244,13 @@ public class StringUtils {
      * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB") = 4
      * </pre>
      *
-     * @param str  the String to check, may be null
-     * @param searchStr  the String to find, may be null
-     * @return the first index of the search String,
+     * @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
      */
-    public static int lastIndexOfIgnoreCase(String str, String searchStr) {
+    public static int lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr) {
         if (str == null || searchStr == null) {
             return INDEX_NOT_FOUND;
         }
@@ -1255,12 +1258,12 @@ public class StringUtils {
     }
 
     /**
-     * <p>Case in-sensitive find of the last index within a String
+     * <p>Case in-sensitive find of the last index within a CharSequence
      * from the specified position.</p>
      *
-     * <p>A {@code null} String will return {@code -1}.
+     * <p>A {@code null} CharSequence will return {@code -1}.
      * A negative start position returns {@code -1}.
-     * An empty ("") search String always matches unless the start position is negative.
+     * 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>
@@ -1275,14 +1278,14 @@ public class StringUtils {
      * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0)  = -1
      * </pre>
      *
-     * @param str  the String to check, may be null
-     * @param searchStr  the String to find, may be null
+     * @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 first index of the search String,
-     *  -1 if no match or {@code null} string input
+     * @return the first index of the search CharSequence,
+     *  -1 if no match or {@code null} input
      * @since 2.5
      */
-    public static int lastIndexOfIgnoreCase(String str, String searchStr, int startPos) {
+    public static int lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr, int
startPos) {
         if (str == null || searchStr == null) {
             return INDEX_NOT_FOUND;
         }
@@ -1297,7 +1300,7 @@ public class StringUtils {
         }
 
         for (int i = startPos; i >= 0; i--) {
-            if (str.regionMatches(true, i, searchStr, 0, searchStr.length())) {
+            if (regionMatchesSequence(str, true, i, searchStr, 0, searchStr.length())) {
                 return i;
             }
         }
@@ -1361,11 +1364,11 @@ public class StringUtils {
     }
 
     /**
-     * <p>Checks if String contains a search String irrespective of case,
+     * <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} String will return {@code false}.</p>
+     * <p>A {@code null} CharSequence will return {@code false}.</p>
      *
      * <pre>
      * StringUtils.contains(null, *) = false
@@ -1378,19 +1381,19 @@ public class StringUtils {
      * StringUtils.contains("abc", "Z") = false
      * </pre>
      *
-     * @param str  the String to check, may be null
-     * @param searchStr  the String to find, may be null
-     * @return true if the String contains the search String irrespective of
+     * @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
      */
-    public static boolean containsIgnoreCase(String str, String searchStr) {
+    public static boolean containsIgnoreCase(CharSequence str, CharSequence searchStr) {
         if (str == null || searchStr == null) {
             return false;
         }
         int len = searchStr.length();
         int max = str.length() - len;
         for (int i = 0; i <= max; i++) {
-            if (str.regionMatches(true, i, searchStr, 0, len)) {
+            if (regionMatchesSequence(str, true, i, searchStr, 0, len)) {
                 return true;
             }
         }



Mime
View raw message