993 * is {@code true} if and only if this {@code String} represents the same 994 * sequence of characters as the specified {@code StringBuffer}. This method 995 * synchronizes on the {@code StringBuffer}. 996 * 997 * @param sb 998 * The {@code StringBuffer} to compare this {@code String} against 999 * 1000 * @return {@code true} if this {@code String} represents the same 1001 * sequence of characters as the specified {@code StringBuffer}, 1002 * {@code false} otherwise 1003 * 1004 * @since 1.4 1005 */ 1006 public boolean contentEquals(StringBuffer sb) { 1007 return contentEquals((CharSequence)sb); 1008 } 1009 1010 private boolean nonSyncContentEquals(AbstractStringBuilder sb) { 1011 char v1[] = value; 1012 char v2[] = sb.getValue(); 1013 int i = 0; 1014 int n = value.length; 1015 while (n-- != 0) { 1016 if (v1[i] != v2[i]) { 1017 return false; 1018 } 1019 i++; 1020 } 1021 return true; 1022 } 1023 1024 /** 1025 * Compares this string to the specified {@code CharSequence}. The 1026 * result is {@code true} if and only if this {@code String} represents the 1027 * same sequence of char values as the specified sequence. Note that if the 1028 * {@code CharSequence} is a {@code StringBuffer} then the method 1029 * synchronizes on it. 1030 * 1031 * @param cs 1032 * The sequence to compare this {@code String} against 1033 * 1034 * @return {@code true} if this {@code String} represents the same 1035 * sequence of char values as the specified sequence, {@code 1036 * false} otherwise 1037 * 1038 * @since 1.5 1039 */ 1040 public boolean contentEquals(CharSequence cs) { 1041 if (value.length != cs.length()) 1042 return false; 1043 // Argument is a StringBuffer, StringBuilder 1044 if (cs instanceof AbstractStringBuilder) { 1045 if (cs instanceof StringBuffer) { 1046 synchronized(cs) { 1047 return nonSyncContentEquals((AbstractStringBuilder)cs); 1048 } 1049 } else { 1050 return nonSyncContentEquals((AbstractStringBuilder)cs); 1051 } 1052 } 1053 // Argument is a String 1054 if (cs.equals(this)) 1055 return true; 1056 // Argument is a generic CharSequence 1057 char v1[] = value; 1058 int i = 0; 1059 int n = value.length; 1060 while (n-- != 0) { 1061 if (v1[i] != cs.charAt(i)) 1062 return false; 1063 i++; 1064 } 1065 return true; 1066 } 1067 1068 /** 1069 * Compares this {@code String} to another {@code String}, ignoring case 1070 * considerations. Two strings are considered equal ignoring case if they 1071 * are of the same length and corresponding characters in the two strings 1072 * are equal ignoring case. 1073 * 1074 * <p> Two characters {@code c1} and {@code c2} are considered the same 1075 * ignoring case if at least one of the following is true: 1076 * <ul> 1077 * <li> The two characters are the same (as compared by the 1078 * {@code ==} operator) 1079 * <li> Applying the method {@link 1080 * java.lang.Character#toUpperCase(char)} to each character 1081 * produces the same result 1082 * <li> Applying the method {@link 1083 * java.lang.Character#toLowerCase(char)} to each character | 993 * is {@code true} if and only if this {@code String} represents the same 994 * sequence of characters as the specified {@code StringBuffer}. This method 995 * synchronizes on the {@code StringBuffer}. 996 * 997 * @param sb 998 * The {@code StringBuffer} to compare this {@code String} against 999 * 1000 * @return {@code true} if this {@code String} represents the same 1001 * sequence of characters as the specified {@code StringBuffer}, 1002 * {@code false} otherwise 1003 * 1004 * @since 1.4 1005 */ 1006 public boolean contentEquals(StringBuffer sb) { 1007 return contentEquals((CharSequence)sb); 1008 } 1009 1010 private boolean nonSyncContentEquals(AbstractStringBuilder sb) { 1011 char v1[] = value; 1012 char v2[] = sb.getValue(); 1013 int n = v1.length; 1014 if (n != v2.length) { 1015 return false; 1016 } 1017 for (int i = 0; i < n; i++) { 1018 if (v1[i] != v2[i]) { 1019 return false; 1020 } 1021 } 1022 return true; 1023 } 1024 1025 /** 1026 * Compares this string to the specified {@code CharSequence}. The 1027 * result is {@code true} if and only if this {@code String} represents the 1028 * same sequence of char values as the specified sequence. Note that if the 1029 * {@code CharSequence} is a {@code StringBuffer} then the method 1030 * synchronizes on it. 1031 * 1032 * @param cs 1033 * The sequence to compare this {@code String} against 1034 * 1035 * @return {@code true} if this {@code String} represents the same 1036 * sequence of char values as the specified sequence, {@code 1037 * false} otherwise 1038 * 1039 * @since 1.5 1040 */ 1041 public boolean contentEquals(CharSequence cs) { 1042 // Argument is a StringBuffer, StringBuilder 1043 if (cs instanceof AbstractStringBuilder) { 1044 if (cs instanceof StringBuffer) { 1045 synchronized(cs) { 1046 return nonSyncContentEquals((AbstractStringBuilder)cs); 1047 } 1048 } else { 1049 return nonSyncContentEquals((AbstractStringBuilder)cs); 1050 } 1051 } 1052 // Argument is a String 1053 if (cs.equals(this)) 1054 return true; 1055 // Argument is a generic CharSequence 1056 char v1[] = value; 1057 int n = v1.length; 1058 if (n != cs.length()) 1059 return false; 1060 for (int i = 0; i < n; i++) { 1061 if (v1[i] != cs.charAt(i)) { 1062 return false; 1063 } 1064 } 1065 return true; 1066 } 1067 1068 /** 1069 * Compares this {@code String} to another {@code String}, ignoring case 1070 * considerations. Two strings are considered equal ignoring case if they 1071 * are of the same length and corresponding characters in the two strings 1072 * are equal ignoring case. 1073 * 1074 * <p> Two characters {@code c1} and {@code c2} are considered the same 1075 * ignoring case if at least one of the following is true: 1076 * <ul> 1077 * <li> The two characters are the same (as compared by the 1078 * {@code ==} operator) 1079 * <li> Applying the method {@link 1080 * java.lang.Character#toUpperCase(char)} to each character 1081 * produces the same result 1082 * <li> Applying the method {@link 1083 * java.lang.Character#toLowerCase(char)} to each character |