Java Tutorial/Data Type/String Compare

Compares all Strings in an array and returns the index at which the Strings begin to differ.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
public class Main {

  /**
   * Compares all Strings in an array and returns the index at which the
   * Strings begin to differ.
   *
   * For example,
   * <code>indexOfDifference(new String[] {"i am a machine", "i am a robot"}) -> 7</code>
   *
   * <pre>
   * StringUtils.indexOfDifference(null) = -1
   * StringUtils.indexOfDifference(new String[] {}) = -1
   * StringUtils.indexOfDifference(new String[] {"abc"}) = -1
   * StringUtils.indexOfDifference(new String[] {null, null}) = -1
   * StringUtils.indexOfDifference(new String[] {"", ""}) = -1
   * StringUtils.indexOfDifference(new String[] {"", null}) = 0
   * StringUtils.indexOfDifference(new String[] {"abc", null, null}) = 0
   * StringUtils.indexOfDifference(new String[] {null, null, "abc"}) = 0
   * StringUtils.indexOfDifference(new String[] {"", "abc"}) = 0
   * StringUtils.indexOfDifference(new String[] {"abc", ""}) = 0
   * StringUtils.indexOfDifference(new String[] {"abc", "abc"}) = -1
   * StringUtils.indexOfDifference(new String[] {"abc", "a"}) = 1
   * StringUtils.indexOfDifference(new String[] {"ab", "abxyz"}) = 2
   * StringUtils.indexOfDifference(new String[] {"abcde", "abxyz"}) = 2
   * StringUtils.indexOfDifference(new String[] {"abcde", "xyz"}) = 0
   * StringUtils.indexOfDifference(new String[] {"xyz", "abcde"}) = 0
   * StringUtils.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;
  }
}

Compares all Strings in an array and returns the initial sequence of characters that is common to all of them.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
public class Main {

  
  /**
   * Compares all Strings in an array and returns the initial sequence of 
   * characters that is common to all of them.
   *
   * For example,
   * <code>getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) -> "i am a "</code>
   *
   * <pre>
   * StringUtils.getCommonPrefix(null) = ""
   * StringUtils.getCommonPrefix(new String[] {}) = ""
   * StringUtils.getCommonPrefix(new String[] {"abc"}) = "abc"
   * StringUtils.getCommonPrefix(new String[] {null, null}) = ""
   * StringUtils.getCommonPrefix(new String[] {"", ""}) = ""
   * StringUtils.getCommonPrefix(new String[] {"", null}) = ""
   * StringUtils.getCommonPrefix(new String[] {"abc", null, null}) = ""
   * StringUtils.getCommonPrefix(new String[] {null, null, "abc"}) = ""
   * StringUtils.getCommonPrefix(new String[] {"", "abc"}) = ""
   * StringUtils.getCommonPrefix(new String[] {"abc", ""}) = ""
   * StringUtils.getCommonPrefix(new String[] {"abc", "abc"}) = "abc"
   * StringUtils.getCommonPrefix(new String[] {"abc", "a"}) = "a"
   * StringUtils.getCommonPrefix(new String[] {"ab", "abxyz"}) = "ab"
   * StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"}) = "ab"
   * StringUtils.getCommonPrefix(new String[] {"abcde", "xyz"}) = ""
   * StringUtils.getCommonPrefix(new String[] {"xyz", "abcde"}) = ""
   * StringUtils.getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) = "i am a "
   * </pre>
   *
   * @param strs  array of String objects, entries may be null
   * @return the initial sequence of characters that are common to all Strings
   * in the array; empty String if the array is null, the elements are all null 
   * or if there is no common prefix. 
   * @since 2.4
   */
  public static String getCommonPrefix(String[] strs) {
      if (strs == null || strs.length == 0) {
          return "";
      }
      int smallestIndexOfDiff = indexOfDifference(strs);
      if (smallestIndexOfDiff == -1) {
          // all strings were identical
          if (strs[0] == null) {
              return "";
          }
          return strs[0];
      } else if (smallestIndexOfDiff == 0) {
          // there were no common initial characters
          return "";
      } else {
          // we found a common initial character sequence
          return strs[0].substring(0, smallestIndexOfDiff);
      }
  }  
  /**
   * Compares all Strings in an array and returns the index at which the
   * Strings begin to differ.
   *
   * For example,
   * <code>indexOfDifference(new String[] {"i am a machine", "i am a robot"}) -> 7</code>
   *
   * <pre>
   * StringUtils.indexOfDifference(null) = -1
   * StringUtils.indexOfDifference(new String[] {}) = -1
   * StringUtils.indexOfDifference(new String[] {"abc"}) = -1
   * StringUtils.indexOfDifference(new String[] {null, null}) = -1
   * StringUtils.indexOfDifference(new String[] {"", ""}) = -1
   * StringUtils.indexOfDifference(new String[] {"", null}) = 0
   * StringUtils.indexOfDifference(new String[] {"abc", null, null}) = 0
   * StringUtils.indexOfDifference(new String[] {null, null, "abc"}) = 0
   * StringUtils.indexOfDifference(new String[] {"", "abc"}) = 0
   * StringUtils.indexOfDifference(new String[] {"abc", ""}) = 0
   * StringUtils.indexOfDifference(new String[] {"abc", "abc"}) = -1
   * StringUtils.indexOfDifference(new String[] {"abc", "a"}) = 1
   * StringUtils.indexOfDifference(new String[] {"ab", "abxyz"}) = 2
   * StringUtils.indexOfDifference(new String[] {"abcde", "abxyz"}) = 2
   * StringUtils.indexOfDifference(new String[] {"abcde", "xyz"}) = 0
   * StringUtils.indexOfDifference(new String[] {"xyz", "abcde"}) = 0
   * StringUtils.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;
  }
}

Compares two Strings, and returns the index at which the Strings begin to differ.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
public class Main {
  /**
   * Compares two Strings, and returns the index at which the
   * Strings begin to differ.
   *
   * For example,
   * <code>indexOfDifference("i am a machine", "i am a robot") -> 7</code>
   *
   * <pre>
   * StringUtils.indexOfDifference(null, null) = -1
   * StringUtils.indexOfDifference("", "") = -1
   * StringUtils.indexOfDifference("", "abc") = 0
   * StringUtils.indexOfDifference("abc", "") = 0
   * StringUtils.indexOfDifference("abc", "abc") = -1
   * StringUtils.indexOfDifference("ab", "abxyz") = 2
   * StringUtils.indexOfDifference("abcde", "abxyz") = 2
   * StringUtils.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;
  }
}

Compares two Strings, and returns the portion where they differ.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
public class Main {
  // Difference
  //-----------------------------------------------------------------------
  /**
   * 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.)
   *
   * For example,
   * <code>difference("i am a machine", "i am a robot") -> "robot"</code>.
   *
   * <pre>
   * StringUtils.difference(null, null) = null
   * StringUtils.difference("", "") = ""
   * StringUtils.difference("", "abc") = "abc"
   * StringUtils.difference("abc", "") = ""
   * StringUtils.difference("abc", "abc") = ""
   * StringUtils.difference("ab", "abxyz") = "xyz"
   * StringUtils.difference("abcde", "abxyz") = "xyz"
   * StringUtils.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 "";
      }
      return str2.substring(at);
  }
  /**
   * Compares two Strings, and returns the index at which the
   * Strings begin to differ.
   *
   * For example,
   * <code>indexOfDifference("i am a machine", "i am a robot") -> 7</code>
   *
   * <pre>
   * StringUtils.indexOfDifference(null, null) = -1
   * StringUtils.indexOfDifference("", "") = -1
   * StringUtils.indexOfDifference("", "abc") = 0
   * StringUtils.indexOfDifference("abc", "") = 0
   * StringUtils.indexOfDifference("abc", "abc") = -1
   * StringUtils.indexOfDifference("ab", "abxyz") = 2
   * StringUtils.indexOfDifference("abcde", "abxyz") = 2
   * StringUtils.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;
  }
}

Comparing Strings for Equality

public class MainClass {
  public static void main(String[] arg) {
    
    String a = "a";
    String b = "a";
    
    if(a.equals(b)){
      System.out.println("a==b");
    }else{
      System.out.println("a!=b");   
    }
  }
}

a==b

Compress 2 adjacent (single or double) quotes into a single (s or d) quote when found in the middle of a String.

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Properties;
/*
   Derby - Class org.apache.derby.iapi.util.PropertyUtil
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to you 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.
 */

public class Main {


