Java String compare two String values and get index of difference

//package com.demo2s;

public class Main {
  public static void main(String[] argv) throws Exception {
    String str1 = "demo2s.com";
    String str2 = "demo2s.com test case";
    System.out.println(difference(str1, str2));
  }/*from w  w w .  j  av a2s .  c o m*/

  /**
   * The empty String <code>""</code>.
   * 
   * @since 2.0
   */
  public static final String EMPTY = "";

  /**
   * <p>
   * Compares two Strings, and returns the portion where they differ. (More
   * precisely, return the remainder of the second String, starting from where
   * it's different from the first.)
   * </p>
   *
   * <p>
   * For example,
   * <code>difference("i am a machine", "i am a robot") -> "robot"</code>.
   * </p>
   *
   * <pre>
   * difference(null, null) = null
   * difference("", "") = ""
   * difference("", "abc") = "abc"
   * difference("abc", "") = ""
   * difference("abc", "abc") = ""
   * difference("ab", "abxyz") = "xyz"
   * difference("abcde", "abxyz") = "xyz"
   * difference("abcde", "xyz") = "xyz"
   * </pre>
   *
   * @param str1
   *          the first String, may be null
   * @param str2
   *          the second String, may be null
   * @return the portion of str2 where it differs from str1; returns the empty
   *         String if they are equal
   * @since 2.0
   */
  public static String difference(String str1, String str2) {
    if (str1 == null) {
      return str2;
    }
    if (str2 == null) {
      return str1;
    }
    int at = indexOfDifference(str1, str2);
    if (at == -1) {
      return EMPTY;
    }
    return str2.substring(at);
  }

  /**
   * <p>
   * Compares two Strings, and returns the index at which the Strings begin to
   * differ.
   * </p>
   *
   * <p>
   * For example,
   * <code>indexOfDifference("i am a machine", "i am a robot") -> 7</code>
   * </p>
   *
   * <pre>
   * indexOfDifference(null, null) = -1
   * indexOfDifference("", "") = -1
   * indexOfDifference("", "abc") = 0
   * indexOfDifference("abc", "") = 0
   * indexOfDifference("abc", "abc") = -1
   * indexOfDifference("ab", "abxyz") = 2
   * indexOfDifference("abcde", "abxyz") = 2
   * indexOfDifference("abcde", "xyz") = 0
   * </pre>
   *
   * @param str1
   *          the first String, may be null
   * @param str2
   *          the second String, may be null
   * @return the index where str2 and str1 begin to differ; -1 if they are equal
   * @since 2.0
   */
  public static int indexOfDifference(String str1, String str2) {
    if (str1 == str2) {
      return -1;
    }
    if (str1 == null || str2 == null) {
      return 0;
    }
    int i;
    for (i = 0; i < str1.length() && i < str2.length(); ++i) {
      if (str1.charAt(i) != str2.charAt(i)) {
        break;
      }
    }
    if (i < str2.length() || i < str1.length()) {
      return i;
    }
    return -1;
  }

  /**
   * <p>
   * Compares all Strings in an array and returns the index at which the Strings
   * begin to differ.
   * </p>
   *
   * <p>
   * For example,
   * <code>indexOfDifference(new String[] {"i am a machine", "i am a robot"}) -> 7</code>
   * </p>
   *
   * <pre>
   * indexOfDifference(null) = -1
   * indexOfDifference(new String[] {}) = -1
   * indexOfDifference(new String[] {"abc"}) = -1
   * indexOfDifference(new String[] {null, null}) = -1
   * indexOfDifference(new String[] {"", ""}) = -1
   * indexOfDifference(new String[] {"", null}) = 0
   * indexOfDifference(new String[] {"abc", null, null}) = 0
   * indexOfDifference(new String[] {null, null, "abc"}) = 0
   * indexOfDifference(new String[] {"", "abc"}) = 0
   * indexOfDifference(new String[] {"abc", ""}) = 0
   * indexOfDifference(new String[] {"abc", "abc"}) = -1
   * indexOfDifference(new String[] {"abc", "a"}) = 1
   * indexOfDifference(new String[] {"ab", "abxyz"}) = 2
   * indexOfDifference(new String[] {"abcde", "abxyz"}) = 2
   * indexOfDifference(new String[] {"abcde", "xyz"}) = 0
   * indexOfDifference(new String[] {"xyz", "abcde"}) = 0
   * indexOfDifference(new String[] {"i am a machine", "i am a robot"}) = 7
   * </pre>
   *
   * @param strs
   *          array of strings, entries may be null
   * @return the index where the strings begin to differ; -1 if they are all equal
   * @since 2.4
   */
  public static int indexOfDifference(String[] strs) {
    if (strs == null || strs.length <= 1) {
      return -1;
    }
    boolean anyStringNull = false;
    boolean allStringsNull = true;
    int arrayLen = strs.length;
    int shortestStrLen = Integer.MAX_VALUE;
    int longestStrLen = 0;

    // find the min and max string lengths; this avoids checking to make
    // sure we are not exceeding the length of the string each time through
    // the bottom loop.
    for (int i = 0; i < arrayLen; i++) {
      if (strs[i] == null) {
        anyStringNull = true;
        shortestStrLen = 0;
      } else {
        allStringsNull = false;
        shortestStrLen = Math.min(strs[i].length(), shortestStrLen);
        longestStrLen = Math.max(strs[i].length(), longestStrLen);
      }
    }

    // handle lists containing all nulls or all empty strings
    if (allStringsNull || (longestStrLen == 0 && !anyStringNull)) {
      return -1;
    }

    // handle lists containing some nulls or some empty strings
    if (shortestStrLen == 0) {
      return 0;
    }

    // find the position with the first difference across all strings
    int firstDiff = -1;
    for (int stringPos = 0; stringPos < shortestStrLen; stringPos++) {
      char comparisonChar = strs[0].charAt(stringPos);
      for (int arrayPos = 1; arrayPos < arrayLen; arrayPos++) {
        if (strs[arrayPos].charAt(stringPos) != comparisonChar) {
          firstDiff = stringPos;
          break;
        }
      }
      if (firstDiff != -1) {
        break;
      }
    }

    if (firstDiff == -1 && shortestStrLen != longestStrLen) {
      // we compared all of the characters up to the length of the
      // shortest string and didn't find a match, but the string lengths
      // vary, so return the length of the shortest string.
      return shortestStrLen;
    }
    return firstDiff;
  }

}

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */