1 package com.wjq.javautils; 2 3 import java.util.Arrays; 4 /** 5 * 6 * @author WangJingQian 7 * 8 */ 9 public class MyString implements java.io.Serializable, Comparable<MyString> { 10 11 private static final long serialVersionUID = 8954832331431321433L; 12 13 // 字符数组 14 private final char[] value; 15 // Default to 0 字符串缓存散列码 16 private int hash; 17 private static final int MAX_CHAR_COUNT = 65535; 18 19 // public MyString() 20 // 无参构造方法 因为MyString对象内容不可变，所以没有必要调用此方法，已省略。 21 22 // public MyString(MyString original) 23 // 创建字符串参数的副本 24 // 理由同上，已省略。 25 26 // 该构造方法创建字符数组参数对应的字符串对象 27 public MyString(char[] value) { 28 this.value = Arrays.copyOf(value, value.length); 29 } 30 31 // 该构造方法创建部分字符数组参数对应的字符串对象 32 // offset是起始位置，count是字符数量 33 public MyString(char[] value, int offset, int count) { 34 // 如果起始位置小于0 35 if (offset < 0) { 36 throw new StringIndexOutOfBoundsException(offset); 37 } 38 39 // 如果字符数量小于1 40 // 非null的空字符串对于MyString来说没有意义 41 if (count <= 0) { 42 throw new StringIndexOutOfBoundsException(count); 43 } 44 45 // Note: offset or count might be near -1>>>1. 46 // 如果起始位置与字符数量不符合逻辑 47 if (offset > value.length - count) { 48 throw new StringIndexOutOfBoundsException(offset + count); 49 } 50 51 // 创建字符数组副本 52 this.value = Arrays.copyOfRange(value, offset, offset + count); 53 } 54 55 // 获取字符串长度 56 public int length() { 57 return value.length; 58 } 59 60 // 判断字符串是否为空 61 public boolean isEmpty() { 62 return value.length == 0; 63 } 64 65 // 按下标获取单个字符 66 public char charAt(int index) { 67 // 避免获取属性操作码 68 char[] val = value; 69 // 如果下标<0或者下标>=字符数组长度 70 if ((index < 0) || (index >= val.length)) { 71 throw new StringIndexOutOfBoundsException(index); 72 } 73 74 return val[index]; 75 } 76 77 // 获取子串，把它拷贝到目标字符数组 78 public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { 79 // 如果源数组开始位置<0 80 if (srcBegin < 0) { 81 throw new StringIndexOutOfBoundsException(srcBegin); 82 } 83 84 char[] val = value; 85 // 如果源数组结束位置>字符数组长度 86 if (srcEnd > val.length) { 87 throw new StringIndexOutOfBoundsException(srcEnd); 88 } 89 // 如果源数组开始位置>=源数组结束位置 90 // 区间前闭后开，说明要拷贝的字符个数<=0 91 if (srcBegin >= srcEnd) { 92 throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); 93 } 94 95 System.arraycopy(val, srcBegin, dst, dstBegin, srcEnd - srcBegin); 96 } 97 98 // 比较两个引用指向的MyString对象内容是否相同 99 @Override 100 public boolean equals(Object anotherObject) { 101 // 如果两个引用指向的是同一个MyString对象 102 if (this == anotherObject) { 103 return true; 104 } 105 106 // 如果第2个引用指向的对象是MyString实例 107 if (anotherObject instanceof MyString) { 108 // 强制类型转换，Object对象没有value属性 109 MyString anotherMyString = (MyString) anotherObject; 110 111 char[] v1 = value; 112 char[] v2 = anotherMyString.value; 113 114 // 获取第1个引用指向的MyString对象的字符串长度 115 int len = v1.length; 116 117 // 如果两个字符串长度相等 118 if (len == v2.length) { 119 // 依次比较字符 120 for (int i = 0; i < len; i++) { 121 if (v1[i] != v2[i]) { 122 return false; 123 } 124 } 125 126 return true; 127 } 128 } 129 130 return false; 131 } 132 133 // 比较两个MyString对象的大小 134 @Override 135 public int compareTo(MyString anotherMyString) { 136 if (anotherMyString == null) { 137 return 1; 138 } 139 140 char[] v1 = value; 141 char[] v2 = anotherMyString.value; 142 143 // 获取字符数组长度 144 int len1 = v1.length; 145 int len2 = v2.length; 146 147 // 获取最小长度 148 int minLen = Math.min(len1, len2); 149 for (int i = 0; i < minLen; i++) { 150 char c1 = v1[i]; 151 char c2 = v2[i]; 152 153 // 如果两个字符不同 154 if (c1 != c2) { 155 return c1 - c2; 156 } 157 } 158 159 // 根据长度比较大小 160 return len1 - len2; 161 } 162 163 // 获取散列码 164 @Override 165 public int hashCode() { 166 int h = hash; 167 char[] val = value; 168 int len = val.length; 169 170 // 如果字符串缓存散列码为0并且字符串数组长度大于0 171 // 由于内容不可变，所以要避免重复计算，只计算一次 172 if (h == 0 && len > 0) { 173 // 遍历每个字符 174 for (int i = 0; i < len; i++) { 175 // 31 * h会被JVM优化成(h << 5) - h 176 h = 31 * h + val[i]; 177 } 178 179 // 保存计算后的字符串缓存散列码 180 hash = h; 181 } 182 183 return h; 184 } 185 186 // 截取字符串，获取子串对象 187 public MyString substring(int beginIndex) { 188 // 如果起始下标<0 189 if (beginIndex < 0) { 190 throw new StringIndexOutOfBoundsException(beginIndex); 191 } 192 193 char[] val = value; 194 // 获取截取长度 195 int subLen = val.length - beginIndex; 196 // 如果截取长度<=0 197 if (subLen <= 0) { 198 throw new StringIndexOutOfBoundsException(subLen); 199 } 200 201 return (beginIndex == 0) ? this : new MyString(val, beginIndex, subLen); 202 } 203 204 // 截取字符串，获取子串对象 205 public MyString substring(int beginIndex, int endIndex) { 206 // 如果起始下标<0 207 if (beginIndex < 0) { 208 throw new StringIndexOutOfBoundsException(beginIndex); 209 } 210 211 char[] val = value; 212 int len = val.length; 213 // 如果末尾下标>字符数组长度 214 if (endIndex > len) { 215 throw new StringIndexOutOfBoundsException(endIndex); 216 } 217 // 获取截取长度 218 int subLen = endIndex - beginIndex; 219 // 如果截取长度<=0 220 if (subLen <= 0) { 221 throw new StringIndexOutOfBoundsException(subLen); 222 } 223 224 return ((beginIndex == 0) && (endIndex == len)) ? this 225 : new MyString(val, beginIndex, subLen); 226 } 227 228 // 获取该字符串对应的字符数组，返回该数组副本 229 public char[] toCharArray() { 230 char[] val = value; 231 int len = val.length; 232 233 // Cannot use Arrays.copyOf because of class initialization order issues 234 // 不能用Arrays的copyOf方法，会出现类初始化顺序问题 235 char result[] = new char[len]; 236 // 创建字符数组副本 237 System.arraycopy(val, 0, result, 0, len); 238 239 return result; 240 } 241 242 // 判断是否包含指定前缀 243 public boolean startsWith(MyString prefix, int beginIndex) { 244 if (prefix == null) { 245 return false; 246 } 247 248 char[] val = value; 249 char[] prefixVal = prefix.value; 250 int len2 = prefixVal.length; 251 // Note: toffset might be near -1>>>1. 252 if ((beginIndex < 0) || (beginIndex + len2 > val.length)) { 253 return false; 254 } 255 256 for (int i = 0; i < len2; i++) { 257 if (val[beginIndex++] != prefixVal[i]) { 258 return false; 259 } 260 } 261 262 return true; 263 } 264 265 // 判断是否包含指定前缀，默认从0开始 266 public boolean startsWith(MyString prefix) { 267 return startsWith(prefix, 0); 268 } 269 270 // 判断是否包含指定后缀，从末尾开始 271 public boolean endsWith(MyString suffix) { 272 return startsWith(suffix, value.length - suffix.value.length); 273 } 274 275 // 获取子串在该字符串中第一次出现的位置 276 public int indexOf(MyString str) { 277 return indexOf(str, 0); 278 } 279 280 private static void setMoveLength(char[] v, int len, int[] moveLength) { 281 // 默认S中的任何字符均不出现在T中，那么每次移动的距离为T的长度 + 1 282 for (int i = 0; i < MAX_CHAR_COUNT; i++) { 283 moveLength[i] = len + 1; 284 } 285 286 // 查找能够出现在T中的字符，若一个字符出现多次，选择最右位置的字符，所以T的下标遍历从0开始 287 for (int i = 0; i < len; i++) { 288 moveLength[v[i]] = len - i; 289 } 290 } 291 292 // 通过Sunday算法获取子串在母串中第一次出现的位置 293 private int indexOfBySunday(char[] v1, int len1, char[] v2, int len2) { 294 int[] moveLength = new int[MAX_CHAR_COUNT]; 295 setMoveLength(v2, len2, moveLength); 296 297 // S遍历下标 298 int i = 0; 299 while (i < len1) { 300 int j = 0; 301 // 符合条件下标就继续右移 302 for (; j < len1 && i + j < len1 && v1[i + j] == v2[j]; j++){} 303 304 // 遍历结束，判断遍历情况 305 if (j >= len2) { 306 return i; 307 } 308 // 查找不成功，那么S下标右移 309 if (i + len2 >= len1) { 310 return -1; 311 } 312 313 i += moveLength[v1[i + len1]]; 314 } 315 316 return -1; 317 } 318 319 // 获取子串在该字符串中从起始位置开始第一次出现的位置 320 public int indexOf(MyString str, int fromIndex) { 321 if (str == null) { 322 return -1; 323 } 324 325 char[] v1 = value; 326 char[] v2 = str.value; 327 328 int len1 = v1.length; 329 int len2 = v2.length; 330 331 // 如果源字符串的开始位置非法或者起始位置<0 332 if (fromIndex < 0 || fromIndex >= len1) { 333 throw new IllegalArgumentException("源字符串相关参数非法"); 334 } 335 // 如果子串是空字符串 336 if (len2 == 0) { 337 return fromIndex; 338 } 339 // 如果子串不可能在当前字符串中出现 340 if (fromIndex + len2 > len1) { 341 return -1; 342 } 343 344 return indexOfBySunday(v1, len1, v2, len2); 345 } 346 347 // 判断当前字符串是否包含子串 348 public boolean contains(MyString myString) { 349 return indexOf(myString) > -1; 350 } 351 }