  /**
   * Compress 2 adjacent (single or double) quotes into a single (s or d)
   * quote when found in the middle of a String.
   *
   * NOTE:  """" or """" will be compressed into "" or "".
   * This function assumes that the leading and trailing quote from a
   * string or delimited identifier have already been removed.
   * @param source string to be compressed
   * @param quotes string containing two single or double quotes.
   * @return String where quotes have been compressed
   */
  public static String compressQuotes(String source, String quotes)
  {
    String  result = source;
    int   index;
    /* Find the first occurrence of adjacent quotes. */
    index = result.indexOf(quotes);
    /* Replace each occurrence with a single quote and begin the
     * search for the next occurrence from where we left off.
     */
    while (index != -1) {
      result = result.substring(0, index + 1) +
           result.substring(index + 2);
      index = result.indexOf(quotes, index + 1);
    }
    return result;
  }
}

equals() and equalsIgnoreCase().

class equalsDemo {
  public static void main(String args[]) {
    String s1 = "Hello";
    String s2 = "Hello";
    String s3 = "Good-bye";
    String s4 = "HELLO";
    System.out.println(s1 + " equals " + s2 + " -> " + s1.equals(s2));
    System.out.println(s1 + " equals " + s3 + " -> " + s1.equals(s3));
    System.out.println(s1 + " equals " + s4 + " -> " + s1.equals(s4));
    System.out.println(s1 + " equalsIgnoreCase " + s4 + " -> " + s1.equalsIgnoreCase(s4));
  }
}

equals() vs ==

class EqualsNotEqualTo {
  public static void main(String args[]) {
    String s1 = "Hello";
    String s2 = new String(s1);
    System.out.println(s1 + " equals " + s2 + " -> " + s1.equals(s2));
    System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2));
  }
}

