001 /*
002 * Written by Dawid Kurzyniec, based on code written by Doug Lea with assistance
003 * from members of JCP JSR-166 Expert Group. Released to the public domain,
004 * as explained at http://creativecommons.org/licenses/publicdomain.
005 */
006
007 /*
008 * Copied from backport-util-concurrent so that weaved code can also be used
009 * with 1.2 and 1.3 JVMs. Only 1.5+ methods are copied.
010 */
011 package net.sourceforge.retroweaver.runtime.java.util;
012
013 import java.lang.reflect.Array;
014 import java.util.ArrayList;
015 import java.util.List;
016
017 public class Arrays_ {
018
019 private Arrays_() {}
020
021 // Cloning
022
023 /**
024 * @since 1.6
025 */
026 public static Object[] copyOf(Object[] original, int newLength) {
027 return copyOf(original, newLength, original.getClass());
028 }
029
030 /**
031 * @since 1.6
032 */
033 public static Object[] copyOf(Object[] original, int newLength, Class newType) {
034 Object[] arr = (newType == Object[].class) ? new Object[newLength] :
035 (Object[])Array.newInstance(newType.getComponentType(), newLength);
036 int len = (original.length < newLength ? original.length : newLength);
037 System.arraycopy(original, 0, arr, 0, len);
038 return arr;
039 }
040
041 /**
042 * @since 1.6
043 */
044 public static byte[] copyOf(byte[] original, int newLength) {
045 byte[] arr = new byte[newLength];
046 int len = (original.length < newLength ? original.length : newLength);
047 System.arraycopy(original, 0, arr, 0, len);
048 return arr;
049 }
050
051 /**
052 * @since 1.6
053 */
054 public static short[] copyOf(short[] original, int newLength) {
055 short[] arr = new short[newLength];
056 int len = (original.length < newLength ? original.length : newLength);
057 System.arraycopy(original, 0, arr, 0, len);
058 return arr;
059 }
060
061 /**
062 * @since 1.6
063 */
064 public static int[] copyOf(int[] original, int newLength) {
065 int[] arr = new int[newLength];
066 int len = (original.length < newLength ? original.length : newLength);
067 System.arraycopy(original, 0, arr, 0, len);
068 return arr;
069 }
070
071 /**
072 * @since 1.6
073 */
074 public static long[] copyOf(long[] original, int newLength) {
075 long[] arr = new long[newLength];
076 int len = (original.length < newLength ? original.length : newLength);
077 System.arraycopy(original, 0, arr, 0, len);
078 return arr;
079 }
080
081 /**
082 * @since 1.6
083 */
084 public static char[] copyOf(char[] original, int newLength) {
085 char[] arr = new char[newLength];
086 int len = (original.length < newLength ? original.length : newLength);
087 System.arraycopy(original, 0, arr, 0, len);
088 return arr;
089 }
090
091 /**
092 * @since 1.6
093 */
094 public static float[] copyOf(float[] original, int newLength) {
095 float[] arr = new float[newLength];
096 int len = (original.length < newLength ? original.length : newLength);
097 System.arraycopy(original, 0, arr, 0, len);
098 return arr;
099 }
100
101 /**
102 * @since 1.6
103 */
104 public static double[] copyOf(double[] original, int newLength) {
105 double[] arr = new double[newLength];
106 int len = (original.length < newLength ? original.length : newLength);
107 System.arraycopy(original, 0, arr, 0, len);
108 return arr;
109 }
110
111 /**
112 * @since 1.6
113 */
114 public static boolean[] copyOf(boolean[] original, int newLength) {
115 boolean[] arr = new boolean[newLength];
116 int len = (original.length < newLength ? original.length : newLength);
117 System.arraycopy(original, 0, arr, 0, len);
118 return arr;
119 }
120
121 /**
122 * @since 1.6
123 */
124 public static Object[] copyOfRange(Object[] original, int from, int to) {
125 return copyOfRange(original, from, to, original.getClass());
126 }
127
128 /**
129 * @since 1.6
130 */
131 public static Object[] copyOfRange(Object[] original, int from, int to, Class newType) {
132 int newLength = to - from;
133 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
134 Object[] arr = (newType == Object[].class) ? new Object[newLength] :
135 (Object[])Array.newInstance(newType.getComponentType(), newLength);
136 int ceil = original.length-from;
137 int len = (ceil < newLength) ? ceil : newLength;
138 System.arraycopy(original, from, arr, 0, len);
139 return arr;
140 }
141
142 /**
143 * @since 1.6
144 */
145 public static byte[] copyOfRange(byte[] original, int from, int to) {
146 int newLength = to - from;
147 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
148 byte[] arr = new byte[newLength];
149 int ceil = original.length-from;
150 int len = (ceil < newLength) ? ceil : newLength;
151 System.arraycopy(original, from, arr, 0, len);
152 return arr;
153 }
154
155 /**
156 * @since 1.6
157 */
158 public static short[] copyOfRange(short[] original, int from, int to) {
159 int newLength = to - from;
160 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
161 short[] arr = new short[newLength];
162 int ceil = original.length-from;
163 int len = (ceil < newLength) ? ceil : newLength;
164 System.arraycopy(original, from, arr, 0, len);
165 return arr;
166 }
167
168 /**
169 * @since 1.6
170 */
171 public static int[] copyOfRange(int[] original, int from, int to) {
172 int newLength = to - from;
173 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
174 int[] arr = new int[newLength];
175 int ceil = original.length-from;
176 int len = (ceil < newLength) ? ceil : newLength;
177 System.arraycopy(original, from, arr, 0, len);
178 return arr;
179 }
180
181 /**
182 * @since 1.6
183 */
184 public static long[] copyOfRange(long[] original, int from, int to) {
185 int newLength = to - from;
186 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
187 long[] arr = new long[newLength];
188 int ceil = original.length-from;
189 int len = (ceil < newLength) ? ceil : newLength;
190 System.arraycopy(original, from, arr, 0, len);
191 return arr;
192 }
193
194 /**
195 * @since 1.6
196 */
197 public static char[] copyOfRange(char[] original, int from, int to) {
198 int newLength = to - from;
199 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
200 char[] arr = new char[newLength];
201 int ceil = original.length-from;
202 int len = (ceil < newLength) ? ceil : newLength;
203 System.arraycopy(original, from, arr, 0, len);
204 return arr;
205 }
206
207 /**
208 * @since 1.6
209 */
210 public static float[] copyOfRange(float[] original, int from, int to) {
211 int newLength = to - from;
212 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
213 float[] arr = new float[newLength];
214 int ceil = original.length-from;
215 int len = (ceil < newLength) ? ceil : newLength;
216 System.arraycopy(original, from, arr, 0, len);
217 return arr;
218 }
219
220 /**
221 * @since 1.6
222 */
223 public static double[] copyOfRange(double[] original, int from, int to) {
224 int newLength = to - from;
225 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
226 double[] arr = new double[newLength];
227 int ceil = original.length-from;
228 int len = (ceil < newLength) ? ceil : newLength;
229 System.arraycopy(original, from, arr, 0, len);
230 return arr;
231 }
232
233 /**
234 * @since 1.6
235 */
236 public static boolean[] copyOfRange(boolean[] original, int from, int to) {
237 int newLength = to - from;
238 if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
239 boolean[] arr = new boolean[newLength];
240 int ceil = original.length-from;
241 int len = (ceil < newLength) ? ceil : newLength;
242 System.arraycopy(original, from, arr, 0, len);
243 return arr;
244 }
245
246 /**
247 * @since 1.5
248 */
249 public static int hashCode(long a[]) {
250 if (a == null) return 0;
251 int hash = 1;
252 for (int i=0; i<a.length; i++) {
253 long e = a[i];
254 hash = 31*hash + (int)(e ^ (e >>> 32));
255 }
256 return hash;
257 }
258
259 /**
260 * @since 1.5
261 */
262 public static int hashCode(int a[]) {
263 if (a == null) return 0;
264 int hash = 1;
265 for (int i=0; i<a.length; i++) {
266 hash = 31*hash + a[i];
267 }
268 return hash;
269 }
270
271 /**
272 * @since 1.5
273 */
274 public static int hashCode(short a[]) {
275 if (a == null) return 0;
276 int hash = 1;
277 for (int i=0; i<a.length; i++) {
278 hash = 31*hash + a[i];
279 }
280 return hash;
281 }
282
283 /**
284 * @since 1.5
285 */
286 public static int hashCode(char a[]) {
287 if (a == null) return 0;
288 int hash = 1;
289 for (int i=0; i<a.length; i++) {
290 hash = 31*hash + a[i];
291 }
292 return hash;
293 }
294
295 /**
296 * @since 1.5
297 */
298 public static int hashCode(byte a[]) {
299 if (a == null) return 0;
300 int hash = 1;
301 for (int i=0; i<a.length; i++) {
302 hash = 31*hash + a[i];
303 }
304 return hash;
305 }
306
307 /**
308 * @since 1.5
309 */
310 public static int hashCode(boolean a[]) {
311 if (a == null) return 0;
312 int hash = 1;
313 for (int i=0; i<a.length; i++) {
314 hash = 31*hash + (a[i] ? 1231 : 1237);
315 }
316 return hash;
317 }
318
319 /**
320 * @since 1.5
321 */
322 public static int hashCode(float a[]) {
323 if (a == null) return 0;
324 int hash = 1;
325 for (int i=0; i<a.length; i++) {
326 hash = 31*hash + Float.floatToIntBits(a[i]);
327 }
328 return hash;
329 }
330
331 /**
332 * @since 1.5
333 */
334 public static int hashCode(double a[]) {
335 if (a == null) return 0;
336 int hash = 1;
337 for (int i=0; i<a.length; i++) {
338 long e = Double.doubleToLongBits(a[i]);
339 hash = 31*hash + (int)(e ^ (e >>> 32));
340 }
341 return hash;
342 }
343
344 /**
345 * @since 1.5
346 */
347 public static int hashCode(Object a[]) {
348 if (a == null) return 0;
349 int hash = 1;
350 for (int i=0; i<a.length; i++) {
351 Object e = a[i];
352 hash = 31*hash + (e == null ? 0 : e.hashCode());
353 }
354 return hash;
355 }
356
357 /**
358 * @since 1.5
359 */
360 public static int deepHashCode(Object a[]) {
361 if (a == null) return 0;
362 int hash = 1;
363 for (int i=0; i<a.length; i++) {
364 Object e = a[i];
365 hash = 31*hash +
366 (e instanceof Object[] ? deepHashCode((Object[])e) :
367 (e instanceof byte[] ? hashCode((byte[])e) :
368 (e instanceof short[] ? hashCode((short[])e) :
369 (e instanceof int[] ? hashCode((int[])e) :
370 (e instanceof long[] ? hashCode((long[])e) :
371 (e instanceof char[] ? hashCode((char[])e) :
372 (e instanceof boolean[] ? hashCode((boolean[])e) :
373 (e instanceof float[] ? hashCode((float[])e) :
374 (e instanceof double[] ? hashCode((double[])e) :
375 (e != null ? e.hashCode() : 0))))))))));
376 }
377 return hash;
378
379 }
380
381 /**
382 * @since 1.5
383 */
384 public static boolean deepEquals(Object[] a1, Object[] a2) {
385 if (a1 == a2) return true;
386 if (a1 == null || a2==null) return false;
387 int len = a1.length;
388 if (len != a2.length) return false;
389 for (int i = 0; i < len; i++) {
390 Object e1 = a1[i];
391 Object e2 = a2[i];
392 if (e1 == e2) continue;
393 if (e1 == null) return false;
394 boolean eq =
395 (e1.getClass() != e2.getClass() || e1.getClass().isArray()) ?
396 e1.equals(e2) :
397 (e1 instanceof Object[] && e2 instanceof Object[]) ?
398 deepEquals((Object[])e1, (Object[])e2) :
399 (e1 instanceof byte[] && e2 instanceof byte[]) ?
400 java.util.Arrays.equals((byte[])e1, (byte[])e2) :
401 (e1 instanceof short[] && e2 instanceof short[]) ?
402 java.util.Arrays.equals((short[])e1, (short[])e2) :
403 (e1 instanceof int[] && e2 instanceof int[]) ?
404 java.util.Arrays. equals((int[])e1, (int[])e2) :
405 (e1 instanceof long[] && e2 instanceof long[]) ?
406 java.util.Arrays.equals((long[])e1, (long[])e2) :
407 (e1 instanceof char[] && e2 instanceof char[]) ?
408 java.util.Arrays.equals((char[])e1, (char[])e2) :
409 (e1 instanceof boolean[] && e2 instanceof boolean[]) ?
410 java.util.Arrays.equals((boolean[])e1, (boolean[])e2) :
411 (e1 instanceof float[] && e2 instanceof float[]) ?
412 java.util.Arrays.equals((float[])e1, (float[])e2) :
413 (e1 instanceof double[] && e2 instanceof double[]) ?
414 java.util.Arrays.equals((double[])e1, (double[])e2) :
415 e1.equals(e2);
416
417 if (!eq) return false;
418 }
419 return true;
420 }
421
422 /**
423 * @since 1.5
424 */
425 public static String toString(long[] a) {
426 if (a == null) return "null";
427 if (a.length == 0) return "[]";
428 StringBuffer buf = new StringBuffer();
429 buf.append('[').append(a[0]);
430 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
431 buf.append(']');
432 return buf.toString();
433 }
434
435 /**
436 * @since 1.5
437 */
438 public static String toString(int[] a) {
439 if (a == null) return "null";
440 if (a.length == 0) return "[]";
441 StringBuffer buf = new StringBuffer();
442 buf.append('[').append(a[0]);
443 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
444 buf.append(']');
445 return buf.toString();
446 }
447
448 /**
449 * @since 1.5
450 */
451 public static String toString(short[] a) {
452 if (a == null) return "null";
453 if (a.length == 0) return "[]";
454 StringBuffer buf = new StringBuffer();
455 buf.append('[').append(a[0]);
456 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
457 buf.append(']');
458 return buf.toString();
459 }
460
461 /**
462 * @since 1.5
463 */
464 public static String toString(char[] a) {
465 if (a == null) return "null";
466 if (a.length == 0) return "[]";
467 StringBuffer buf = new StringBuffer();
468 buf.append('[').append(a[0]);
469 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
470 buf.append(']');
471 return buf.toString();
472 }
473
474 /**
475 * @since 1.5
476 */
477 public static String toString(byte[] a) {
478 if (a == null) return "null";
479 if (a.length == 0) return "[]";
480 StringBuffer buf = new StringBuffer();
481 buf.append('[').append(a[0]);
482 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
483 buf.append(']');
484 return buf.toString();
485 }
486
487 /**
488 * @since 1.5
489 */
490 public static String toString(boolean[] a) {
491 if (a == null) return "null";
492 if (a.length == 0) return "[]";
493 StringBuffer buf = new StringBuffer();
494 buf.append('[').append(a[0]);
495 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
496 buf.append(']');
497 return buf.toString();
498 }
499
500 /**
501 * @since 1.5
502 */
503 public static String toString(float[] a) {
504 if (a == null) return "null";
505 if (a.length == 0) return "[]";
506 StringBuffer buf = new StringBuffer();
507 buf.append('[').append(a[0]);
508 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
509 buf.append(']');
510 return buf.toString();
511 }
512
513 /**
514 * @since 1.5
515 */
516 public static String toString(double[] a) {
517 if (a == null) return "null";
518 if (a.length == 0) return "[]";
519 StringBuffer buf = new StringBuffer();
520 buf.append('[').append(a[0]);
521 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
522 buf.append(']');
523 return buf.toString();
524 }
525
526 /**
527 * @since 1.5
528 */
529 public static String toString(Object[] a) {
530 if (a == null) return "null";
531 if (a.length == 0) return "[]";
532 StringBuffer buf = new StringBuffer();
533 buf.append('[').append(a[0]);
534 for (int i=1; i<a.length; i++) buf.append(", ").append(a[i]);
535 buf.append(']');
536 return buf.toString();
537 }
538
539 /**
540 * @since 1.5
541 */
542 public static String deepToString(Object[] a) {
543 if (a == null) return "null";
544 StringBuffer buf = new StringBuffer();
545 deepToString(a, buf, new ArrayList());
546 return buf.toString();
547 }
548
549 private static void deepToString(Object[] a, StringBuffer buf, List seen) {
550 seen.add(a);
551 buf.append('[');
552 for (int i = 0; i < a.length; i++) {
553 if (i>0) buf.append(", ");
554 Object e = a[i];
555 if (e == null) {
556 buf.append("null");
557 }
558 else if (!e.getClass().isArray()) {
559 buf.append(e.toString());
560 }
561 else if (e instanceof Object[]) {
562 if (seen.contains(e)) buf.append("[...]");
563 else deepToString((Object[])e, buf, seen);
564 }
565 else {
566 // primitive arr
567 buf.append(
568 (e instanceof byte[]) ? toString( (byte[]) e) :
569 (e instanceof short[]) ? toString( (short[]) e) :
570 (e instanceof int[]) ? toString( (int[]) e) :
571 (e instanceof long[]) ? toString( (long[]) e) :
572 (e instanceof char[]) ? toString( (char[]) e) :
573 (e instanceof boolean[]) ? toString( (boolean[]) e) :
574 (e instanceof float[]) ? toString( (float[]) e) :
575 (e instanceof double[]) ? toString( (double[]) e) : "");
576 }
577 }
578 buf.append(']');
579 seen.remove(seen.size()-1);
580 }
581 }