Region Matches

/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
public class RegionMatchesDemo {
  public static void main(String[] args) {
    String searchMe = "Green Eggs and Ham";
    String findMe = "Eggs";
    int searchMeLength = searchMe.length();
    int findMeLength = findMe.length();
    boolean foundIt = false;
    for (int i = 0; i <= (searchMeLength - findMeLength); i++) {
      if (searchMe.regionMatches(i, findMe, 0, findMeLength)) {
        foundIt = true;
        System.out.println(searchMe.substring(i, i + findMeLength));
        break;
      }
    }
    if (!foundIt)
      System.out.println("No match found.");
  }
}

Sequencing Strings

public class MainClass {
  public static void main(String[] arg) {
    
    String string1 = "abcde";
    String string2 = "bcdef";
    
    if(string1.rupareTo(string2) > 0) {
      System.out.println("greater");
    }
    if(string1.rupareTo(string2) == 0) {
      System.out.println("equal");
    }
    if(string1.rupareTo(string2) < 0) {
      System.out.println("less");
    }
  }
}

less

String length, charAt, equals

class StringDemo2 {
  public static void main(String args[]) {
    String strOb1 = "First String";
    String strOb2 = "Second String";
    String strOb3 = strOb1;
   
    System.out.println("Length of strOb1: " +
                       strOb1.length());
   
    System.out.println("Char at index 3 in strOb1: " +
                       strOb1.charAt(3));
   
    if(strOb1.equals(strOb2))
      System.out.println("strOb1 == strOb2");
    else
      System.out.println("strOb1 != strOb2");
   
    if(strOb1.equals(strOb3))
      System.out.println("strOb1 == strOb3");
    else
      System.out.println("strOb1 != strOb3");
  }
}

To check for equality between two strings ignoring the case

public class MainClass {
  public static void main(String[] arg) {
    
    String a = "a";
    String b = "A";
    
    if(a.equalsIgnoreCase(b)){
      System.out.println("a==b");
    }else{
      System.out.println("a!=b");   
    }
  }
}

a==b